@danieltmn/tamnora 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -5,6 +5,89 @@ 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.9.0] - 2026-10-07
+
+### Agregado
+
+- **Voz (TTS)**: el agente **narra su progreso** con frases cortas armadas por
+  plantillas sobre los eventos del run (nada de leer la respuesta) y las adjunta
+  como `say`. La consola las reproduce y Telegram manda una **nota de voz** al
+  cerrar el turno. El cliente (`core/src/tts/edge.js`) usa el **WebSocket global
+  de Node** contra las voces de Edge Read Aloud: gratis, sin API key ni
+  dependencias. Ajustes en la pestaña Voz (`app.json` -> `tts`).
+- **Tool `speak`**: el agente puede pedir leer un texto en voz alta (por ejemplo,
+  un resumen en audio cuando se lo pedís). La consola lo reproduce en la tarjeta
+  del tool y Telegram lo manda como nota de voz.
+- **`GET /api/state`, la verdad del servidor**: un snapshot chico con
+  `running`/`awaiting` de cada sesion y los permisos pendientes, en un solo
+  request y **sin mensajes**. Antes la consola necesitaba dos o tres round trips
+  por ciclo, y sobre el tunel cada uno es caro y una oportunidad de fallar.
+- **Reconciliador con la logica testeada** (`public/reconcile.js` +
+  `test/reconcile.test.js`): `diffState` es puro y decide enganchar, soltar,
+  recargar y que permisos son nuevos o resueltos. Los SSE pasaron a ser **atajos
+  de latencia**: si se caen se pierde inmediatez, no correctitud. Antes la misma
+  decision estaba repartida en el canal global, un sweep y el handler de
+  permisos, y se contradijian.
+- **Cadencia adaptativa**: 5 s cuando hay un permiso esperando una decision tuya,
+  10 s con un run activo, 25 s idle.
+- **Banner de permisos** (`#perm-banner`): no descartable, en el composer, con
+  `denegar` / `permitir una vez` / `autorizar todo`. Se puede decidir **desde
+  cualquier pestana o sesion**, sin estar enganchado al run.
+- **Los argumentos de un permiso se leen en una linea**: `summarizeArgs` (puro,
+  en `reconcile.js`) muestra el comando de `bash`, la ruta y el tamano de `write`,
+  o la url de `fetch_url`. Antes se volcaba el JSON crudo y al pedir permiso para
+  escribir un archivo se veia medio archivo con los `\n` escapados.
+- **Señales cuando la pestana esta en background**: `document.title` con `(⚠ n)`
+  y favicon con punto rojo. Con iOS mandando la app a background son las unicas
+  que quedan.
+- **El server abre la consola en el navegador**: al quedar escuchando, `tamnora
+  server` abre la URL en el navegador predeterminado (tambien cuando ya estaba
+  corriendo). Se apaga con `--no-open`. New `core/src/open.js`; en Windows usa
+  `rundll32` para no pasar la URL por un shell.
+- **SSE resumible** (`server/public/runStream.js`): el watchdog de silencio (45 s;
+  30 s para el canal global) detecta el stream colgado en el que
+  `reader.read()` espera para siempre —tipico en un corte de tunel— y reconecta
+  con backoff desde el ultimo cursor, sin repintar el pane.
+- **Canal global de eventos** (`GET /api/events`): un SSE por pestana con
+  `run_start`/`run_end`, permisos y un `snapshot`. Sirve para enterarse al
+  instante de una tarea pedida desde otro dispositivo.
+- **Varios clientes en la misma sesion**: al pedir una tarea mientras otro cliente
+  tiene el turno, el mensaje va a la cola visible en vez de desaparecer; un
+  cliente observador ahora dibuja el mensaje del usuario (se emitia antes de
+  persistirse).
+
+### Corregido
+
+- **Aprobar un permiso ya no lo hace reaparecer en bucle**: `decide()` se
+  tragaba el error del `POST` (`.catch(() => {})`). La UI se cerraba igual,
+  borraba el permiso local y el siguiente snapshot lo volvia a traer porque el
+  server seguia tenerlo pendiente: la tarjeta reaparecia una y otra vez sin
+  decir por que. Ahora el fallo **se avisa y se revierte**, y un 404 se
+  distingue como "ese permiso ya no aplicaba" en vez de dejarlo esperando.
+- **Los permisos ya no se esconden**: eran estado invisible que solo existia
+  dentro del stream SSE de su sesion. Con el celular sin ese stream (o con el
+  tunel caido) la IA se quedaba esperando una decision que no aparecia en ningun
+  lado, y recargar la pagina dejaba el run bloqueado para siempre. Ahora son
+  estado de primera clase y se pueden resolver desde donde estes mirando.
+- **Un permiso ya no desaparece al re-renderizar**: `renderPane` borra el pane
+  entero y los permisos no son mensajes, asi que la tarjeta se ve y al primer
+  re-render se perdia para siempre. Ahora se repintan.
+- **Los fallos de red se ven**: cada camino era un `.catch(() => null)`, con lo
+  que un fallo se veía **exactamente igual** que "no hay nada pendiente" (y por eso
+  no se podia diagnosticar nada). Ahora hay backoff, `#sb-sync` con el motivo en
+  el tooltip y avisos flotantes.
+- **Un error de la consola ya no se disfraza de corte de red**: si el handler de
+  un evento tiraba una excepcion, `streamSse` la propagaba como si fuera una
+  caida del transporte y se reintentaba en bucle — el sintoma era un
+  "reconectando..." perpetuo que no contaba nada. Ahora se propaga marcado como
+  error del handler, no se reintenta y se avisa con el mensaje real.
+- **`tamnora server --stop` podia quedar colgado**: `close()` nunca destruia los
+  sockets SSE abiertos, asi que esperaba indefinidamente.
+- **Cierre del server**: la base SQLite se cerraba antes de cortar las
+  conexiones, y un run abortado terminaba escribiendo sobre una base cerrada.
+- Se mano `attachRun` sin reconexion: un corte de tunel dejaba el turno en
+  "pensando..." para siempre sin error que reintentar.
+
 ## [0.8.0] - 2026-10-06
 
 ### Documentacion

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

