@danieltmn/tamnora 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -5,6 +5,19 @@ 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.6.2] - 2026-10-05
+
+### Cambios
+
+- fix(telegram): proveedor de transcripcion dedicado y error claro en la voz
+
+## [0.6.1] - 2026-10-05
+
+### Cambios
+
+- feat(consola): configura Telegram desde la consola y cierra el turno con resumen
+- docs(website): actividad colapsable, runs durables, subagentes y Telegram
+
 ## [0.6.0] - 2026-10-04
 
 ### Cambios

package/README.md

@@ -81,6 +81,12 @@ menu "mas" (los tres puntitos). En el chat:
 - **`/new`** abre otra sesion en la **misma carpeta** de la sesion activa; el boton
   "+ nueva sesion" (y `/new` sin sesion) abre el selector de carpetas. La
   **carpeta predeterminada** se elige en Ajustes.
+- **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.
+- **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`).
 
 ### Preview
 
@@ -120,6 +126,22 @@ URL publica **y un QR** para abrirlo desde el celular. Trabaja protegido por el
 login del server: configura un usuario antes de exponerlo (ver
 [`SECURITY.md`](SECURITY.md)).
 
+### Telegram (canales de mensajeria)
+
+Con un token de bot (`telegram.token` en `tamnora.json`, `app.json` o
+`TAMNORA_TELEGRAM_TOKEN`) podes manejar el harness desde el chat. Cada chat mapea
+a una sesion y el bot soporta:
+
+- texto, **imagenes** y **notas de voz** (transcripcion con `telegram.transcribeModel`,
+  default `whisper-1`, via `POST {baseUrl}/audio/transcriptions`);
+- aprobaciones `ask` con **botones inline** (permitir/denegar);
+- comandos `/new`, `/status`, `/model`, `/provider`, `/mode`, `/stop`, `/help`;
+- **notificaciones**: si un run de la consola pertenece a una sesion vinculada a un
+  chat, el canal avisa el fin, los errores, los subagentes y los permisos.
+
+`server/src/lib/channels/` define la interfaz (`stop`, `notify`); sumar otro
+proveedor es implementarla.
+
 ## MCP
 
 Los servidores MCP se configuran en `tamnora.json` (`mcp[]`) y soportan HTTP y
@@ -136,6 +158,14 @@ Tools locales confinadas al workspace (`read`, `list`, `glob`, `grep`, `write`,
 esta detras de Cloudflare; para esos casos, registra un MCP de navegador (por
 ejemplo Playwright).
 
+## Subagentes
+
+El agente puede delegar una subtarea con la tool `task`: lanza un **subagente**
+con contexto y toolset propios (solo lectura por defecto, modo `plan`) y devuelve
+un resumen. En la consola la actividad del subagente se anida en una tarjeta
+plegable; el limite de rondas se ajusta con `agents.maxRounds`. La tool `task`
+tambien esta disponible en modo `plan` (exploracion delegada).
+
 ## Documentacion
 
 - [`CHANGELOG.md`](CHANGELOG.md) — historial de versiones.

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

@@ -178,7 +178,7 @@ function activateTab(name) {
   hideMoreMenu();
   if (name === 'runs') refreshRuns();
   if (name === 'providers') refreshProviders();
-  if (name === 'ajustes') { refreshMcp(); refreshSkills(); }
+  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshChannels(); }
 }
 
 document.querySelectorAll('.tab[data-tab]').forEach((t) =>
@@ -1531,6 +1531,25 @@ function handleAgentEvent(event, data, turn) {
   return true;
 }
 
+function formatDuration(ms) {
+  const value = Number(ms) || 0;
+  if (value <= 0) return '';
+  return value >= 1000 ? `${(value / 1000).toFixed(1)}s` : `${value}ms`;
+}
+
+/** Cierre del turno: siempre deja un resumen visible (rondas, tools, tiempo). */
+function renderCompletion(message, data) {
+  const tools = Number(data.toolCalls) || 0;
+  const parts = [`${data.rounds ?? '?'} ronda${data.rounds === 1 ? '' : 's'}`];
+  if (tools) parts.push(`${tools} herramienta${tools === 1 ? '' : 's'}`);
+  const duration = formatDuration(data.durationMs);
+  if (duration) parts.push(duration);
+  if (data.tokens?.total_tokens) parts.push(`${Number(data.tokens.total_tokens).toLocaleString('es')} tokens`);
+  const maxed = data.stopReason === 'max_rounds';
+  message.tools.appendChild(el('div', maxed ? 'chip warn' : 'chip ok', `${maxed ? '⚠ máximo de rondas' : '✓ terminado'} · ${parts.join(' · ')}`));
+  scrollMessages(paneOf(message));
+}
+
 function handleChatEvent(event, data, turn) {
   if (handleAgentEvent(event, data, turn)) return;
   if (event === 'agent_start') {
@@ -1603,7 +1622,23 @@ function handleChatEvent(event, data, turn) {
     turn.assistant().tools.appendChild(el('div', 'chip err', `✗ ${data.message}`));
   } else if (event === 'done') {
     setActivity(turn.active, null);
-    if (!data.content && !turn.sawText) setText(turn.assistant(), '(sin texto)');
+    const finalText = (turn.active?.textEl?.textContent ?? '').trim();
+    const tools = Number(data.toolCalls) || 0;
+    if (!finalText) {
+      if (data.stopReason === 'max_rounds') {
+        setText(
+          turn.assistant(),
+          `⚠ El agente alcanzó el máximo de rondas (${data.rounds ?? '?'}) sin dejar una respuesta final.${
+            tools ? ` Hizo ${tools} llamadas a herramientas.` : ''
+          } Pedile que continúe o subí \`maxRounds\`.`
+        );
+      } else if (tools) {
+        setText(turn.assistant(), '✓ El agente terminó sus herramientas, pero no devolvió un mensaje final.');
+      } else {
+        setText(turn.assistant(), '(sin texto)');
+      }
+    }
+    renderCompletion(turn.active, data);
     updateStatus({ rounds: data.rounds, stopReason: data.stopReason });
     addTokens(data.tokens);
   } else if (event === 'aborted') {
@@ -2361,6 +2396,11 @@ const mcpForm = $('#mcp-form');
 const skillListEl = $('#skill-list');
 const skillModal = $('#skill-modal');
 const skillForm = $('#skill-form');
+const tgTokenEl = $('#tg-token');
+const tgChatsEl = $('#tg-chats');
+const tgTranscribeEl = $('#tg-transcribe');
+const tgTranscribeProviderEl = $('#tg-transcribe-provider');
+const tgStatusEl = $('#tg-status');
 
 function setStatus(node, text, cls = '') {
   const elNode = $(node);
@@ -2575,6 +2615,59 @@ async function submitSkill(event) {
   refreshSkills();
 }
 
+async function refreshChannels() {
+  if (!tgStatusEl) return;
+  const data = await api('/api/channels').catch(() => null);
+  if (!data?.telegram) return;
+  const tg = data.telegram;
+  tgStatusEl.className = `summary${tg.running ? ' ok' : ''}`;
+  tgStatusEl.textContent = tg.running
+    ? `activo${tg.tokenHint ? ` · ${tg.tokenHint}` : ''}`
+    : tg.tokenSet
+      ? 'token guardado (bot detenido)'
+      : 'sin configurar';
+  if (tgChatsEl && document.activeElement !== tgChatsEl) {
+    tgChatsEl.value = (tg.allowedChatIds ?? []).join(', ');
+  }
+  if (tgTranscribeEl && document.activeElement !== tgTranscribeEl) {
+    tgTranscribeEl.value = tg.transcribeModel ?? 'whisper-1';
+  }
+  if (tgTranscribeProviderEl && document.activeElement !== tgTranscribeProviderEl) {
+    tgTranscribeProviderEl.value = tg.transcribeProvider ?? '';
+  }
+  if (tgTokenEl && document.activeElement !== tgTokenEl) {
+    tgTokenEl.value = '';
+    tgTokenEl.placeholder = tg.tokenHint ? `${tg.tokenHint} (dejar vacío para no cambiar)` : '123456:ABC…';
+  }
+}
+
+async function submitChannel() {
+  if (!tgTokenEl) return;
+  setStatus('#tg-msg', 'guardando…');
+  const body = {
+    allowedChatIds: tgChatsEl?.value ?? '',
+    transcribeModel: tgTranscribeEl?.value.trim() || 'whisper-1',
+    transcribeProvider: tgTranscribeProviderEl?.value.trim() || '',
+  };
+  const token = tgTokenEl.value.trim();
+  if (token) body.token = token;
+  const data = await api('/api/channels/telegram', { method: 'PUT', body }).catch((e) => ({ error: e.message }));
+  if (data?.error) return setStatus('#tg-msg', data.error, 'err');
+  setStatus('#tg-msg', data.telegram?.running ? 'guardado · bot activo' : 'guardado', 'ok');
+  refreshChannels();
+}
+
+async function testChannel() {
+  if (!tgTokenEl) return;
+  setStatus('#tg-msg', 'probando…');
+  const data = await api('/api/channels/telegram/test', {
+    method: 'POST',
+    body: { token: tgTokenEl.value.trim() },
+  }).catch((e) => ({ ok: false, error: e.message }));
+  if (data?.ok) setStatus('#tg-msg', `token OK${data.username ? ` · @${data.username}` : ''}`, 'ok');
+  else setStatus('#tg-msg', data?.error || 'token inválido', 'err');
+}
+
 async function importMcp() {
   const input = $('#mcp-import');
   const value = input.value.trim();
@@ -2622,6 +2715,8 @@ if (mcpListEl) {
     }
   });
   $('#mcp-reload').addEventListener('click', () => refreshMcp({ connect: true }));
+  $('#tg-save')?.addEventListener('click', submitChannel);
+  $('#tg-test')?.addEventListener('click', testChannel);
   $('#mcp-close').addEventListener('click', closeMcpForm);
   $('#mf-cancel').addEventListener('click', closeMcpForm);
   $('#mf-transport').addEventListener('change', syncMcpFormFields);

package/harness/packages/server/public/index.html

@@ -33,7 +33,7 @@
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><span class="logo-t">T</span><span class="logo-h">H</span></span> <span class="ver">v0.6.0</span></div>
+      <div class="brand"><span class="logo"><span class="logo-t">T</span><span class="logo-h">H</span></span> <span class="ver">v0.6.2</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>
@@ -377,6 +377,45 @@
           <div id="skill-import-status" class="summary"></div>
           <ul id="skill-list" class="providers"></ul>
         </div>
+
+        <div class="panel">
+          <div class="row between">
+            <h2>Telegram</h2>
+            <span id="tg-status" class="summary">cargando…</span>
+          </div>
+          <p class="muted verify-line">
+            Bot por long polling (no necesita URL pública). El token vive en <code>app.json</code>
+            (la casa) y nunca se muestra completo.
+          </p>
+          <label class="field"><span>token del bot</span>
+            <input id="tg-token" type="password" autocomplete="off" spellcheck="false"
+              placeholder="123456:ABC… (dejar vacío para no cambiar)" />
+          </label>
+          <label class="field"><span>chats autorizados (ids separados por coma)</span>
+            <input id="tg-chats" spellcheck="false" placeholder="123456789, -1001234567890" />
+          </label>
+          <label class="field"><span>proveedor de transcripción (voz, opcional)</span>
+            <input id="tg-transcribe-provider" spellcheck="false"
+              placeholder="openai · groq — vacío = proveedor activo" />
+          </label>
+          <label class="field"><span>modelo de transcripción (voz)</span>
+            <input id="tg-transcribe" spellcheck="false" placeholder="whisper-1" />
+          </label>
+          <details class="tg-help">
+            <summary>¿Cómo habilito mi chat?</summary>
+            <ol>
+              <li>Creá el bot con <b>@BotFather</b> (<code>/newbot</code>) y pegá el token acá.</li>
+              <li>Guardá y mandale cualquier mensaje al bot: si tu chat no está autorizado, te
+                responde tu <b>chat id</b>.</li>
+              <li>Agregá ese id a <strong>chats autorizados</strong> y volvé a guardar.</li>
+            </ol>
+          </details>
+          <div class="row">
+            <button id="tg-save" class="btn primary" type="button">guardar</button>
+            <button id="tg-test" class="btn" type="button">probar token</button>
+            <span id="tg-msg" class="summary"></span>
+          </div>
+        </div>
       </section>
 
       <dialog id="folder-modal" class="modal folder-modal">

package/harness/packages/server/public/styles.css

@@ -613,6 +613,8 @@ body.resizing * { cursor: col-resize !important; }
   word-break: break-word;
 }
 .chip.err { border-left-color: var(--danger); color: var(--danger); }
