@danieltmn/tamnora 0.7.1 → 0.9.0

package/CHANGELOG.md

@@ -5,6 +5,101 @@ 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
+
+- **Revision de docs y sitio**: se audito cada afirmacion contra el codigo y se
+  corrigieron varias inexactas (las API keys **no** se cifran —van en texto plano
+  en SQLite—; `--max-steps` no tiene default `8`; "nada se sube a terceros" es
+  falso si se elige un proveedor remoto). Se sumaron al sitio y a la guia las
+  features de 0.7.1 (tablas markdown, saltos de scroll, agente autonomo y MCP
+  con entorno confinado/redaccion). Actualiza `README.md`, `document.md`,
+  `AGENTS.md`, `SECURITY.md`, `website/` y la landing.
+
 ## [0.7.1] - 2026-10-06
 
 ### Agregado

package/README.md

@@ -84,6 +84,10 @@ menu "mas" (los tres puntitos). En el chat:
 - **Actividad colapsable**: las tools de lectura (`read`, `list`, `glob`, `grep`,
   `fetch_url`, `git_*`) salen **plegadas** y al hacer click se ve el detalle
   (args + resultado); el volcado completo se pide bajo demanda.
+- **Markdown con tablas**: las respuestas renderizan tablas (`|`, con alineacion
+  y celdas saneadas) y botones flotantes para saltar al inicio/final del turno.
+- **Acciones por mensaje**: copiar, editar, regenerar y borrar se agrupan en un
+  menu `⋮`; el indicador de "pensando/trabajando" vive en el pie (`#sb-activity`).
 - **Runs durables**: cerrar el celular o cortar la red **no cancela** el turno; al
   volver, la consola **reconecta** y reconstruye el progreso. Para cortarlo se usa
   el boton de detener (o `POST /api/sessions/:id/stop`).
@@ -149,6 +153,11 @@ stdio. Las tools se exponen como `mcp__<servidor>__<tool>` y, si el servidor los
 anuncia, tambien sus **recursos** y **prompts** (`list_resources`,
 `read_resource`, `list_prompts`, `get_prompt`).
 
+Los MCP stdio **no heredan `process.env`**: reciben un baseline minimo mas el
+`env` declarado (`"KEY": "env:VAR"`), y sus resultados pasan por `redactSecrets`
+(ver [`SECURITY.md`](SECURITY.md)). Para un servidor de confianza que necesite el
+entorno completo, `"inheritEnv": true`.
+
 ## Tools
 
 Tools locales confinadas al workspace (`read`, `list`, `glob`, `grep`, `write`,

package/SECURITY.md

@@ -15,12 +15,17 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
 - **Local (loopback)**: quien ya tiene tu sesion de usuario ya puede correr
   comandos; el server no agrega una barrera adicional mas alla del login.
 - **Acceso remoto por tunel (tunnelmole)**: la URL publica es accesible desde
-  Internet. Es obligatorio (a) una passphrase fuerte, (b) login real en toda la
-  API, (c) limite de intentos y (d) restringir el picker de carpetas a roots
-  permitidos. Nunca expongas un server sin passphrase.
-- **Credenciales**: las API keys de proveedores se guardan en la casa local del
-  usuario (fuera del repo) y se cifran con una clave derivada de la passphrase.
-  Nunca se commitean y se devuelven enmascaradas al cliente.
+  Internet. Configura un **usuario** (asi toda `/api/*` pide sesion) con una
+  **contrasena fuerte**; nunca expongas un server sin login. El tunnel reenvia
+  por loopback, de modo que una vez autenticado se alcanza toda la consola
+  (incluidos el explorador de archivos y el selector de carpetas): tratalo como
+  acceso completo a tu maquina. Cierra el tunnel (`tamnora bridge --stop`) cuando
+  no lo uses.
+- **Credenciales**: las API keys de proveedores se guardan en la base SQLite de
+  la casa local (fuera del repo) **en texto plano**; protege el archivo con los
+  permisos del sistema. Para no persistirlas, usa `"apiKey": "env:VAR"` y
+  define la variable en el entorno. Nunca se commitean y se devuelven
+  enmascaradas al cliente (`apiKeyHint`).
 - **Servidores MCP**: tratalos como codigo de terceros. Los MCP stdio **no heredan
   `process.env`** por defecto: solo reciben un baseline minimo mas el `env` que
   declares (`"env": { "TOKEN": "env:TOKEN" }`); `inheritEnv: true` es solo para

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

@@ -160,7 +160,7 @@ Opciones:
   --session <id>     Continuar una sesión existente
   -c, --continue     Continuar la última sesión
   --system <texto>   Instrucciones extra de sistema
-  --max-steps <n>    Máximo de rondas de herramientas (default: 8)
+  --max-steps <n>    Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>    Tools habilitadas (coma), ej. read,list,grep
   --no-tools         Deshabilitar todas las tools
   -y, --yes          Aprobar automáticamente los permisos "ask"