@@ -70,7 +70,7 @@ Uso:
   tamnora run "<prompt>"          Ejecutar una tarea headless
   tamnora eval <dataset.jsonl>    Correr un dataset de evaluación
   tamnora mcp                     Listar servidores y herramientas MCP
-  tamnora server [--init|--start|--reload|--stop|--status|--logs]   Server en segundo plano
+  tamnora server [--init|--start|--reload|--stop|--status|--logs]   Server en segundo plano (abre el navegador)
   tamnora user                    Usuario local (login del server)
   tamnora bridge [--start|--reload|--stop|--status]   Tunel publico (tunnelmole) + QR
   tamnora autostart install|remove    Arranque automatico del server

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

@@ -1,16 +1,23 @@
-import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync, unlinkSync, appendFileSync } from 'node:fs';
-import path from 'node:path';
 import {
-  setHome,
   homeDir,
   ensureHome,
   ensureApp,
-  bridgeStatePath,
-  bridgeLogPath,
+  writeApp,
+  readApp,
+  randomToken,
 } from '../../../core/src/index.js';
 import { parse, num } from '../lib/util.js';
-import { killPid, pidAlive } from '../lib/daemon.js';
+import {
+  applyHomeOverride,
+  killPid,
+  pidAlive,
+  bridgeState,
+  createFileLogger,
+  spawnDetached,
+  waitForState,
+  tailLines,
+  bridgeLogPath,
+} from '../lib/daemon.js';
 import { startTunnel } from '../lib/tunnel.js';
 import { qrTerminal } from '../lib/qr.js';
 