+.chip.ok { border-left-color: var(--ok); color: var(--ok); }
+.chip.warn { border-left-color: var(--warn); color: var(--warn); }
 details.reasoning { margin-top: 6px; }
 details.reasoning > summary { color: var(--muted); cursor: pointer; font-size: 12.5px; }
 details.reasoning .body { color: var(--muted); white-space: pre-wrap; margin-top: 4px; border-left: 1px solid var(--border); padding-left: 10px; }

package/harness/packages/server/src/lib/channels/index.js

@@ -1,43 +1,96 @@
 // Capa de canales de mensajeria. Hoy implementa Telegram; la interfaz comun
-// (`stop`, `notify`) permite sumar otros proveedores mas adelante.
+// (`stop`, `notify`) permite sumar otros proveedores mas adelante. El manager
+// permite recargar los canales en caliente tras cambiar la configuracion.
 
 import { startTelegramChannel } from './telegram.js';
 
+function tokenHint(token) {
+  const value = String(token ?? '');
+  if (!value) return '';
+  if (value.includes('•')) return value;
+  return value.length <= 6 ? '••••' : `••••${value.slice(-4)}`;
+}
+
+function parseAllowed(raw) {
+  if (Array.isArray(raw)) return raw.map(String).filter(Boolean);
+  return String(raw ?? '')
+    .split(/[,\s]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
 /**
- * Arranca los canales configurados y los suscribe a los eventos de los runs
- * para avisar a los chats vinculados (por ejemplo, de la consola).
+ * Crea el manager de canales. `load()` arranca (o reinicia) los canales segun
+ * la config efectiva (app.json + tamnora.json + entorno), `status()` la resume
+ * y `stop()` los baja.
  */
-export function startChannels(ctx, { log = () => {} } = {}) {
-  const tgConfig = { ...(ctx.app?.telegram ?? {}), ...(ctx.config?.telegram ?? {}) };
-  const token = tgConfig.token || process.env.TAMNORA_TELEGRAM_TOKEN || '';
-  const rawAllow = tgConfig.allowedChatIds ?? process.env.TAMNORA_TELEGRAM_CHAT_IDS ?? [];
-  const allowedChatIds = Array.isArray(rawAllow) ? rawAllow : String(rawAllow).split(/[,\s]+/).filter(Boolean);
-
-  const channels = [];
-  const telegram = startTelegramChannel(ctx, {
-    token,
-    allowedChatIds,
-    transcribeModel: tgConfig.transcribeModel,
-    log,
-  });
-  if (telegram) channels.push(telegram);
-
-  const unsubscribe = ctx.runs?.subscribeAll?.((sessionId, event) => {
-    for (const channel of channels) {
-      try {
-        channel.notify?.(sessionId, event);
-      } catch {
-        // un canal caido no debe frenar el run
-      }
-    }
-  });
-
-  return {
-    channels,
-    enabled: channels.length > 0,
-    stop() {
-      unsubscribe?.();
-      for (const channel of channels) channel.stop?.();
-    },
+export function createChannelsManager(ctx, { log = () => {}, enabled = true } = {}) {
+  let active = null;
+
+  // app.json (global) es la base; tamnora.json solo pisa con valores definidos
+  // (evita que sus defaults vacios borren lo guardado desde la consola).
+  const readConfig = () => {
+    const app = ctx.app?.telegram ?? {};
+    const cfg = ctx.config?.telegram ?? {};
+    const tg = { ...app };
+    if (cfg.token) tg.token = cfg.token;
+    if (Array.isArray(cfg.allowedChatIds) && cfg.allowedChatIds.length) tg.allowedChatIds = cfg.allowedChatIds;
+    if (cfg.transcribeModel) tg.transcribeModel = cfg.transcribeModel;
+    if (cfg.transcribeProvider) tg.transcribeProvider = cfg.transcribeProvider;
+    return tg;
   };
+
+  function effective() {
+    const tg = readConfig();
+    const token = tg.token || process.env.TAMNORA_TELEGRAM_TOKEN || '';
+    const allowedChatIds = parseAllowed(tg.allowedChatIds ?? process.env.TAMNORA_TELEGRAM_CHAT_IDS ?? []);
+    return {
+      token,
+      allowedChatIds,
+      transcribeModel: tg.transcribeModel,
+      transcribeProvider: tg.transcribeProvider,
+    };
+  }
+
+  function stop() {
+    active?.unsubscribe?.();
+    for (const channel of active?.channels ?? []) channel.stop?.();
+    active = null;
+    ctx.telegram = false;
+  }
+
+  function load() {
+    stop();
+    if (!enabled) return { enabled: false, channels: [] };
+    const { token, allowedChatIds, transcribeModel, transcribeProvider } = effective();
+    const channels = [];
+    const telegram = startTelegramChannel(ctx, { token, allowedChatIds, transcribeModel, transcribeProvider, log });
+    if (telegram) channels.push(telegram);
+    const unsubscribe = ctx.runs?.subscribeAll?.((sessionId, event) => {
+      for (const channel of channels) {
+        try {
+          channel.notify?.(sessionId, event);
+        } catch {
+          // un canal caido no debe frenar el run
+        }
+      }
+    });
+    active = { channels, unsubscribe };
+    ctx.telegram = channels.length > 0;
+    return { enabled: ctx.telegram, channels };
+  }
+
+  function status() {
+    const { token, allowedChatIds, transcribeModel, transcribeProvider } = effective();
+    return {
+      tokenSet: Boolean(token),
+      tokenHint: tokenHint(token),
+      allowedChatIds,
+      transcribeModel: transcribeModel || 'whisper-1',
+      transcribeProvider: transcribeProvider || '',
+      running: Boolean(active && active.channels.length),
+    };
+  }
+
+  return { load, stop, status, readConfig };
 }

package/harness/packages/server/src/lib/channels/telegram.js

@@ -3,7 +3,7 @@
 // inline. Cada chat mapea a una sesion del harness.
 
 import { randomUUID } from 'node:crypto';
-import { runAgent, createTools, resolveMode, summarizeToolCall } from '../core.js';
+import { runAgent, createTools, resolveMode, summarizeToolCall, listProviderModels, PROVIDER_META } from '../core.js';
 import { resolveExistingDir } from '../workspace.js';
 
 const API = 'https://api.telegram.org';
@@ -11,11 +11,12 @@ const API = 'https://api.telegram.org';
 const HELP = [
   'Tamnora Harness — bot',
   '',
+  '/menu — panel con botones (modelo, modo, proveedor)',
   '/new — nueva sesión',
   '/status — proveedor, modelo, modo y sesión',
-  '/model <id> — cambia el modelo',
-  '/provider <id> — cambia el proveedor',
-  '/mode plan|build — cambia el modo',
+  '/model [id] — cambia el modelo (sin id: lista con botones)',
+  '/provider [id] — cambia el proveedor (sin id: lista)',
+  '/mode [plan|build] — cambia el modo (sin arg: panel)',
   '/stop — cancela la respuesta en curso',
   '/help — esta ayuda',
   '',
@@ -42,6 +43,17 @@ async function tg(token, method, payload) {
   return data.result;
 }
 
+/** Valida un token consultando `getMe`. Devuelve `{ ok, username, name }` o `{ ok:false, error }`. */
+export async function getTelegramBotInfo(token) {
+  if (!token) return { ok: false, error: 'Falta el token.' };
+  try {
+    const result = await tg(token, 'getMe', {});
+    return { ok: true, username: result?.username ?? null, name: result?.first_name ?? null };
+  } catch (error) {
+    return { ok: false, error: error?.message ?? String(error) };
+  }
+}
+
 async function downloadFile(token, fileId) {
   const file = await tg(token, 'getFile', { file_id: fileId });
   const res = await fetch(`${API}/file/bot${token}/${file.file_path}`);
@@ -58,14 +70,27 @@ function splitMessage(text, max = 3900) {
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/** Linea de cierre del turno (rondas, herramientas, duración). */
+export function completionFooter(stopReason, rounds, toolCalls, durationMs) {
+  const parts = [`${rounds ?? '?'} ronda${rounds === 1 ? '' : 's'}`];
+  if (toolCalls) parts.push(`${toolCalls} herramienta${toolCalls === 1 ? '' : 's'}`);
+  if (durationMs > 0) parts.push(durationMs >= 1000 ? `${(durationMs / 1000).toFixed(1)}s` : `${durationMs}ms`);
+  const maxed = stopReason === 'max_rounds';
+  return `${maxed ? '⚠ máximo de rondas' : '✓ terminado'} · ${parts.join(' · ')}`;
+}
+
 /**
  * Arranca el canal de Telegram. Devuelve `{ stop, notify }` o `null` sin token.
  */
-export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcribeModel = 'whisper-1', log = () => {} } = {}) {
+export function startTelegramChannel(
+  ctx,
+  { token, allowedChatIds = [], transcribeModel = 'whisper-1', transcribeProvider = '', log = () => {} } = {}
+) {
   if (!token) return null;
   const allowed = new Set(allowedChatIds.map(String));
   const controllers = new Map();
   const ownSessions = new Set();
+  const modelChoices = new Map();
   let running = true;
   let offset = 0;
 
@@ -108,10 +133,11 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
   }
 
   async function transcribe(buffer, filename) {
-    const providerId = ctx.effectiveProviderId();
-    const baseUrl = (ctx.providerSettings(providerId).baseUrl || '').replace(/\/+$/, '');
+    const providerId = transcribeProvider || ctx.effectiveProviderId();
+    const settings = ctx.providerSettings(providerId) ?? {};
+    const baseUrl = (settings.baseUrl || '').replace(/\/+$/, '');
     const apiKey = ctx.apiKeyFor(providerId);
-    if (!baseUrl) throw new Error('el proveedor no tiene baseUrl para transcribir');
+    if (!baseUrl) throw new Error(`el proveedor "${providerId}" no tiene baseUrl para transcribir`);
     const form = new FormData();
     form.append('file', new Blob([buffer]), filename);
     form.append('model', transcribeModel);
@@ -120,7 +146,15 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
       headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
       body: form,
     });
-    if (!res.ok) throw new Error(`transcripción falló (HTTP ${res.status})`);
+    if (!res.ok) {
+      const hint =
+        res.status === 404
+          ? ` — "${providerId}" no expone /audio/transcriptions`
+          : '';
+      throw new Error(
+        `transcripción falló (HTTP ${res.status})${hint}. Elegí un proveedor con voz (OpenAI, Groq…) en Ajustes → Telegram.`
+      );
+    }
     const data = await res.json();
     return String(data.text ?? '').trim();
   }
@@ -193,6 +227,7 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
     const controller = new AbortController();
     controllers.set(String(chatId), controller);
     ownSessions.add(sessionId);
+    const startedAt = Date.now();
     const message = await send(chatId, '…');
     let full = '';
     let activity = '';
@@ -232,8 +267,24 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
           }
         },
       });
