@danieltmn/tamnora 0.22.0 → 0.23.1

package/CHANGELOG.md

@@ -5,6 +5,31 @@ 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.1] - 2026-10-28
+
+### Cambios
+
+- fix(spawn): evita el warning DEP0190 y hace puntual el stop del bridge
+
+## [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,13 @@
 #!/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. Se quita el
+// impresor default de Node para que lo que si se imprime (lo que no sea
+// ExperimentalWarning) salga una sola vez, no dos.
+process.removeAllListeners('warning');
+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/bridge.js

@@ -11,7 +11,7 @@ import {
   tailLines,
   bridgeLogPath,
 } from '../lib/daemon.js';
-import { startTunnel, probeTailscale, resetTailscaleServe } from '../lib/tunnel.js';
+import { startTunnel, probeTailscale, stopTailscaleServe } from '../lib/tunnel.js';
 import { qrTerminal } from '../lib/qr.js';
 
 const OPTIONS = {
@@ -193,10 +193,10 @@ async function cmdStop() {
     return 0;
   }
   try {
-    await resetTailscaleServe();
+    await stopTailscaleServe();
     stopped.push('tailscale serve');
   } catch (error) {
-    console.log(`No pude ejecutar tailscale serve reset: ${error.message}`);
+    console.log(`No pude detener tailscale serve: ${error.message}`);
   }
   // Mata el supervisor si quedo vivo.
   if (state.pid && pidAlive(state.pid)) {

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/commands/update.js

@@ -16,8 +16,15 @@ const OPTIONS = {
   help: { type: 'boolean', short: 'h' },
 };
 
+// Con `shell: true` (npm.cmd en Windows) Node concatena los args sin escapar
+// (warning DEP0190): se manda un unico comando con args internos ya validados.
+function npmSpawn(args, extra = {}) {
+  const [cmd, cmdArgs] = IS_WIN ? [[NPM, ...args].join(' '), []] : [NPM, args];
+  return spawnSync(cmd, cmdArgs, { windowsHide: true, shell: IS_WIN, timeout: 180000, ...extra });
+}
+
 function npm(args) {
-  return spawnSync(NPM, args, { encoding: 'utf8', windowsHide: true, shell: IS_WIN, timeout: 180000 });
+  return npmSpawn(args, { encoding: 'utf8' });
 }
 
 /** Version del paquete instalado globalmente (la que resuelve `npm ls -g`). */
@@ -78,6 +85,10 @@ export async function updateCommand(argv) {
   }
 
   const tag = typeof values.tag === 'string' && values.tag ? values.tag : 'latest';
+  if (!/^[\w.-]+$/.test(tag)) {
+    console.error(`Tag invalido: ${tag}`);
+    return 1;
+  }
   const spec = `${PACKAGE}@${tag}`;
   const version = readPackageVersion();
   console.log(`Version actual: ${version}`);
@@ -115,7 +126,7 @@ export async function updateCommand(argv) {
   }
 
   console.log(`Actualizando a ${spec}...`);
-  const result = spawnSync(NPM, ['i', '-g', spec], { stdio: 'inherit', windowsHide: true, shell: IS_WIN });
+  const result = npmSpawn(['i', '-g', spec], { stdio: 'inherit' });
   if (result.status !== 0) {
     console.error(`La actualizacion fallo. Proba a mano: npm i -g ${spec}`);
     if (wasRunning) restartServer(wasRunning);

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/cli/test/bin-warning.test.js

@@ -0,0 +1,27 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const BIN = fileURLToPath(new URL('../bin/tamnora.mjs', import.meta.url));
+
+// El bin filtra el ExperimentalWarning de node:sqlite, pero no debe duplicar el
+// resto: sin quitar el impresor default de Node, cada warning salia dos veces.
+// El probe difiere el warning para que salte con el handler del bin ya instalado.
+test('el bin imprime cada warning una sola vez', async () => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-bin-'));
+  const probe = path.join(dir, 'probe.cjs');
+  await writeFile(probe, `setTimeout(() => process.emitWarning('aviso de prueba', 'CustomWarning'), 100);`);
+  const res = spawnSync(process.execPath, ['--require', probe, BIN, '--help'], {
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: 30000,
+  });
+  const out = `${res.stdout}\n${res.stderr}`;
+  const count = out.split('aviso de prueba').length - 1;
+  assert.equal(count, 1, `se esperaba 1 impresion del warning, hubo ${count}`);
+  assert.equal(res.status, 0);
+});

package/harness/packages/cli/test/tunnel.test.js

@@ -1,8 +1,26 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { parseTunnelmoleUrls, parseTailscaleStatus, startTunnel, tailscalePreviewUrl } from '../src/lib/tunnel.js';
+import { EventEmitter } from 'node:events';
+import {
+  parseTunnelmoleUrls,
+  parseTailscaleStatus,
+  startTunnel,
+  startTunnelmole,
+  stopTailscaleServe,
+  tailscalePreviewUrl,
+} from '../src/lib/tunnel.js';
 import { qrTerminal } from '../src/lib/qr.js';
 
+function fakeChild(exitCode = 0) {
+  const child = new EventEmitter();
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.pid = 0;
+  child.killed = false;
+  setImmediate(() => child.emit('exit', exitCode));
+  return child;
+}
+
 test('parseTunnelmoleUrls extracts the https URL', () => {
   const out = parseTunnelmoleUrls('Listening at https://abc-123.tunnelmole.net (forwarding to 4517)');
   assert.equal(out.https, 'https://abc-123.tunnelmole.net');
@@ -38,6 +56,36 @@ test('startTunnel con provider none no abre nada', async () => {
   assert.equal(tun.url, '');
 });
 
+test('stopTailscaleServe apaga solo el handler 443 y lanza tailscale sin shell', async () => {
+  const calls = [];
+  const spawnImpl = (cmd, args, options) => {
+    calls.push({ cmd, args, options });
+    return fakeChild();
+  };
+  await stopTailscaleServe({ spawnImpl });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].cmd, 'tailscale');
+  assert.deepEqual(calls[0].args, ['serve', '--https=443', 'off']);
+  assert.equal(calls[0].options.shell, undefined);
+});
+
+test(
+  'startTunnelmole con shell manda un unico comando (Node no concatena args)',
+  { skip: process.platform !== 'win32' },
+  async () => {
+    const calls = [];
+    const spawnImpl = (cmd, args, options) => {
+      calls.push({ cmd, args, options });
+      return fakeChild(1);
+    };
+    await assert.rejects(() => startTunnelmole(4517, { spawnImpl }), /termino/);
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].cmd, 'npx --yes tunnelmole 4517');
+    assert.deepEqual(calls[0].args, []);
+    assert.equal(calls[0].options.shell, true);
+  }
+);
+
 test('tailscalePreviewUrl usa el 8443 y omite el 443', () => {
   assert.equal(tailscalePreviewUrl('pc.tailnet.ts.net'), 'https://pc.tailnet.ts.net:8443');
   assert.equal(tailscalePreviewUrl('pc.tailnet.ts.net', 9000), 'https://pc.tailnet.ts.net:9000');

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/index.js

@@ -150,7 +150,7 @@ export {
   parseTunnelmoleUrls,
   parseTailscaleStatus,
   probeTailscale,
-  resetTailscaleServe,
+  stopTailscaleServe,
   startTailscaleServe,
   startTailscalePreview,
   startTunnelmole,

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

@@ -71,14 +71,19 @@ function spawnTunnel(bin, args, opts = {}) {
   const parse = opts.parse || (() => ({ https: '', http: '' }));
   const timeoutMs = opts.timeoutMs || 90000;
   const label = opts.label || bin;
+  const useShell = process.platform === 'win32';
   return new Promise((resolve, reject) => {
     let child;
     try {
-      child = spawn(bin, args, {
+      // En Windows `npx` es un shim .cmd y exige shell; ahi se manda un unico
+      // comando (ver shellCommandLine): con array de args Node concatena sin
+      // escapar y emite el warning DEP0190.
+      const [cmd, cmdArgs] = useShell ? [shellCommandLine(bin, args), []] : [bin, args];
+      child = (opts.spawnImpl || spawn)(cmd, cmdArgs, {
         stdio: ['ignore', 'pipe', 'pipe'],
         windowsHide: true,
-        shell: process.platform === 'win32',
-        detached: process.platform !== 'win32',
+        shell: useShell,
+        detached: !useShell,
       });
     } catch (err) {
       reject(new Error(`no se pudo iniciar ${label}: ${err.message}`));
@@ -138,15 +143,29 @@ export function startTunnelmole(port, opts = {}) {
  * tailnet reenviando a loopback, asi que no hay exposicion publica y las
  * peticiones siguen siendo "locales" para el server. Proveedor recomendado.
  */
+// Con `shell: true` Node concatena los args sin escapar (warning DEP0190): se
+// arma un unico comando con args validados contra metacaracteres del shell.
+const SAFE_SHELL_ARG = /^[^&|<>^%!"\r\n]+$/;
+
+function shellCommandLine(bin, args) {
+  for (const arg of args) {
+    if (!SAFE_SHELL_ARG.test(String(arg))) {
+      throw new Error(`argumento no permitido para ${bin}: "${arg}"`);
+    }
+  }
+  return [bin, ...args].join(' ');
+}
+
 function runTailscale(args, opts = {}) {
   const timeoutMs = opts.timeoutMs || 15000;
   return new Promise((resolve, reject) => {
     let child;
     try {
-      child = spawn('tailscale', args, {
+      // `tailscale` es un ejecutable real (.exe en Windows): resuelve por PATH
+      // sin shell, que ademas evita el warning DEP0190 de Node.
+      child = (opts.spawnImpl || spawn)('tailscale', args, {
         stdio: ['ignore', 'pipe', 'pipe'],
         windowsHide: true,
-        shell: process.platform === 'win32',
       });
     } catch (err) {
       reject(err);
@@ -241,7 +260,7 @@ export async function startTailscaleServe(port, opts = {}) {
     pid: 0,
     child: null,
     probeUrl: `${url}/api/health`,
-    stop: () => runTailscale(['serve', 'reset']).catch(() => {}),
+    stop: () => stopTailscaleServe().catch(() => {}),
   };
 }
 
@@ -279,9 +298,13 @@ export async function probeTailscale() {
   return parseTailscaleStatus(stdout);
 }
 
-/** Quita toda la configuracion de `tailscale serve` de este nodo. */
-export function resetTailscaleServe() {
-  return runTailscale(['serve', 'reset'], { timeoutMs: 30000 });
+/**
+ * Apaga el handler `serve` de la consola (https 443) de forma puntual: un
+ * `serve reset` borraria tambien los otros handlers (p.ej. el preview en 8443).
+ */
+export function stopTailscaleServe(opts = {}) {
+  const httpsPort = Number(opts.httpsPort) || 443;
+  return runTailscale(['serve', `--https=${httpsPort}`, 'off'], { timeoutMs: 30000, spawnImpl: opts.spawnImpl });
 }
 
 /**