@@ -21,6 +28,7 @@ const OPTIONS = {
   status: { type: 'boolean' },
   foreground: { type: 'boolean' },
   stream: { type: 'boolean' },
+  insecure: { type: 'boolean' },
   tunnel: { type: 'string' },
   port: { type: 'string' },
   home: { type: 'string' },
@@ -28,26 +36,9 @@ const OPTIONS = {
   help: { type: 'boolean', short: 'h' },
 };
 
-function readBridgeState() {
-  try {
-    return JSON.parse(readFileSync(bridgeStatePath(), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function writeBridgeState(data) {
-  ensureHome();
-  writeFileSync(bridgeStatePath(), `${JSON.stringify(data, null, 2)}\n`);
-}
-
-function clearBridgeState() {
-  try {
-    unlinkSync(bridgeStatePath());
-  } catch {
-    /* nada */
-  }
-}
+const readBridgeState = () => bridgeState.read();
+const writeBridgeState = (data) => bridgeState.write(data);
+const clearBridgeState = () => bridgeState.clear();
 
 export async function bridgeCommand(argv) {
   const { values } = parse(argv, OPTIONS);
@@ -56,8 +47,7 @@ export async function bridgeCommand(argv) {
     return 0;
   }
   if (values.home) {
-    setHome(values.home);
-    process.env.TAMNORA_HOME = path.resolve(values.home);
+    applyHomeOverride(values);
   }
 
   if (values.stop) return cmdStop();
@@ -75,9 +65,25 @@ function resolve(values) {
   return {
     port: num(values.port, app.port || 4517),
     provider: String(values.tunnel || app.tunnel?.provider || 'tunnelmole').toLowerCase(),
+    app,
   };
 }
 
+/** Asegura la configuracion del relay (url + token) en app.json y la devuelve. */
+function ensureRelayConfig(app) {
+  const tunnel = { ...app.tunnel };
+  if (!tunnel.relayUrl) {
+    tunnel.relayUrl = process.env.TAMNORA_RELAY_URL || 'https://harness.tamnora.com/index.php';
+  }
+  if (!tunnel.token) {
+    tunnel.token = process.env.TAMNORA_RELAY_TOKEN || randomToken(24);
+    const current = readApp();
+    writeApp({ ...current, tunnel: { ...current.tunnel, token: tunnel.token, relayUrl: tunnel.relayUrl } });
+    console.log(`Token de relay nuevo (guardado en app.json): ${tunnel.token}`);
+  }
+  return tunnel;
+}
+
 async function cmdStart(values) {
   const { port, provider } = resolve(values);
   if (provider === 'none') {
@@ -85,6 +91,20 @@ async function cmdStart(values) {
     return 1;
   }
 
+  // Exponer el server a Internet sin usuario configurado deja /api/* abierto
+  // (incluido /api/chat con tool bash): hay que pedirlo explicito.
+  const app = ensureApp();
+  if (!app.user?.password && !values.insecure) {
+    console.error('No hay usuario configurado: por el tunel cualquiera con la URL tendria acceso total.');
+    console.error('Crea uno con: tamnora user --name <usuario> --password <clave>');
+    console.error('Si igual queres abrirlo sin proteccion: tamnora bridge --insecure');
+    return 1;
+  }
+  if (provider === 'tunnelmole' || provider === 'tmole') {
+    console.log('Aviso: tunnelmole gratuito admite una sola conexion; si abriste el');
+    console.log('preview de la consola, cerralo (o el bridge) antes de usar el otro.');
+  }
+
   const current = readBridgeState();
   if (current && pidAlive(current.pid)) {
     console.log(`Bridge ya esta corriendo (pid ${current.pid}).`);
@@ -96,22 +116,17 @@ async function cmdStart(values) {
   const args = [bin, 'bridge', '--foreground', '--port', String(port), '--tunnel', provider];
   if (process.env.TAMNORA_HOME) args.push('--home', process.env.TAMNORA_HOME);
   if (values.verbose) args.push('--verbose');
-  const child = spawn(process.execPath, args, {
-    detached: true,
-    stdio: 'ignore',
-    windowsHide: true,
-    env: { ...process.env, TAMNORA_BRIDGE_CHILD: '1' },
-  });
-  child.unref();
-  let dead = false;
-  child.on('exit', () => {
-    dead = true;
-  });
+  const { child, isDead } = spawnDetached(args, { envFlag: 'TAMNORA_BRIDGE_CHILD' });
   console.log(`Abriendo tunel (${provider}) en el puerto ${port}...`);
 
-  const state = await waitForBridge(child.pid, () => dead, 90000);
+  const state = await waitForState(() => readBridgeState(), {
+    childPid: child.pid,
+    isDead,
+    timeoutMs: 90000,
+    tickMs: 500,
+  });
   if (!state) {
-    const tail = tailBridgeLog(8);
+    const tail = tailLines(bridgeLogPath(), 8);
     if (tail) console.log(tail);
     console.log('No pude abrir el tunel. Revisa: tamnora bridge --status');
     return 1;
@@ -120,64 +135,129 @@ async function cmdStart(values) {
   return 0;
 }
 
+/** URL publica para el celular: la consola agregada al relay con el token. */
+function relayConsoleUrl(extra) {
+  const base = String(extra.relayUrl ?? '').replace(/\/+$/, '').replace(/index\.php$/, '').replace(/\/$/, '');
+  return `${base}/console/?t=${extra.token}`;
+}
+
 async function runForeground(values) {
-  const { port, provider } = resolve(values);
-  const log = (line) => {
-    const text = `[${new Date().toISOString()}] ${line}`;
-    try {
-      ensureHome();
-      appendFileSync(bridgeLogPath(), `${text}\n`);
-    } catch {
-      /* nada */
-    }
-    console.log(text);
+  const { port, provider, app } = resolve(values);
+  const log = createFileLogger(bridgeLogPath());
+  const extra = { provider };
+  if (provider === 'relay') {
+    const relay = ensureRelayConfig(app);
+    extra.relayUrl = relay.relayUrl;
+    extra.token = relay.token;
+  }
+
+  // Senal de apagado: el supervisor de abajo la consulta entre intentos.
+  let interrupted = false;
+  let notifyInterrupt = null;
+  const interruptPromise = new Promise((r) => {
+    notifyInterrupt = r;
+  });
+  const shutdown = () => {
+    interrupted = true;
+    notifyInterrupt();
   };
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+  const sleep = (ms) =>
+    new Promise((r) => {
+      const t = setTimeout(r, ms);
+      interruptPromise.then(() => {
+        clearTimeout(t);
+        r();
+      });
+    });
 
+  // Supervision: si el proceso del tunel muere (el servicio gratuito lo hace a
+  // menudo), reconecta con backoff y reescribe el estado con la URL nueva.
+  let attempt = 0;
   let tun;
-  try {
-    tun = await startTunnel(port, provider, { log, verbose: values.verbose });
-  } catch (err) {
-    log(`ERROR: ${err.message}`);
-    return 1;
-  }
-  if (!tun.url) {
-    log('ERROR: el tunel no devolvio URL.');
-    return 1;
-  }
+  for (;;) {
+    try {
+      tun = await startTunnel(port, provider, { log, verbose: values.verbose, ...extra });
+    } catch (err) {
+      if (interrupted) break;
+      log(`ERROR: ${err.message}`);
+      return 1;
+    }
+    if (!tun.url) {
+      log('ERROR: el tunel no devolvio URL.');
+      return 1;
+    }
 
-  writeBridgeState({
-    pid: process.pid,
-    url: tun.url,
-    provider: tun.provider,
-    port,
-    childPid: tun.pid,
-    startedAt: new Date().toISOString(),
-  });
-  printStatus(readBridgeState(), true);
-  log(`Tunel publico: ${tun.url}`);
+    writeBridgeState({
+      pid: process.pid,
+      url: tun.url,
+      publicUrl: provider === 'relay' ? relayConsoleUrl(extra) : undefined,
+      provider: tun.provider,
+      port,
+      childPid: tun.pid,
+      startedAt: new Date().toISOString(),
+    });
+    printStatus(readBridgeState(), true);
+    log(`Tunel publico: ${tun.url}`);
+    attempt = 0;
 
-  return new Promise((resolve) => {
-    let closing = false;
-    const shutdown = () => {
-      if (closing) return;
-      closing = true;
-      try {
-        tun.stop();
-      } catch {
-        /* nada */
+    const exitCode = await new Promise((r) => {
+      // Health-check cada 60 s: si la URL publica deja de responder dos veces
+      // seguidas, matamos el tunel y el supervisor abre otro.
+      let fails = 0;
+      const probe = async () => {
+        const probeUrl = tun.probeUrl ?? `${tun.url}/api/health`;
+        try {
+          const res = await fetch(probeUrl, { signal: AbortSignal.timeout(8000) });
+          if (res.ok) fails = 0;
+          else fails += 1;
+        } catch {
+          fails += 1;
+        }
+        if (fails >= 2) {
+          log(`La URL publica no responde (${tun.url}); reiniciando el tunel...`);
+          tun.stop();
+        }
+      };
+      const health = setInterval(probe, 60000);
+      health.unref?.();
+      tun.child?.once('exit', (code) => {
+        clearInterval(health);
+        r(code ?? 1);
+      });
+      if (!tun.child) {
+        clearInterval(health);
+        r(0);
       }
-      clearBridgeState();
-      resolve(0);
-    };
-    process.once('SIGINT', shutdown);
-    process.once('SIGTERM', shutdown);
-  });
+      interruptPromise.then(() => {
+        clearInterval(health);
+        r('signal');
+      });
+    });
+
+    if (interrupted || exitCode === 'signal') break;
+    attempt += 1;
+    const wait = Math.min(30000, 2000 * attempt);
+    log(`El tunel termino (codigo ${exitCode}); reconectando en ${Math.round(wait / 1000)} s...`);
+    await sleep(wait);
+  }
+
+  try {
+    tun?.stop?.();
+  } catch {
+    /* nada */
+  }
+  clearBridgeState();
+  return 0;
 }
 
 async function cmdReload(values) {
+  // Leer el estado ANTES de parar: clearBridgeState borra el archivo y despues
+  // no habria nada que esperar (el tunel viejo seguia muriendo).
+  const previous = readBridgeState();
   await cmdStop();
-  const current = readBridgeState();
-  for (let i = 0; i < 25 && current && pidAlive(current.pid); i++) {
+  for (let i = 0; i < 25 && previous?.pid && pidAlive(previous.pid); i++) {
     await new Promise((r) => setTimeout(r, 200));
   }
   return cmdStart(values);
@@ -216,45 +296,21 @@ async function cmdStatus() {
 }
 
 function printStatus(state, withQr = false) {
+  const shown = state.publicUrl || state.url;
   console.log(`Bridge corriendo (pid ${state.pid})`);
-  console.log(`  url     : ${state.url}`);
+  console.log(`  url     : ${shown}`);
   console.log(`  proveedor: ${state.provider}   puerto local: ${state.port}`);
   console.log(`  casa    : ${homeDir()}`);
   if (withQr && state.url) {
-    const art = qrTerminal(state.url, 2);
+    const art = qrTerminal(shown, 2);
     if (art) {
       console.log('');
       console.log(art);
-      console.log(`  escanea para abrir ${state.url}`);
+      console.log(`  escanea para abrir ${shown}`);
     }
   }
 }
 
-function tailBridgeLog(n) {
-  try {
-    const lines = readFileSync(bridgeLogPath(), 'utf8')
-      .split(/\r?\n/)
-      .filter((l) => l.trim() !== '');
-    return lines.slice(-n).join('\n');
-  } catch {
-    return '';
-  }
-}
-
-function waitForBridge(childPid, isDead, timeoutMs) {
-  return new Promise((resolve) => {
-    const start = Date.now();
-    const tick = () => {
-      if (isDead()) return resolve(null);
-      const state = readBridgeState();
-      if (state && state.pid && pidAlive(state.pid) && (!childPid || state.pid === childPid)) return resolve(state);
-      if (Date.now() - start > timeoutMs) return resolve(null);
-      setTimeout(tick, 500);
-    };
-    tick();
-  });
-}
-
 function printHelp() {
   console.log(`Uso: tamnora bridge [accion] [opciones]
 
@@ -268,7 +324,12 @@ Acciones:
   --foreground      Corre en primer plano (debug)
 
 Opciones:
-  --tunnel <prov>   Proveedor (default: el de app.json; hoy: tunnelmole)
+  --tunnel <prov>   Proveedor (default: el de app.json; hoy: tunnelmole o relay)
   --port <n>        Puerto local a exponer (default: el del server)
-  --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)`);
+  --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+  --insecure        Permitir el tunel sin usuario configurado (peligroso)
+
+Relay propio (app.json -> tunnel: { provider: "relay", relayUrl, token }): URLs
+estables via https://harness.tamnora.com; el QR abre la consola agregada con el
+token ya puesto.`);
 }

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

@@ -1,8 +1,6 @@
-import { spawn } from 'node:child_process';
-import { appendFileSync, writeFileSync, readFileSync } from 'node:fs';
+import { writeFileSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import {
-  setHome,
   homeDir,
   ensureHome,
   homeExists,
@@ -12,10 +10,12 @@ import {
   databasePath,
   pidPath,
   serverLogPath,
+  openBrowser,
 } from '../../../core/src/index.js';
 import { createTamnoraServer } from '../../../server/src/index.js';
 import { parse, num } from '../lib/util.js';
 import {
+  applyHomeOverride,
   killPid,
   pidAlive,
   readRuntime,
@@ -23,6 +23,9 @@ import {
   clearRuntime,
   stopRunningServer,
   portHint,
+  createFileLogger,
+  spawnDetached,
+  waitForState,
   tailLines,
 } from '../lib/daemon.js';
 
@@ -42,29 +45,16 @@ const OPTIONS = {
   dir: { type: 'string' },
   home: { type: 'string' },
   force: { type: 'boolean' },
+  'no-open': { type: 'boolean' },
   yes: { type: 'boolean', short: 'y' },
   help: { type: 'boolean', short: 'h' },
 };
 
 function applyHome(values) {
-  const override = values.home ? path.resolve(values.home) : process.env.TAMNORA_HOME || null;
-  if (values.home) {
-    setHome(values.home);
-    process.env.TAMNORA_HOME = override;
-  }
-  return override;
+  applyHomeOverride(values);
 }
 
-function log(line) {
-  const text = `[${new Date().toISOString()}] ${line}`;
-  try {
-    ensureHome();
-    appendFileSync(serverLogPath(), `${text}\n`);
-  } catch {
-    /* sin log no detenemos nada */
-  }
-  console.log(text);
-}
+const log = createFileLogger(serverLogPath());
 
 export async function serverCommand(argv) {
   const { values } = parse(argv, OPTIONS);
@@ -118,34 +108,29 @@ async function cmdStart(values) {
   const isChild = Boolean(process.env.TAMNORA_DETACHED);
   const foreground = Boolean(values.stream || values.foreground) || isChild;
 
-  if (!isChild) {
+if (!isChild) {
     const cur = readRuntime();
     if (cur && pidAlive(cur.pid)) {
       console.log(`Tamnora ya esta corriendo (pid ${cur.pid}).`);
       printStatus(cur);
+      // Aprovechamos que ya esta sirviendo para abrir la consola.
+      if (!values['no-open']) await openBrowser(cur.url, { log: (line) => console.warn(line) });
       return 0;
     }
   }
 
-  if (!foreground) {
+if (!foreground) {
     const bin = process.argv[1];
     const args = [bin, 'server', '--stream', '--port', String(port), '--host', host];
     if (values.dir) args.push('--dir', cwd);
     if (process.env.TAMNORA_HOME) args.push('--home', process.env.TAMNORA_HOME);
     if (values.yes) args.push('--yes');
-    const child = spawn(process.execPath, args, {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true,
-      env: { ...process.env, TAMNORA_DETACHED: '1' },
-    });
-    child.unref();
-    let dead = false;
-    child.on('exit', () => {
-      dead = true;
-    });
+    // El hijo es quien.listen() y por lo tanto quien abre el navegador: el flag
+    // tiene que viajar con el o `--no-open` no serviria de nada.
+    if (values['no-open']) args.push('--no-open');
+    const { child, isDead } = spawnDetached(args, { envFlag: 'TAMNORA_DETACHED' });
     console.log(`Tamnora arrancando en segundo plano (pid ${child.pid})...`);
-    const rt = await waitForRuntime(child.pid, () => dead, 30000);
+    const rt = await waitForState(() => readRuntime(), { childPid: child.pid, isDead, timeoutMs: 30000, tickMs: 400 });
     const tail = rt ? '' : tailLines(serverLogPath(), 8);
     if (tail) {
       console.log('');
@@ -202,10 +187,13 @@ async function runForeground({ values, port, host, cwd }) {
   } catch {
     /* nada */
   }
-  log(`Tamnora escuchando en ${info.url} (workspace ${cwd})`);
-  if (!instance.ctx.authEnabled) {
+log(`Tamnora escuchando en ${info.url} (workspace ${cwd})`);
+if (!instance.ctx.authEnabled) {
     log('aviso: sin usuario configurado; el server no pide login. Crea uno: tamnora user --name <n> --password <p>');
   }
+  // Abrir la consola es lo esperable al arrancar. Solo cuando queda escuchando:
+  // si hubo EADDRINUSE ya hay una consola abierta sirviendo.
+  if (!values['no-open']) await openBrowser(info.url, { log: (line) => log(line) });
 
   return new Promise((resolve) => {
     let closing = false;
@@ -247,8 +235,9 @@ async function cmdStop() {
 }
 
 async function cmdReload(values) {
+  const previous = readRuntime();
   await cmdStop();
-  for (let i = 0; i < 25 && pidAlive(readPid()); i++) {
+  for (let i = 0; i < 25 && previous?.pid && pidAlive(previous.pid); i++) {
     await new Promise((r) => setTimeout(r, 200));
   }
   return cmdStart(values);
@@ -308,20 +297,6 @@ function readPid() {
   }
 }
 
-function waitForRuntime(childPid, isDead, timeoutMs) {
-  return new Promise((resolve) => {
-    const start = Date.now();
-    const tick = () => {
-      if (isDead()) return resolve(null);
-      const rt = readRuntime();
-      if (rt && rt.pid && pidAlive(rt.pid) && (!childPid || rt.pid === childPid)) return resolve(rt);
-      if (Date.now() - start > timeoutMs) return resolve(null);
-      setTimeout(tick, 400);
-    };
-    tick();
-  });
-}
-
 function printHelp() {
   console.log(`Uso: tamnora server [accion] [opciones]
 
@@ -341,5 +316,6 @@ Opciones:
   --host <addr>     Interfaz (default: 127.0.0.1)
   --dir <path>      Workspace del server
   --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+  --no-open         No abrir la consola en el navegador al arrancar
   -y, --yes         Auto-aprobar tools con permiso "ask"`);
 }