@danieltmn/tamnora 0.21.2 → 0.23.0

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

@@ -1,9 +1,36 @@
+import fs from 'node:fs';
 import path from 'node:path';
 
+/**
+ * realpath del segmento existente más profundo, más el resto del camino (que
+ * todavía no existe): `a/b/c` con `a/b` real devuelve `<real(a/b)>/c`.
+ */
+export function realpathDeep(target) {
+  let current = target;
+  const rest = [];
+  for (;;) {
+    try {
+      const real = fs.realpathSync(current);
+      return rest.length ? path.join(real, ...rest.reverse()) : real;
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return target;
+      rest.push(path.basename(current));
+      current = parent;
+    }
+  }
+}
+
+function escapes(base, target) {
+  const rel = path.relative(base, target);
+  return rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel);
+}
+
 /**
  * Resolve a user-supplied path against the workspace root, refusing to escape
- * it. This is a lexical guard: `..`, absolute paths outside the root and
- * drive changes are rejected.
+ * it. Two guards: a lexical one (`..`, absolute paths outside the root, drive
+ * changes) and a real one over `fs.realpath`, because a symlink inside the
+ * workspace can point anywhere and the lexical check cannot see it.
  *
  * @param {string} root - absolute workspace root
  * @param {string} input - relative (or absolute-inside-root) path
@@ -14,11 +41,14 @@ export function resolveInRoot(root, input) {
   const raw = String(input ?? '.').trim() || '.';
   const target = path.isAbsolute(raw) ? path.resolve(raw) : path.resolve(base, raw);
 
-  const rel = path.relative(base, target);
-  const escapes = rel === '..' || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel);
-  if (escapes) {
+  if (escapes(base, target)) {
     throw new Error(`Ruta fuera del workspace: "${input}"`);
   }
+  const realBase = realpathDeep(base);
+  const realTarget = realpathDeep(target);
+  if (escapes(realBase, realTarget)) {
+    throw new Error(`Ruta fuera del workspace (symlink): "${input}"`);
+  }
   return target;
 }
 

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

@@ -58,7 +58,6 @@ function subjectFor(name, args) {
 // `ask` = nunca se autoaprueba (siempre consulta, aunque bash sea `allow`).
 const BASH_DENY = [
   /:\s*\(\s*\)\s*\{[\s\S]*\}\s*;?\s*:/, // fork bomb :(){ :|:& };:
-  /\brm\s+(-[a-z]*r[a-z]*f|-[a-z]*f[a-z]*r)(\s+--?[\w-]+)*\s+(\/|~|\$HOME|\/\*)(\s|$)/i,
   /\bmkfs(\.|\s|$)/i,
   /\bdd\b[^\n]*\bof=\/dev\//i,
   />\s*\/dev\/(sd|nvme|disk)/i,
@@ -67,18 +66,58 @@ const BASH_DENY = [
   /\b(?:remove-item|del|rd|rmdir|format)\b[^\n]*(?:-recurse|-r\b)[^\n]*\b[a-z]:\\?\s*$/i,
 ];
 const BASH_ASK = [
-  /\brm\s+(-[a-z]*r[a-z]*f|-[a-z]*f[a-z]*r)(\s+--?[\w-]+)*\s+(\*|\.|\.\/)(\s|$)/i, // rm -rf * | . (workspace)
   /\bgit\s+push\b[^\n]*(\s-f\b|\s--force\b)/i,
   /\bgit\s+reset\s+--hard\b/i,
   /\bgit\s+clean\s+-[a-z]*f/i,
 ];
 
+// `rm` con flags peligrosos: se parsean los tokens en vez de mirar la grafia,
+// porque `rm --recursive --force /`, `rm -r -f /` y `rm -rf /` son lo mismo y
+// las regex de un solo cluster de flags solo cazaban la ultima.
+const RM_DEADLY_TARGETS = /^(\/|\/\*|\/\.\.|~|\$HOME|\$\{HOME\}|[a-z]:\\?(\*)?)$/i;
+const RM_WORKSPACE_TARGETS = /^(\*|\.{1,2}|\.\/?)$/i;
+
+/** Invocaciones de `rm` del comando: flags normalizados + primer argumento. */
+function rmInvocations(command) {
+  const out = [];
+  for (const segment of String(command).split(/[;&|\n]/)) {
+    const m = /(?:^|\s)(?:sudo\s+)?rm\s+(.*)$/i.exec(segment);
+    if (!m) continue;
+    let recursive = false;
+    let force = false;
+    let target = '';
+    for (const token of m[1].trim().split(/\s+/).filter(Boolean)) {
+      if (token === '--') continue;
+      if (token.startsWith('--')) {
+        if (/^--(recursive|no-preserve-root)$/i.test(token)) recursive = true;
+        if (/^--force$/i.test(token)) force = true;
+        continue;
+      }
+      if (token.startsWith('-')) {
+        const letters = token.slice(1);
+        if (/[rR]/.test(letters)) recursive = true;
+        if (/f/.test(letters)) force = true;
+        continue;
+      }
+      target = token.replace(/^["']|["']$/g, '');
+      break;
+    }
+    out.push({ recursive, force, target });
+  }
+  return out;
+}
+
 /** Devuelve `'deny'`/`'ask'` si el comando es peligroso, o `null`. */
 export function bashGuard(command) {
   const text = String(command ?? '');
   if (!text.trim()) return null;
   for (const re of BASH_DENY) if (re.test(text)) return 'deny';
   for (const re of BASH_ASK) if (re.test(text)) return 'ask';
+  for (const rm of rmInvocations(text)) {
+    if (!rm.recursive) continue;
+    if (RM_DEADLY_TARGETS.test(rm.target)) return 'deny';
+    if (rm.force && RM_WORKSPACE_TARGETS.test(rm.target)) return 'ask';
+  }
   return null;
 }
 

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { TOOL_DEFINITIONS, TOOL_NAMES } from './schema.js';
 import { EXECUTORS } from './executors.js';
-import { evaluatePermission } from './permissions.js';
+import { evaluatePermission, bashGuard } from './permissions.js';
 
 const WRITE_TOOLS = new Set(['write', 'edit']);
 
@@ -24,7 +24,9 @@ function extensionOf(p) {
  * @param {AbortSignal} [opts.signal] - cancela las tools de larga duracion (bash, git)
  */
 export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQuestion, yes = false, signal, writeExtensions } = {}) {
-  const names = new Set(enabled?.length ? enabled : TOOL_NAMES);
+  // `enabled` undefined = todas; una lista se respeta tal cual (vacía = ninguna,
+  // no "todas": un modo restringido no puede quedar sin tools por un filtro).
+  const names = new Set(Array.isArray(enabled) ? enabled : TOOL_NAMES);
   const definitions = TOOL_DEFINITIONS.filter((d) => names.has(d.function.name));
   const allowedWrite = Array.isArray(writeExtensions) && writeExtensions.length
     ? new Set(writeExtensions.map((ext) => String(ext).toLowerCase()))
@@ -38,8 +40,11 @@ export function createToolRegistry({ root, enabled, permissions = {}, onAsk, onQ
     if (!writeAllowed(name, args)) return 'deny';
     let decision = evaluatePermission(name, args, permissions);
     if (decision === 'ask') {
+      // Un `ask` del piso de seguridad (bashGuard) nunca se autoaprueba con
+      // `yes`: sin UI que pregunte (onAsk) queda denegado.
+      const guarded = name === 'bash' && bashGuard(args?.command) === 'ask';
       if (onAsk) decision = (await onAsk(name, args)) ? 'allow' : 'deny';
-      else decision = yes ? 'allow' : 'deny';
+      else decision = !guarded && yes ? 'allow' : 'deny';
     }
     return decision;
   }

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/src/tunnel.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
 import { bridgeStatePath } from './config/home.js';
 import { pidAlive, killPidTree } from './pid.js';
 
@@ -18,9 +18,10 @@ function killTree(child) {
  * Estado del bridge (escrito por `tamnora bridge`), si el supervisor sigue
  * vivo. Lo consulta el server para saber que hay un tunel publico activo y
  * ajustar el modelo de confianza (guards locales, cookie Secure).
- * Cache de 1 s: se lee en cada request sensible y el pid no cambia tan rapido.
+ * Cache de 1 s + invalidacion por mtime del archivo: se lee en cada request
+ * sensible, pero un bridge.json nuevo (o borrado) se ve al instante.
  */
-let tunnelCache = { key: null, at: 0, state: null };
+let tunnelCache = { key: null, mtime: null, at: 0, state: null };
 export function tunnelState() {
   let statePath;
   try {
@@ -29,7 +30,16 @@ export function tunnelState() {
     return null;
   }
   const now = Date.now();
-  if (tunnelCache.key === statePath && now - tunnelCache.at < 1000) return tunnelCache.state;
+  let mtime = null;
+  try {
+    mtime = statSync(statePath).mtimeMs;
+  } catch {
+    tunnelCache = { key: statePath, mtime: null, at: now, state: null };
+    return null;
+  }
+  if (tunnelCache.key === statePath && tunnelCache.mtime === mtime && now - tunnelCache.at < 1000) {
+    return tunnelCache.state;
+  }
   let state = null;
   try {
     const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
@@ -39,7 +49,7 @@ export function tunnelState() {
   } catch {
     /* sin bridge */
   }
-  tunnelCache = { key: statePath, at: now, state };
+  tunnelCache = { key: statePath, mtime, at: now, state };
   return state;
 }
 

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/tools.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtemp, readFile, writeFile, mkdir } from 'node:fs/promises';
+import { mkdtemp, readFile, writeFile, mkdir, symlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { resolveInRoot, toRel } from '../src/tools/paths.js';
@@ -8,6 +8,7 @@ import { evaluatePermission, bashGuard } from '../src/tools/permissions.js';
 import { createTools, createToolRegistry } from '../src/tools/index.js';
 import {
   fetchUrlTool,
+  gitDiffTool,
   previewUrlTool,
   screenshotTool,
   consoleTool,
@@ -61,6 +62,48 @@ test('bashGuard marca comandos peligrosos (piso de seguridad)', () => {
   assert.equal(evaluatePermission('bash', { command: 'rm -rf ./dist' }, { bash: 'allow' }), 'allow');
 });
 
+test('bashGuard tolera grafías alternativas de flags en rm', () => {
+  assert.equal(bashGuard('rm --recursive --force /'), 'deny');
+  assert.equal(bashGuard('rm -r -f /'), 'deny');
+  assert.equal(bashGuard('rm -fr /'), 'deny');
+  assert.equal(bashGuard('rm -r -f ~'), 'deny');
+  assert.equal(bashGuard('rm --recursive --force *'), 'ask');
+  assert.equal(bashGuard('rm -r -f .'), 'ask');
+  assert.equal(bashGuard('rm -rf ./build'), null);
+  assert.equal(bashGuard('rm archivo.txt'), null);
+});
+
+test('el tier ask del piso de seguridad no se autoaprueba con yes', async () => {
+  const root = await makeWorkspace();
+  const auto = createToolRegistry({ root, permissions: { bash: 'allow' }, yes: true });
+  assert.equal(await auto.authorize('bash', { command: 'rm -rf *' }), 'deny', 'yes no saltea la guarda');
+
+  const interactive = createToolRegistry({ root, permissions: { bash: 'allow' }, onAsk: async () => true });
+  assert.equal(await interactive.authorize('bash', { command: 'rm -rf *' }), 'allow', 'onAsk si puede aprobar');
+
+  // Con `yes`, un ask normal (sin guarda) sigue autoaprobando.
+  assert.equal(await auto.authorize('write', { path: 'x.txt' }), 'allow');
+});
+
+test('git_diff rechaza refs que parecen opciones', async () => {
+  const root = await makeWorkspace();
+  const result = await gitDiffTool(root, { ref: '--output=/tmp/inyectado' });
+  assert.match(result, /ref.*inválido/i);
+});
+
+test('resolveInRoot no deja escapar por symlink', async () => {
+  const root = await makeWorkspace();
+  const outside = await mkdtemp(path.join(tmpdir(), 'tamnora-fuera-'));
+  await writeFile(path.join(outside, 'secreto.txt'), 'no tocar');
+  try {
+    await symlink(outside, path.join(root, 'link'), 'junction');
+  } catch {
+    return; // el fs no permite crear symlinks: nada que probar
+  }
+  assert.throws(() => resolveInRoot(root, 'link/secreto.txt'), /fuera del workspace/);
+  assert.equal(toRel(root, resolveInRoot(root, 'src/a.js')), 'src/a.js');
+});
+
 test('local tools read, write, list, glob, grep and edit', async () => {
   const root = await makeWorkspace();
   const reg = createToolRegistry({ root, permissions: { write: 'allow', edit: 'allow' } });

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) => {