@danieltmn/tamnora 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -5,6 +5,25 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.23.0] - 2026-10-28
+
+### Cambios
+
+- feat(ajustes): expone maxOutputTokens y promptCaching en la pestana Limites
+- feat(consola): el logo acompana el esquema del tema, y el browser puede emular color y correr un pre-script
+- refactor(consola): extrae las tarjetas de chat.js a cards.js
+- test(consola): valida el grafo de modulos y la carga real en navegador headless
+- feat: canary de servicios vivos en pnpm y en cron de GitHub
+- feat(doctor): --voz prueba el servicio de voz y distingue voz rota de servicio caido
+- fix(voz): reintenta un fallo de conexion de la sintesis, sin reintentar rechazos
+- fix(test): el arranque de procs espera la condicion, no un tiempo fijo
+- refactor(consola): extrae el formato puro de chat.js a chatFormat.js, con tests
+- refactor(telegram): parte el canal en api, text, permissions, media, projects, run y commands
+- fix(voz): EDGE_VERSION acompana al endpoint nuevo y agrega un canary de servicios vivos
+- chore: quita document.md desactualizado (decia 0.11.3) y normaliza los fin de linea
+- fix: node:sqlite necesita Node >= 22.13 y el warning experimental se filtra en los bins
+- refactor(consola): unifica la navegacion en el menu mas y devuelve el foco al cerrarlo
+
 ## [0.22.0] - 2026-10-22
 
 ### Cambios

package/README.md