-      await edit(chatId, message.message_id, result.content?.trim() || full || '(sin texto)');
-      ctx.store.addMessages(sessionId, result.messages.slice(messages.length));
+      const newMessages = result.messages.slice(messages.length);
+      const toolCalls = newMessages.filter((m) => m.role === 'tool').length;
+      const durationMs = Date.now() - startedAt;
+      let body = result.content?.trim() || full.trim();
+      if (!body) {
+        if (result.stopReason === 'max_rounds') {
+          body = `⚠ El agente alcanzó el máximo de rondas (${result.rounds}) sin respuesta final.${
+            toolCalls ? ` Hizo ${toolCalls} herramientas.` : ''
+          } Pedile que continúe o subí maxRounds.`;
+        } else if (toolCalls) {
+          body = '✓ El agente terminó sus herramientas, pero no devolvió un mensaje final.';
+        } else {
+          body = '(sin texto)';
+        }
+      }
+      const footer = completionFooter(result.stopReason, result.rounds, toolCalls, durationMs);
+      await edit(chatId, message.message_id, `${body}\n\n— ${footer}`);
+      ctx.store.addMessages(sessionId, newMessages);
       ctx.store.touchSession(sessionId, { provider: providerId, model });
     } catch (error) {
       await edit(chatId, message.message_id, error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`);
@@ -244,12 +295,71 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
     }
   }
 
+  async function sendMenu(chatId) {
+    const sessionId = ensureSession(chatId);
+    const session = ctx.store.getSession(sessionId);
+    const providerId = session?.provider || ctx.effectiveProviderId();
+    const model = session?.model || ctx.effectiveModel() || '—';
+    const mode = resolveMode(ctx.effectiveMode());
+    const text = ['⚙ Panel', `proveedor: ${providerId}`, `modelo: ${model}`, `modo: ${mode.label}`].join('\n');
+    await send(chatId, text, {
+      reply_markup: {
+        inline_keyboard: [
+          [
+            { text: mode.id === 'plan' ? '● Plan' : 'Plan', callback_data: 'mode:plan' },
+            { text: mode.id === 'agent' ? '● Build' : 'Build', callback_data: 'mode:agent' },
+          ],
+          [
+            { text: 'modelos', callback_data: 'menu:models' },
+            { text: 'proveedores', callback_data: 'menu:providers' },
+          ],
+          [
+            { text: '🆕 nueva', callback_data: 'menu:new' },
+            { text: '⏹ detener', callback_data: 'menu:stop' },
+          ],
+        ],
+      },
+    });
+  }
+
+  async function sendModels(chatId) {
+    const sessionId = ensureSession(chatId);
+    const providerId = ctx.store.getSession(sessionId)?.provider || ctx.effectiveProviderId();
+    const models = await listProviderModels({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    }).catch(() => []);
+
+    const current = ctx.store.getSession(sessionId)?.model || ctx.effectiveModel();
+    if (!models?.length) return send(chatId, 'No pude listar modelos. Usá /model <id>.');
+    const capped = models.slice(0, 12);
+    modelChoices.set(String(chatId), capped.map((m) => m.id));
+    const rows = capped.map((m, i) => [
+      { text: `${m.id === current ? '● ' : ''}${m.label || m.id}`, callback_data: `model:${i}` },
+    ]);
+    rows.push([{ text: '‹ panel', callback_data: 'menu:home' }]);
+    await send(chatId, `Modelos de ${providerId} (elegí uno):`, { reply_markup: { inline_keyboard: rows } });
+    if (models.length > capped.length) {
+      send(chatId, `Hay ${models.length} modelos; mostré 12. Para otro, usá /model <id>.`).catch(() => {});
+    }
+  }
+
+  async function sendProviders(chatId) {
+    const custom = ctx.customProviderDefs?.() ?? [];
+    const ids = [...new Set([...PROVIDER_META.map((p) => p.id), ...custom.map((p) => p.id)])];
+    const current = ctx.effectiveProviderId();
+    const rows = ids.map((id) => [{ text: `${id === current ? '● ' : ''}${id}`, callback_data: `provider:${id}` }]);
+    rows.push([{ text: '‹ panel', callback_data: 'menu:home' }]);
+    await send(chatId, 'Proveedores (elegí uno):', { reply_markup: { inline_keyboard: rows } });
+  }
+
   async function handleCommand(chatId, text) {
     const [raw, ...rest] = text.slice(1).split(/\s+/);
     const cmd = raw.toLowerCase();
     const arg = rest.join(' ').trim();
     const sessionId = ctx.store.getSetting(sessionKey(chatId));
     if (cmd === 'start' || cmd === 'help' || cmd === 'ayuda') return send(chatId, HELP);
+    if (cmd === 'menu' || cmd === 'panel' || cmd === 'config') return sendMenu(chatId);
     if (cmd === 'new' || cmd === 'nueva') {
       ctx.store.setSetting(sessionKey(chatId), null);
       return send(chatId, 'Nueva sesión. Mandá tu mensaje.');
@@ -261,20 +371,20 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
         `proveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
       );
     }