@@ -40,7 +40,7 @@ npx @danieltmn/tamnora --help
 npm i -g @danieltmn/tamnora
 ```
 
-Requiere **Node.js >= 22.5** (por `node:sqlite`).
+Requiere **Node.js >= 22.13** (por `node:sqlite`).
 
 ## Uso rapido
 
@@ -184,6 +184,8 @@ Los tres se renderizan en vivo y se reconstruyen al recargar la consola.
   server resume lo viejo y sigue con el resumen + lo reciente, sin borrar nada.
 - **`max_tokens` por ronda** (`maxOutputTokens`) y **prompt caching** opt-in
   (`promptCaching`, `cache_control` en Anthropic y `prompt_cache_key` en OpenAI).
+  Ambos se ajustan en la pestaña **Límites** de la consola o con `PUT /api/settings`
+  (no solo por `tamnora.json`).
 
 ### Hooks y plugins
 

package/SECURITY.md

@@ -59,7 +59,7 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
 
 ## Buenas practicas
 
-- Mantene Node actualizado (`node:sqlite` requiere Node >= 22.5).
+- Mantene Node actualizado (`node:sqlite` requiere Node >= 22.13).
 - No commitees `.env`, `tamnora.json`, bases `.db` ni `.npmrc`; estan en
   `.gitignore`.
 - Rota cualquier credencial que se haya compartido en texto plano.

package/harness/packages/cli/bin/tamnora.mjs

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
-import { runCli } from '../src/cli.js';
+// node:sqlite sigue siendo "experimental" en Node 22, que avisa aunque ande. El
+// aviso no le aporta nada al usuario, asi que se filtra aca (lo que no sea un
+// warning de Node se imprime igual).
+process.on('warning', (warning) => {
+  if (warning.name !== 'ExperimentalWarning') console.warn(warning.stack ?? warning);
+});
+const { runCli } = await import('../src/cli.js');
 
 runCli(process.argv.slice(2))
   .then((code) => {

package/harness/packages/cli/src/commands/doctor.js

@@ -10,23 +10,28 @@ import {
   readPackageVersion,
   compareVersions,
   fetchLatestVersion,
+  sintetizar,
 } from '../../../core/src/index.js';
 import { parse } from '../lib/util.js';
 import { pidAlive, readRuntime } from '../lib/daemon.js';
 
-const OPTIONS = { home: { type: 'string' }, help: { type: 'boolean', short: 'h' } };
+const OPTIONS = {
+  home: { type: 'string' },
+  voz: { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
 
 export async function doctorCommand(argv) {
   const { values } = parse(argv, OPTIONS);
   if (values.help) {
-    console.log('Uso: tamnora doctor [--home <path>]\n\nVerifica Node, la casa, el puerto y la base.');
+    console.log('Uso: tamnora doctor [--home <path>] [--voz]\n\nVerifica Node, la casa, el puerto y la base. Con --voz prueba tambien el servicio de voz.');
     return 0;
   }
 
   const [maj, min] = process.versions.node.split('.').map((n) => parseInt(n, 10));
-  const nodeOk = maj > 22 || (maj === 22 && min >= 5);
+  const nodeOk = maj > 22 || (maj === 22 && min >= 13);
   const checks = [
-    [`Node ${process.versions.node}`, nodeOk, nodeOk ? '' : 'requiere Node >= 22.5 (node:sqlite)'],
+    [`Node ${process.versions.node}`, nodeOk, nodeOk ? '' : 'requiere Node >= 22.13 (node:sqlite)'],
   ];
 
   const cfgOk = homeExists();
@@ -69,6 +74,10 @@ export async function doctorCommand(argv) {
   if (serverLive) checks.push([`server (pid ${rt.pid})`, true, rt.url || '']);
   checks.push([`logs`, true, serverLogPath()]);
 
+  // El servicio de voz es un servicio externo sin contrato: se prueba solo si se
+  // pide, porque toca la red y tarda un par de segundos.
+  if (values.voz) checks.push(await checkVoz());
+
   let ok = true;
   for (const [name, pass, hint] of checks) {
     console.log(`${pass ? '  OK  ' : ' FALTA'}  ${name}${hint ? `  ->  ${hint}` : ''}`);
@@ -85,3 +94,32 @@ function isPortFree(port, host) {
     server.listen(port, host);
   });
 }
+
+/**
+ * Prueba el servicio de voz sintetizando una frase. Si la voz configurada no
+ * responde, se prueba la voz por defecto: asi se distingue "el servicio esta
+ * caido" de "esta voz ya no existe".
+ *
+ * Entre intentos hay que esperar: el servicio se queja (fallo de handshake) si
+ * se le abren varias conexiones seguidas, y sin la pausa un fallo transitorio
+ * hace parecer que la voz no existe.
+ */
+async function checkVoz() {
+  const voz = readApp()?.tts?.voice || '';
+  const etiqueta = voz ? `voz (${voz})` : 'voz';
+  const esperar = () => new Promise((resolve) => setTimeout(resolve, 3000));
+  try {
+    const mp3 = await sintetizar('prueba de voz', voz ? { voice: voz } : {});
+    return [etiqueta, true, `${mp3.length} bytes`];
+  } catch (error) {
+    const detalle = error?.message ?? error;
+    if (!voz) return [etiqueta, false, `el servicio no responde: ${detalle}`];
+    await esperar();
+    try {
+      await sintetizar('prueba de voz');
+      return [etiqueta, false, `esa voz no responde (${detalle}); la voz por defecto si: cambia la voz en Ajustes`];
+    } catch {
+      return [etiqueta, false, `el servicio no responde: ${detalle}`];
+    }
+  }
+}

package/harness/packages/cli/src/commands/repl.js

@@ -166,6 +166,7 @@ export async function replCommand(argv) {
         maxTokens: config.maxTokens,
         maxDurationMs: config.maxDurationMs,
         maxOutputTokens: config.maxOutputTokens,
+        promptCaching: config.promptCaching === true,
         tools: toolDefs,
         execute,
         onEvent: printer.onEvent,

package/harness/packages/cli/src/commands/run.js

@@ -119,6 +119,7 @@ export async function runCommand(argv) {
       maxTokens: config.maxTokens,
       maxDurationMs: config.maxDurationMs,
       maxOutputTokens: config.maxOutputTokens,
+      promptCaching: config.promptCaching === true,
       signal: controller.signal,
       tools: toolDefs,
       execute,

package/harness/packages/cli/src/commands/tui.js

@@ -101,6 +101,7 @@ export async function tuiCommand(argv) {
     maxTokens: config.maxTokens,
     maxDurationMs: config.maxDurationMs,
     maxOutputTokens: config.maxOutputTokens,
+    promptCaching: config.promptCaching === true,
     toolOptions: {
       root: cwd,
       enabled: enabledFor(mode),

package/harness/packages/cli/src/lib/runtime.js

@@ -77,6 +77,7 @@ export async function runTurn({
   maxTokens,
   maxDurationMs,
   maxOutputTokens,
+  promptCaching,
   stallWarnMs,
   signal,
   execute,
@@ -104,6 +105,7 @@ export async function runTurn({
     maxTokens,
     maxDurationMs,
     maxOutputTokens,
+    promptCaching,
     stallWarnMs,
     signal,
     onEvent,

package/harness/packages/cli/src/tui/app.js

@@ -24,6 +24,7 @@ export function runTui({
   maxTokens,
   maxDurationMs,
   maxOutputTokens,
+  promptCaching,
   toolOptions,
   store,
   sessionId,
@@ -207,6 +208,7 @@ export function runTui({
         maxTokens,
         maxDurationMs,
         maxOutputTokens,
+        promptCaching,
         signal: controller.signal,
         tools: toolset.definitions,
         execute: toolset.execute,

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

@@ -53,7 +53,7 @@ function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function assertAllowedUrl(raw) {
+function assertAllowedUrl(raw, allowPrivate = false) {
   let parsed;
   try {
     parsed = new URL(String(raw));
@@ -63,16 +63,18 @@ function assertAllowedUrl(raw) {
   if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
     throw new Error(`Solo se admite http(s): ${raw}`);
   }
-  if (isBlockedHost(parsed.hostname)) {
+  // `allowPrivate` es para abrir nuestro **propio** server local (el smoke test
+  // de la consola). Las tools no lo usan: ahi la guarda anti-SSRF es total.
+  if (!allowPrivate && isBlockedHost(parsed.hostname)) {
     throw new Error(`host bloqueado (${normalizeHost(parsed.hostname)}).`);
   }
 }
 
-function isBlockedNavigation(raw) {
+function isBlockedNavigation(raw, allowPrivate = false) {
   try {
     const parsed = new URL(String(raw));
     if (!parsed.hostname) return parsed.protocol === 'file:';
-    return isBlockedHost(parsed.hostname);
+    return !allowPrivate && isBlockedHost(parsed.hostname);
   } catch {
     return false;
   }
@@ -196,7 +198,7 @@ function describeArg(arg) {
   return String(arg.type ?? '');
 }
 
-async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true } = {}) {
+async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true, allowPrivate = false } = {}) {
   const cdp = new CdpConnection(new WebSocket(wsUrl));
   await cdp.open();
   const { targetId } = await cdp.send('Target.createTarget', { url: 'about:blank' });
@@ -240,7 +242,7 @@ async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true
     if (message.method !== 'Page.frameNavigated' || message.sessionId !== sessionId) return;
     const frame = message.params?.frame;
     if (!frame || frame.parentId || !frame.url || frame.url === 'about:blank') return;
-    if (isBlockedNavigation(frame.url)) blockedUrl = frame.url;
+    if (isBlockedNavigation(frame.url, allowPrivate)) blockedUrl = frame.url;
   });
   try {
     await cdp.send('Page.navigate', { url }, sessionId);
@@ -256,7 +258,7 @@ async function openPage(wsUrl, url, { timeoutMs = 20000, collectMessages = true
         sessionId
       );
       const finalUrl = String(result?.value ?? '');
-      if (finalUrl && isBlockedNavigation(finalUrl)) blockedUrl = finalUrl;
+      if (finalUrl && isBlockedNavigation(finalUrl, allowPrivate)) blockedUrl = finalUrl;
     } catch {
       /* sin runtime disponible: nos quedamos con los eventos de navegacion */
     }
@@ -287,7 +289,7 @@ function killBrowser(child) {
 }
 
 async function withBrowser(url, options, run) {
-  assertAllowedUrl(url);
+  assertAllowedUrl(url, options.allowPrivate === true);
   const bin = findBrowserPath();
   if (!bin) {
     throw new Error('no encontré Chrome/Edge/Chromium; definí TAMNORA_BROWSER con la ruta al ejecutable');
@@ -315,11 +317,23 @@ async function withBrowser(url, options, run) {
 /**
  * Captura PNG de una URL. Devuelve `{ buffer, width, height, consoleErrors }`.
  */
-export async function captureScreenshot(url, { fullPage = false, width = 1280, height = 720, waitMs = 800, timeoutMs } = {}) {
-  return withBrowser(url, { timeoutMs, collectMessages: true }, async ({ cdp, sessionId, messages }) => {
+export async function captureScreenshot(url, { fullPage = false, width = 1280, height = 720, waitMs = 800, timeoutMs, allowPrivate = false, preScript = '', colorScheme = '' } = {}) {
+  return withBrowser(url, { timeoutMs, collectMessages: true, allowPrivate }, async ({ cdp, sessionId, messages }) => {
     await cdp
       .send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: false }, sessionId)
       .catch(() => {});
+    // Para paginas que se tematizan con `prefers-color-scheme` (el sitio, no la
+    // consola): emula el esquema del sistema.
+    if (colorScheme) {
+      await cdp.send('Emulation.setEmulatedMedia', { features: [{ name: 'prefers-color-scheme', value: colorScheme }] }, sessionId).catch(() => {});
+    }
+    let preScriptResult = null;
+    if (preScript) {
+      const evaluado = await cdp
+        .send('Runtime.evaluate', { expression: preScript, returnByValue: true, awaitPromise: true }, sessionId)
+        .catch(() => null);
+      preScriptResult = evaluado?.result?.value ?? evaluado?.value ?? null;
+    }
     if (waitMs > 0) await delay(waitMs);
     const shot = await cdp.send(
       'Page.captureScreenshot',
@@ -327,15 +341,15 @@ export async function captureScreenshot(url, { fullPage = false, width = 1280, h
       sessionId
     );
     const errors = messages.filter((m) => m.level === 'error');
-    return { buffer: Buffer.from(shot.data, 'base64'), width, height, consoleErrors: errors };
+    return { buffer: Buffer.from(shot.data, 'base64'), width, height, consoleErrors: errors, preScriptResult };
   });
 }
 
 /**
  * Abre una URL y devuelve los mensajes de consola. `{ messages, errors }`.
  */
-export async function readConsole(url, { waitMs = 1500, timeoutMs } = {}) {
-  return withBrowser(url, { timeoutMs, collectMessages: true }, async ({ messages }) => {
+export async function readConsole(url, { waitMs = 1500, timeoutMs, allowPrivate = false } = {}) {
+  return withBrowser(url, { timeoutMs, collectMessages: true, allowPrivate }, async ({ messages }) => {
     if (waitMs > 0) await delay(waitMs);
     const errors = messages.filter((m) => m.level === 'error');
     return { messages, errors };

package/harness/packages/core/src/tts/edge.js

@@ -18,8 +18,10 @@ import { createHash, randomBytes } from 'node:crypto';
 /** Token publico del cliente de Edge (via en el codigo del navegador). */
 export const TRUSTED_CLIENT_TOKEN = '6A5AA1D4EAFF4E9FB37E23D68491D6F4';
 
-/** Version de Edge que declaramos. Si el servicio empieza a rechazar, subirla. */
-export const EDGE_VERSION = process.env.TTS_EDGE_VERSION ?? '143.0.3650.75';
+/** Version de Edge que declaramos (UA + `Sec-MS-GEC-Version`). Tiene que acompanar
+ * al endpoint que se use: el de `api.msedgeservices.com` espera un Edge moderno.
+ * Si el servicio empieza a rechazar, subirla o pisarla con `TTS_EDGE_VERSION`. */
+export const EDGE_VERSION = process.env.TTS_EDGE_VERSION ?? '155.0.3000.102';
 
 /** Formato por defecto: MP3 a 24 kHz, 48 kbps, mono (CBR). */
 export const FORMATO_POR_DEFECTO = 'audio-24khz-48kbitrate-mono-mp3';
@@ -122,6 +124,30 @@ function marcaDeTiempo(ahora = new Date()) {
  * @returns {Promise<Buffer>} MP3.
  */
 export function sintetizar(texto, opciones = {}) {
+  // Estas validaciones fallan sin abrir socket, asi que las decide el llamador
+  // (y se propagan igual que siempre: en seco, no como promesa rechazada).
+  const contenido = String(texto ?? '').slice(0, MAX_TEXTO).trim();
+  if (!contenido) throw new Error('El texto está vacío: no hay nada que sintetizar.');
+  if (opciones?.signal?.aborted) throw new Error('La síntesis se canceló antes de empezar.');
+  return reintentar(() => sintetizarUnaVez(texto, opciones), opciones);
+}
+
+/** Reintenta mientras el fallo sea del transporte y no haya llegado audio. */
+function reintentar(intento, opciones) {
+  const reintentos = Math.max(0, Number(opciones?.reintentos ?? 1));
+  const pausaMs = Math.max(0, Number(opciones?.pausaReintentoMs ?? 500));
+  return new Promise((resolve, reject) => {
+    const correr = (restante) => {
+      intento().then(resolve, (error) => {
+        if (!restante || !error?.reintento) return reject(error);
+        setTimeout(() => correr(restante - 1), pausaMs);
+      });
+    };
+    correr(reintentos);
+  });
+}
+
+function sintetizarUnaVez(texto, opciones = {}) {
   const {
     voice: voz = VOZ_POR_DEFECTO,
     rate = '+0%',
@@ -133,14 +159,13 @@ export function sintetizar(texto, opciones = {}) {
   } = opciones;
 
   const contenido = String(texto ?? '').slice(0, MAX_TEXTO).trim();
-  if (!contenido) throw new Error('El texto está vacío: no hay nada que sintetizar.');
-  if (signal?.aborted) throw new Error('La síntesis se canceló antes de empezar.');
   if (typeof WebSocket === 'undefined') {
     throw new Error('Este Node no trae WebSocket global (se necesita Node 22+).');
   }
 
   return new Promise((resolve, reject) => {
     const chunks = [];
+    let abrio = false;
     const ws = new WebSocket(urlSintesis(), {
       origin: ORIGEN_EDGE,
       headers: {
@@ -166,6 +191,10 @@ export function sintetizar(texto, opciones = {}) {
       } catch {
         // ya cerrado
       }
+      // Reintenta solo si el fallo fue del transporte antes de llegar audio: un
+      // corte a mitad de stream seria un audio truncado, y el servicio que
+      // rechaza un formato lo va a volver a rechazar.
+      if (!abrio && chunks.length === 0 && !signal?.aborted) error.reintento = true;
       reject(error);
     };
 
@@ -180,6 +209,7 @@ export function sintetizar(texto, opciones = {}) {
     vigilar();
 
     ws.addEventListener('open', () => {
+      abrio = true;
       ws.send(
         `X-Timestamp:${marcaDeTiempo()}\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
           JSON.stringify({

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

@@ -376,6 +376,24 @@ test('runAgent propaga maxOutputTokens al proveedor', async () => {
   assert.deepEqual(seen, [1234]);
 });
 
+test('runAgent propaga promptCaching al proveedor', async () => {
+  const seen = [];
+  const provider = {
+    async streamChat(_config, params) {
+      seen.push(params.promptCaching);
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    promptCaching: true,
+  });
+  assert.deepEqual(seen, [true]);
+});
+
 test('runAgent emite el ciclo de vida (run.start/end, tool.before/after)', async () => {
   const life = [];
   const provider = {

package/harness/packages/core/test/servicios-vivos.test.js

@@ -0,0 +1,71 @@
+// Canary de los servicios no oficiales (TTS de Edge y STT de Google). Son los
+// unicos que dependen de un servicio externo sin contrato: si cambian el
+// protocolo o la clave, el unico sintoma real es un 403. Los tests con mocks
+// no lo ven, asi que estos prueban el camino real, pero solo con TAMNORA_LIVE=1
+// (piden red y a servicios que pueden estar caidos o barrerte).
+//
+//   TAMNORA_LIVE=1 node --test harness/packages/core/test/servicios-vivos.test.js
+//
+// El servicio de Edge solo devuelve MP3 (los formatos riff-/raw- cierran la
+// conexion antes de mandar audio), asi que el round trip se hace con ffmpeg en
+// el medio para convertir el MP3 a WAV.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { generarSecMsGec, listarVoces, reconocerGoogle, sintetizar, VOZ_POR_DEFECTO } from '../src/index.js';
+
+const LIVE = process.env.TAMNORA_LIVE === '1';
+const liveOpts = LIVE ? {} : { skip: 'red real: correr con TAMNORA_LIVE=1' };
+
+/** MP3 -> WAV 16 kHz mono con ffmpeg. `null` si no hay ffmpeg. */
+async function mp3AWav(mp3) {
+  return new Promise((resolve) => {
+    const hijo = spawn(
+      'ffmpeg',
+      ['-hide_banner', '-loglevel', 'error', '-i', 'pipe:0', '-f', 'wav', '-ar', '16000', '-ac', '1', 'pipe:1'],
+      { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true },
+    );
+    const salida = [];
+    hijo.stdout.on('data', (b) => salida.push(b));
+    hijo.on('error', () => resolve(null));
+    hijo.on('close', (code) => resolve(code === 0 && salida.length ? Buffer.concat(salida) : null));
+    hijo.stdin.on('error', () => {});
+    hijo.stdin.end(mp3);
+  });
+}
+
+test('sintetizar entrega un MP3 real (canary)', liveOpts, async () => {
+  const mp3 = await sintetizar('hola', { voice: VOZ_POR_DEFECTO });
+  assert.ok(Buffer.isBuffer(mp3), 'deberia devolver un Buffer');
+  assert.ok(mp3.length > 1000, `MP3 demasiado chico: ${mp3.length} bytes`);
+  assert.equal(mp3[0], 0xff, 'sin frame de MP3: el servicio cambio de formato');
+});
+
+test('el catalogo de voces responde con la voz por defecto (canary)', liveOpts, async () => {
+  await esperar(3000);
+  const voces = await listarVoces('es-');
+  assert.ok(Array.isArray(voces) && voces.length > 0, 'el catalogo vino vacio');
+  const nombres = voces.map((v) => v.ShortName ?? v.name ?? v);
+  assert.ok(nombres.includes(VOZ_POR_DEFECTO), `falta ${VOZ_POR_DEFECTO} en ${JSON.stringify(nombres.slice(0, 3))}`);
+});
+
+/** Espera ms antes de abrir otro socket: el servicio de Edge se queja (fallo de
+ * handshake) si se le abren varias conexiones seguidas. */
+const esperar = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+test('ida y vuelta: el audio del TTS se entiende en el STT (canary)', liveOpts, async () => {
+  await esperar(3000);
+  const mp3 = await sintetizar('hola mundo de prueba', { voice: VOZ_POR_DEFECTO });
+  const wav = await mp3AWav(mp3);
+  if (!wav) {
+    // Sin ffmpeg no hay WAV con el que hacer el viaje: se probo arriba el camino
+    // del TTS, que es el que mas se rompe.
+    return;
+  }
+  const texto = await reconocerGoogle(wav, { lang: 'es-AR' });
+  assert.ok(/hola/.test(texto), `se entiende otra cosa: "${texto}"`);
+});
+
+test('el anti-abuso de Edge sigue generando tokens de 64 hex', () => {
+  assert.match(generarSecMsGec(), /^[0-9A-F]{64}$/);
+});

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

@@ -39,3 +39,84 @@ test('sintetizar recorta el texto al tope del servicio', () => {
   const largo = 'x'.repeat(MAX_TEXTO + 100);
   assert.throws(() => sintetizar(largo, { signal: controller.signal }), /cancel/);
 });
+
+/** WebSocket falso: `guion` dice que hace cada intento ('error' o 'audio'). */
+function mockWebSocket(guion) {
+  const original = globalThis.WebSocket;
+  let intentos = 0;
+  globalThis.WebSocket = class {
+    constructor() {
+      this.listeners = new Map();
+      this.binaryType = 'arraybuffer';
+      const paso = guion[Math.min(intentos, guion.length - 1)];
+      intentos += 1;
+      setTimeout(() => {
+        // 'fallo' nunca llega a abrirse (fallo de transporte); 'error' abre la
+        // conexion y recien ahi falla (el servicio rechaza algo).
+        if (paso !== 'fallo') this.fire('open', {});
+        if (paso === 'error' || paso === 'fallo') {
+          this.fire('error', {});
+          return;
+        }
+        this.fire('message', new TextEncoder().encode('Path:audio\r\nFRAME').buffer);
+        this.fire('message', 'X-RequestId:1\r\nPath:turn.end\r\n');
+      }, 0);
+    }
+    addEventListener(type, fn) {
+      if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+      this.listeners.get(type).add(fn);
+    }
+    removeEventListener() {}
+    send() {}
+    close() {
+      this.fire('close', {});
+    }
+    fire(type, arg) {
+      for (const fn of this.listeners.get(type) ?? []) fn({ data: arg, message: 'fake' });
+    }
+  };
+  return {
+    get intentos() {
+      return intentos;
+    },
+    restaurar: () => {
+      globalThis.WebSocket = original;
+    },
+  };
+}
+
+test('sintetizar reintenta un fallo de conexion y devuelve el audio', async () => {
+  const mock = mockWebSocket(['fallo', 'audio']);
+  try {
+    const mp3 = await sintetizar('hola', { pausaReintentoMs: 5 });
+    assert.equal(mp3.toString(), 'FRAME');
+    assert.equal(mock.intentos, 2);
+  } finally {
+    mock.restaurar();
+  }
+});
+
+test('sintetizar no reintenta cuando el fallo es del propio servicio', async () => {
+  // Con la conexion abierta el servicio ya decidio: volver a conectar sirve
+  // para un corte de red, no para un rechazo.
+  const mock = mockWebSocket(['error']);
+  try {
+    await assert.rejects(() => sintetizar('hola', { reintentos: 5, pausaReintentoMs: 5 }), /WebSocket/);
+    assert.equal(mock.intentos, 1);
+  } finally {
+    mock.restaurar();
+  }
+});
+
+test('sintetizar no reintenta si el usuario cancela', async () => {
+  const mock = mockWebSocket(['fallo']);
+  const controller = new AbortController();
+  try {
+    const enCurso = sintetizar('hola', { reintentos: 5, pausaReintentoMs: 5, signal: controller.signal });
+    controller.abort();
+    await assert.rejects(() => enCurso, /cancel/);
+    assert.ok(mock.intentos <= 1, `intentos: ${mock.intentos}`);
+  } finally {
+    mock.restaurar();
+  }
+});

package/harness/packages/server/bin/tamnora-server.mjs

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
-import { serveCommand } from '../src/cli.js';
+// node:sqlite sigue siendo "experimental" en Node 22, que avisa aunque ande. El
+// aviso no le aporta nada al usuario, asi que se filtra aca (lo que no sea un
+// warning de Node se imprime igual).
+process.on('warning', (warning) => {
+  if (warning.name !== 'ExperimentalWarning') console.warn(warning.stack ?? warning);
+});
+const { serveCommand } = await import('../src/cli.js');
 
 serveCommand(process.argv.slice(2))
   .then((code) => {

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

@@ -122,7 +122,9 @@ import {
   closeSkillForm,
   importMcp,
   importSkill,
+  limitsCachingEl,
   limitsDurationEl,
+  limitsOutputEl,
   limitsRoundsEl,
   limitsTokensEl,
   mcpForm,
@@ -201,9 +203,6 @@ import {
   trTestBtn,
 } from './voice.js';
 
-document.querySelectorAll('.tab[data-tab]').forEach((t) =>
-  t.addEventListener('click', () => activateTab(t.dataset.tab))
-);
 moreTab.addEventListener('click', (event) => {
   event.stopPropagation();
   const open = moreMenu.hidden;
@@ -538,6 +537,8 @@ $('#limits-save')?.addEventListener('click', async () => {
     maxRounds: Math.max(0, Number(limitsRoundsEl?.value) || 0),
     maxTokens: Math.max(0, Number(limitsTokensEl?.value) || 0),
     maxDurationMs: Math.max(0, Math.round((Number(limitsDurationEl?.value) || 0) * 1000)),
+    maxOutputTokens: Math.max(0, Number(limitsOutputEl?.value) || 0),
+    promptCaching: Boolean(limitsCachingEl?.checked),
   };
   try {
     await api('/api/settings', { method: 'PUT', body });