-    if (cmd === 'model') {
-      if (!arg) return send(chatId, `modelo actual: ${ctx.effectiveModel() || '—'}`);
+    if (cmd === 'model' || cmd === 'modelo') {
+      if (!arg) return sendModels(chatId);
       ctx.store.setSetting('activeModel', arg);
       if (sessionId) ctx.store.touchSession(sessionId, { model: arg });
       return send(chatId, `modelo: ${arg}`);
     }
-    if (cmd === 'provider') {
-      if (!arg) return send(chatId, `proveedor actual: ${ctx.effectiveProviderId()}`);
+    if (cmd === 'provider' || cmd === 'proveedor') {
+      if (!arg) return sendProviders(chatId);
       ctx.store.setSetting('activeProvider', arg);
       if (sessionId) ctx.store.touchSession(sessionId, { provider: arg });
       return send(chatId, `proveedor: ${arg}`);
     }
     if (cmd === 'mode' || cmd === 'modo') {
-      if (!arg) return send(chatId, `modo actual: ${ctx.effectiveMode()}`);
+      if (!arg) return sendMenu(chatId);
       const id = arg.toLowerCase() === 'build' ? 'agent' : arg.toLowerCase();
       ctx.store.setSetting('activeMode', resolveMode(id).id);
       return send(chatId, `modo: ${resolveMode(id).label}`);
@@ -329,10 +439,46 @@ export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcri
   }
 
   async function handleCallback(query) {
-    const [_, askId, action] = String(query.data ?? '').split(':');
-    if (askId) ctx.approvals.decide(askId, action === 'allow');
-    await tg(token, 'answerCallbackQuery', { callback_query_id: query.id, text: action === 'allow' ? 'Permitido' : 'Denegado' }).catch(() => null);
-    if (query.message) {
+    const chatId = String(query.message?.chat.id ?? '');
+    const [kind, a, b] = String(query.data ?? '').split(':');
+    let toast = '';
+
+    if (kind === 'perm') {
+      ctx.approvals.decide(a, b === 'allow');
+      toast = b === 'allow' ? 'Permitido' : 'Denegado';
+    } else if (kind === 'mode') {
+      ctx.store.setSetting('activeMode', resolveMode(a).id);
+      toast = `Modo ${resolveMode(a).label}`;
+    } else if (kind === 'provider') {
+      ctx.store.setSetting('activeProvider', a);
+      const sid = ctx.store.getSetting(sessionKey(chatId));
+      if (sid) ctx.store.touchSession(sid, { provider: a });
+      toast = `Proveedor ${a}`;
+    } else if (kind === 'model') {
+      const id = (modelChoices.get(chatId) ?? [])[Number(a)];
+      if (id) {
+        ctx.store.setSetting('activeModel', id);
+        const sid = ctx.store.getSetting(sessionKey(chatId));
+        if (sid) ctx.store.touchSession(sid, { model: id });
+        toast = `Modelo ${id}`;
+      }
+    } else if (kind === 'menu') {
+      if (a === 'models') await sendModels(chatId);
+      else if (a === 'providers') await sendProviders(chatId);
+      else if (a === 'home') await sendMenu(chatId);
+      else if (a === 'new') {
+        ctx.store.setSetting(sessionKey(chatId), null);
+        await send(chatId, 'Nueva sesión. Mandá tu mensaje.');
+      } else if (a === 'stop') {
+        controllers.get(chatId)?.abort();
+        await send(chatId, 'Cancelando…');
+      }
+      toast = 'ok';
+    }
+
+    await tg(token, 'answerCallbackQuery', { callback_query_id: query.id, text: toast }).catch(() => null);
+    // Solo los permisos cierran su tarjeta; el panel conserva los botones.
+    if (kind === 'perm' && query.message) {
       await tg(token, 'editMessageReplyMarkup', { chat_id: query.message.chat.id, message_id: query.message.message_id }).catch(() => null);
     }
   }

package/harness/packages/server/src/routes/channels.js

@@ -0,0 +1,48 @@
+// Configuracion de los canales de mensajeria desde la consola. La config vive
+// en app.json (casa); al guardar se recargan los canales en caliente.
+
+import { readApp, writeApp } from '../lib/core.js';
+import { getTelegramBotInfo } from '../lib/channels/telegram.js';
+import { readJson, sendJson } from '../lib/http.js';
+
+function sanitizeAllowed(value) {
+  if (Array.isArray(value)) return value.map((v) => String(v).trim()).filter(Boolean);
+  return String(value ?? '')
+    .split(/[,\s]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+export function registerChannels(route, ctx) {
+  route('GET', '/api/channels', ({ res }) => {
+    sendJson(res, 200, { telegram: ctx.channels.status() });
+  });
+
+  route('PUT', '/api/channels/telegram', async ({ req, res }) => {
+    const body = await readJson(req);
+    const app = readApp();
+    const next = { ...(app.telegram ?? {}) };
+
+    if ('token' in body) {
+      const token = String(body.token ?? '').trim();
+      // El cliente puede mandar la mascara (`••••1234`): no pisar el token real.
+      if (!token.includes('•')) next.token = token;
+    }
+    if ('allowedChatIds' in body) next.allowedChatIds = sanitizeAllowed(body.allowedChatIds);
+    if ('transcribeModel' in body) next.transcribeModel = String(body.transcribeModel ?? '').trim() || 'whisper-1';
+    if ('transcribeProvider' in body) next.transcribeProvider = String(body.transcribeProvider ?? '').trim();
+
+    app.telegram = next;
+    writeApp(app);
+    ctx.app = app;
+    ctx.channels.load();
+    sendJson(res, 200, { telegram: ctx.channels.status() });
+  });
+
+  route('POST', '/api/channels/telegram/test', async ({ req, res }) => {
+    const body = await readJson(req).catch(() => ({}));
+    let token = String(body.token ?? '').trim();
+    if (!token || token.includes('•')) token = ctx.channels.readConfig().token ?? '';
+    sendJson(res, 200, await getTelegramBotInfo(token));
+  });
+}

package/harness/packages/server/src/routes/chat.js

@@ -239,6 +239,7 @@ export function registerChat(route, ctx) {
     const prefixLength = messages.length;
 
     (async () => {
+      const startedAt = Date.now();
       const partials = createPartialThrottle(300, (name, payload) => ctx.runs.emit(sessionId, name, payload));
       try {
         const result = await runAgent({
@@ -293,7 +294,9 @@ export function registerChat(route, ctx) {
         const title =
           current && (!current.title || current.title === 'Nueva sesión') ? input.slice(0, 60) : undefined;
         ctx.store.touchSession(sessionId, { provider: providerId, model, title });
-        if (result.stopReason === 'aborted') ctx.runs.emit(sessionId, 'aborted', {});
+        const toolCalls = newMessages.filter((message) => message.role === 'tool').length;
+        const durationMs = Date.now() - startedAt;
+        if (result.stopReason === 'aborted') ctx.runs.emit(sessionId, 'aborted', { durationMs, toolCalls });
         else
           ctx.runs.emit(sessionId, 'done', {
             sessionId,
@@ -301,6 +304,8 @@ export function registerChat(route, ctx) {
             rounds: result.rounds,
             stopReason: result.stopReason,
             tokens: result.usage ?? null,
+            toolCalls,
+            durationMs,
           });
       } catch (error) {
         partials.flush();

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

@@ -20,7 +20,7 @@ import { skillsPrompt } from './lib/skills.js';
 import { createApprovalBroker } from './lib/approvals.js';
 import { createRunManager } from './lib/runManager.js';
 import { createProcManager } from './lib/procs.js';
-import { startChannels } from './lib/channels/index.js';
+import { createChannelsManager } from './lib/channels/index.js';
 import { createAgentTools } from './lib/agentTools.js';
 import { createStaticHandler } from './static.js';
 import { requireLogin, requireCsrf } from './auth.js';
@@ -32,6 +32,7 @@ import { registerModels } from './routes/models.js';
 import { registerProviders } from './routes/providers.js';
 import { registerMcp } from './routes/mcp.js';
 import { registerSkills } from './routes/skills.js';
+import { registerChannels } from './routes/channels.js';
 import { registerProcs } from './routes/procs.js';
 import { registerPreview } from './routes/preview.js';
 import { registerChat } from './routes/chat.js';
@@ -171,10 +172,11 @@ export async function createTamnoraServer({
   ctx.agentTools = createAgentTools(ctx);
 
   // Canales de mensajeria (Telegram via long polling) si hay token.
-  const channels = telegram
-    ? startChannels(ctx, { log: (message) => process.stderr.write(`${message}\n`) })
-    : { channels: [], enabled: false, stop() {} };
-  ctx.telegram = channels.enabled;
+  const channels = createChannelsManager(ctx, {
+    enabled: telegram,
+    log: (message) => process.stderr.write(`${message}\n`),
+  });
+  channels.load();
   ctx.channels = channels;
 
   const routes = [];
@@ -201,6 +203,7 @@ export async function createTamnoraServer({
   registerProviders(route, ctx);
   registerMcp(route, ctx);
   registerSkills(route, ctx);
+  registerChannels(route, ctx);
   registerProcs(route, ctx);
   const preview = registerPreview(route, ctx);
   registerChat(route, ctx);

package/harness/packages/server/test/server.test.js

@@ -6,6 +6,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { createTamnoraServer } from '../src/index.js';
 import { setHome, ensureApp, readApp, writeApp, makeUser } from '../../core/src/index.js';
+import { completionFooter } from '../src/lib/channels/telegram.js';
 
 const fakeProvider = {
   id: 'fake',
@@ -224,6 +225,90 @@ test('keeps a run alive after the client disconnects and can stop it', async ()
   }
 });
 
+test('done reports max_rounds and the tool count when the model never answers', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-loop-'));
+  await writeFile(path.join(cwd, 'a.txt'), 'hola');
+  let seq = 0;
+  const provider = {
+    id: 'loop',
+    async streamChat() {
+      seq += 1;
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: `call_${seq}`, function: { name: 'read', arguments: JSON.stringify({ path: 'a.txt' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const sse = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'leé', model: 'm', maxRounds: 2 }),
+      })
+    ).text();
+    assert.match(sse, /event: done/);
+    assert.match(sse, /"stopReason":"max_rounds"/);
+    const match = sse.match(/"toolCalls":(\d+)/);
+    assert.ok(match && Number(match[1]) >= 2, 'el done debe reportar las tools usadas');
+    assert.match(sse, /"durationMs":\d+/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('completionFooter resume el cierre del turno', () => {
+  assert.equal(completionFooter('end_turn', 1, 0, 0), '✓ terminado · 1 ronda');
+  assert.equal(completionFooter('end_turn', 3, 5, 1200), '✓ terminado · 3 rondas · 5 herramientas · 1.2s');
+  assert.match(completionFooter('max_rounds', 2, 2, 300), /^⚠ máximo de rondas · 2 rondas · 2 herramientas · 300ms$/);
+});
+
+test('configures Telegram from the console (masked token)', async () => {
+  const { instance, base } = await startServer({ telegram: false });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    let data = await (await fetch(`${base}/api/channels`)).json();
+    assert.equal(data.telegram.tokenSet, false);
+    assert.equal(data.telegram.transcribeModel, 'whisper-1');
+
+    let res = await fetch(`${base}/api/channels/telegram`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ allowedChatIds: '123, 456', transcribeModel: '' }),
+    });
+    data = await res.json();
+    assert.deepEqual(data.telegram.allowedChatIds, ['123', '456']);
+    assert.equal(data.telegram.transcribeModel, 'whisper-1');
+
+    res = await fetch(`${base}/api/channels/telegram`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ token: '123456:ABCDEFghij', transcribeProvider: 'openai' }),
+    });
+    data = await res.json();
+    assert.equal(data.telegram.tokenSet, true);
+    assert.equal(data.telegram.transcribeProvider, 'openai');
+    assert.match(data.telegram.tokenHint, /ghij$/);
+    assert.doesNotMatch(JSON.stringify(data), /ABCDEF/);
+
+    // Mandar la mascara no pisa el token real.
+    res = await fetch(`${base}/api/channels/telegram`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ token: data.telegram.tokenHint, allowedChatIds: ['1'] }),
+    });
+    data = await res.json();
+    assert.equal(data.telegram.tokenSet, true);
+    assert.match(data.telegram.tokenHint, /ghij$/);
+  } finally {
+    await instance.close();
+  }
+});
+
 test('manages MCP servers from the console', async () => {
   const { instance, base } = await startServer();
   const json = { 'Content-Type': 'application/json' };

package/harness/packages/server/test/telegram.test.js

@@ -0,0 +1,94 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { Store } from '../../core/src/index.js';
+import { createApprovalBroker } from '../src/lib/approvals.js';
+import { startTelegramChannel } from '../src/lib/channels/telegram.js';
+
+const reply = (data) => ({ ok: true, json: async () => data });
+
+function installFetchMock() {
+  const sent = [];
+  const updates = [];
+  const original = global.fetch;
+  global.fetch = async (url, opts = {}) => {
+    const method = String(url).split('/').pop();
+    const body = opts.body ? JSON.parse(opts.body) : {};
+    if (method === 'getUpdates') {
+      const out = updates.splice(0, updates.length);
+      if (!out.length) await new Promise((resolve) => setTimeout(resolve, 20));
+      return reply({ ok: true, result: out });
+    }
+    if (method === 'sendMessage' || method === 'editMessageText') {
+      sent.push(body);
+      return reply({ ok: true, result: { message_id: sent.length } });
+    }
+    return reply({ ok: true, result: true });
+  };
+  return { sent, updates, restore: () => { global.fetch = original; } };
+}
+
+function makeCtx(cwd) {
+  const store = new Store(':memory:');
+  const provider = {
+    id: 'fake',
+    async streamChat(_config, { onEvent }) {
+      onEvent?.({ type: 'text', delta: 'listo', full: 'listo' });
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  return {
+    cwd,
+    config: { maxRounds: 2, permissions: {}, telegram: {} },
+    app: {},
+    store,
+    approvals: createApprovalBroker({ timeoutMs: 1000 }),
+    effectiveProviderId: () => 'fake',
+    effectiveModel: () => 'm',
+    effectiveMode: () => 'agent',
+    providerSettings: () => ({ baseUrl: 'http://127.0.0.1:1', apiKey: '' }),
+    apiKeyFor: () => '',
+    customProviderDefs: () => [],
+    resolveProvider: () => ({ provider, config: {} }),
+    getMcp: async () => null,
+    systemPromptFor: async () => 'sys',
+    agentTools: { definitions: [], handles: () => false, execute: async () => '' },
+  };
+}
+
+async function waitFor(fn, timeout = 3000) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (fn()) return;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw new Error('timeout esperando la condición');
+}
+
+test('el canal de Telegram cierra el turno y muestra el panel', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tg-'));
+  const ctx = makeCtx(cwd);
+  const mock = installFetchMock();
+  const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
+  try {
+    mock.updates.push({ update_id: 1, message: { chat: { id: 7 }, text: 'hola' } });
+    await waitFor(() => mock.sent.some((m) => /✓ terminado/.test(m.text ?? '')));
+    const completion = mock.sent.find((m) => /✓ terminado/.test(m.text ?? ''));
+    assert.match(completion.text, /listo/);
+    assert.match(completion.text, /1 ronda/);
+
+    mock.updates.push({ update_id: 2, message: { chat: { id: 7 }, text: '/menu' } });
+    await waitFor(() => mock.sent.some((m) => m.reply_markup?.inline_keyboard));
+    const menu = mock.sent.find((m) => m.reply_markup?.inline_keyboard);
+    const datas = menu.reply_markup.inline_keyboard.flat().map((b) => b.callback_data);
+    assert.ok(datas.includes('mode:plan'));
+    assert.ok(datas.includes('menu:models'));
+    assert.ok(datas.includes('menu:stop'));
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",