@danieltmn/tamnora 0.8.0 → 0.9.1

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

@@ -177,6 +177,23 @@ html[data-theme='dark'] #theme-toggle .ico-moon { display: block; }
 .menu-pop button.active { background: var(--theirs); color: var(--accent); }
 .settings { grid-column: 3; justify-self: end; display: flex; align-items: center; gap: 8px; }
 .settings select { max-width: 220px; }
+
+/* Nueva sesión en el topbar: texto en desktop, solo el icono en móvil, donde
+   el ancho es el recurso escaso. */
+.topbar-new {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  height: 34px;
+  padding: 0 13px;
+  flex: 0 0 auto;
+}
+.topbar-new svg { width: 18px; height: 18px; display: block; flex: 0 0 auto; }
+.topbar-new-label { display: none; }
+@media (min-width: 821px) {
+  .topbar-new-label { display: inline; }
+}
 .check { color: var(--muted); display: flex; align-items: center; gap: 5px; cursor: pointer; }
 
 select, input, textarea {
@@ -204,6 +221,8 @@ main { flex: 1; min-height: 0; min-width: 0; display: flex; }
   cursor: pointer;
   font: 600 12.5px var(--sans);
   transition: 0.15s ease;
+  /* Sin esto, en una fila apretada "denegar" se parte en "den egar". */
+  white-space: nowrap;
 }
 .btn:hover { border-color: var(--accent); color: var(--text); }
 .btn.primary { background: var(--accent); border-color: var(--accent); color: var(--primary-fg); font-weight: 700; }
@@ -266,6 +285,29 @@ main { flex: 1; min-height: 0; min-width: 0; display: flex; }
 .session-item.active { background: var(--theirs); color: var(--text); border-color: var(--border); }
 .session-item .sub { color: var(--muted); font-size: 11px; overflow: hidden; text-overflow: ellipsis; }
 .session-item .session-title { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; }
+.session-live {
+  flex: none;
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--accent);
+  animation: live-pulse 1.4s ease-in-out infinite;
+}
+.session-await {
+  flex: none;
+  padding: 0 5px;
+  height: 14px;
+  line-height: 14px;
+  border-radius: 7px;
+  font-size: 10px;
+  font-weight: 700;
+  color: var(--bg);
+  background: var(--warn);
+}
+@keyframes live-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.25; }
+}
 .session-del,
 .group-del {
   flex: 0 0 auto;
@@ -558,6 +600,12 @@ body.resizing * { cursor: col-resize !important; }
   overflow: auto;
 }
 .tool-card > .tool-out:empty { display: none; }
+.tool-card > .tool-audio {
+  display: block;
+  width: calc(100% - 28px);
+  height: 32px;
+  margin: 4px 0 2px 18px;
+}
 .tool-more {
   display: inline-block;
   margin: 2px 0 2px 18px;
@@ -632,7 +680,7 @@ body.resizing * { cursor: col-resize !important; }
   background: rgba(210, 153, 34, 0.06);
 }
 .perm-card .perm-head { display: flex; gap: 7px; align-items: center; color: var(--warn); font-weight: 700; }
-.perm-card .perm-args { color: var(--muted); margin: 5px 0 9px; white-space: pre-wrap; word-break: break-word; }
+.perm-card .perm-args { color: var(--muted); margin: 5px 0 9px; white-space: pre-wrap; word-break: break-word; max-height: 7.5em; overflow: auto; }
 .perm-card .perm-actions { display: flex; align-items: center; gap: 8px; }
 .perm-card .spacer { flex: 1; }
 .perm-card.approved { border-color: var(--ok); background: rgba(63, 185, 80, 0.06); }
@@ -727,6 +775,71 @@ details.reasoning .body { color: var(--muted); white-space: pre-wrap; margin-top
 .queue-remove:hover { color: var(--danger); background: var(--theirs); }
 .shell-out { margin: 0; padding: 8px 10px; max-height: 320px; overflow: auto; background: var(--theirs); border: 1px solid var(--border); border-radius: 8px; font: 11.5px/1.5 var(--mono); white-space: pre-wrap; word-break: break-word; }
 .attach-preview { display: flex; gap: 8px; flex-wrap: wrap; padding-bottom: 2px; }
+.sb-channel {
+  font-size: 11px;
+  color: var(--warn);
+  border: 1px solid currentColor;
+  border-radius: 9px;
+  padding: 0 6px;
+  cursor: help;
+}
+.sb-channel.retrying { animation: live-pulse 1.4s ease-in-out infinite; }
+.toasts {
+  /* Encima del composer, no sobre el: al borde inferior tapaba el banner y los
+     botones, y cada toast (con `pointer-events: auto`) les robaba los clics. */
+  position: absolute;
+  bottom: calc(100% + 6px);
+  left: 10px;
+  right: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  pointer-events: none;
+  z-index: 5;
+}
+.toast {
+  pointer-events: auto;
+  cursor: pointer;
+  padding: 7px 11px;
+  border: 1px solid var(--border);
+  border-left: 3px solid var(--warn);
+  border-radius: 8px;
+  background: var(--panel);
+  color: var(--text);
+  font-size: 12.5px;
+  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.18);
+}
+
+/* Banner de permisos: se decide desde cualquier pestana o sesion, asi que vive
+   en el composer y no dentro del mensaje de una sesion. */
+.perm-banner { display: flex; flex-direction: column; gap: 6px; margin-bottom: 8px; }
+.perm-banner[hidden] { display: none; }
+.perm-banner-row {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  padding: 9px 11px;
+  border: 1px solid var(--warn);
+  border-radius: 9px;
+  background: rgba(217, 112, 74, 0.08);
+}
+.perm-banner-label { display: flex; align-items: center; gap: 7px; flex-wrap: wrap; }
+.perm-banner-icon { color: var(--warn); font-weight: 700; }
+.perm-banner-title { font-weight: 700; color: var(--text); }
+.perm-banner-session { font-size: 11.5px; color: var(--muted); border: 1px solid var(--border); border-radius: 8px; padding: 0 6px; }
+.perm-banner-args {
+  color: var(--muted);
+  font-family: var(--mono, monospace);
+  font-size: 11.5px;
+  /* Recorte limpio: `overflow` a secas cortaba la linea por la mitad y se
+     leia como texto roto. */
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+  word-break: break-word;
+}
+.perm-banner-row > .btn { align-self: flex-start; }
 .attach-thumb { position: relative; }
 .attach-thumb img { height: 64px; border-radius: 6px; border: 1px solid var(--border); display: block; }
 .attach-remove {
@@ -862,6 +975,9 @@ pre.code code { background: none; border: 0; padding: 0; font-size: 0.92em; }
 
 .card { border: 1px solid var(--border); background: var(--panel); backdrop-filter: blur(14px); border-radius: 14px; padding: 14px; display: flex; flex-direction: column; gap: 10px; }
 
+/* ajustes: voz (TTS) -------------------------------------------------------- */
+.voz-announce { display: flex; align-items: center; gap: 14px; flex-wrap: wrap; border-top: 1px solid var(--border); border-bottom: 1px solid var(--border); padding: 8px 0; }
+
 /* ajustes: pestañas internas ---------------------------------------------- */
 #view-ajustes.active { display: block; overflow-y: auto; }
 .ajustes-wrap { width: 100%; max-width: 780px; margin: 0 auto; padding: 18px; display: flex; flex-direction: column; gap: 12px; min-height: 100%; }
@@ -1202,10 +1318,13 @@ dialog.file-modal.preview-maximized {
   .topbar {
     position: relative;
     display: flex;
-    flex-wrap: wrap;
+    /* Una sola fila: con `wrap` los botones de accion caian a una segunda
+       linea y empujaban el chat hacia abajo. */
+    flex-wrap: nowrap;
     gap: 8px 10px;
     padding: 8px 12px;
   }
+  .brand { flex: 0 0 auto; }
   .brand .ver {
     display: none;
   }
@@ -1232,13 +1351,20 @@ dialog.file-modal.preview-maximized {
   .settings {
     grid-column: auto;
     margin-left: 0;
-    flex: 1 1 100%;
-    flex-wrap: wrap;
-    gap: 8px;
+    /* Antes `1 1 100%`: eso ocupaba toda la fila y mandaba los botones a una
+       segunda linea. Ahora se quedan en la misma linea que TH. */
+    flex: 0 0 auto;
+    flex-wrap: nowrap;
+    gap: 6px;
   }
   .settings .btn.icon {
     flex: 0 0 auto;
   }
+  /* Cuadrado como los demas iconos: el texto no entra en un movil angosto. */
+  .topbar-new {
+    width: 34px;
+    padding: 0;
+  }
 
   /* sidebar como drawer deslizante */
   .sidebar {
@@ -1296,6 +1422,17 @@ dialog.file-modal.preview-maximized {
 }
 
 @media (max-width: 480px) {
+  /* Cinco elementos en una fila no entran en un movil angosto: el nombre del
+     tab activo es lo unico que sobra, y el menu de puntos ya lo deja claro. */
+  .topbar {
+    gap: 8px 8px;
+  }
+  #more-tab-label {
+    display: none;
+  }
+  .settings {
+    gap: 5px;
+  }
   .settings select {
     flex: 1 1 100%;
   }

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

@@ -1,5 +1,7 @@
 import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
 import { sendError } from './lib/http.js';
+import { tunnelState } from './lib/core.js';
+import { isLoopback } from './lib/workspace.js';
 
 /**
  * Autenticacion web con cookie de sesion firmada (stateless), CSRF y bloqueo
@@ -37,14 +39,25 @@ export function parseCookies(header) {
 }
 
 // Detras del tunel el server recibe desde loopback: solo ahi confiamos en
-// X-Forwarded-Proto para marcar la cookie Secure.
+// X-Forwarded-Proto para marcar la cookie Secure. Como el cliente del tunel
+// corre en la misma maquina, un request por el tunel es indistinguible de uno
+// local por direccion: usamos el Host (localhost/127.0.0.1 = local) y el
+// estado del bridge para no mandar la cookie sin Secure por el tunel.
+function isLocalHost(req) {
+  const host = String(req.headers.host || '').split(':')[0].toLowerCase();
+  return !host || host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '[::1]';
+}
+
 function isSecure(req) {
   if (req.socket && req.socket.encrypted) return true;
   const remote = req.socket && req.socket.remoteAddress;
-  const loopback = !remote || remote === '127.0.0.1' || remote === '::1' || remote === '::ffff:127.0.0.1';
+  const loopback = !remote || isLoopback(remote);
   if (!loopback) return false;
   const proto = String(req.headers['x-forwarded-proto'] || '').split(',')[0].trim().toLowerCase();
-  return proto === 'https';
+  if (proto === 'https') return true;
+  // Peticion por el tunel (host publico + bridge activo): la URL publica es
+  // HTTPS, la cookie no tiene que poder viajar por la variante http.
+  return Boolean(tunnelState()) && !isLocalHost(req);
 }
 
 function serializeCookie(value, req, maxAge) {
@@ -112,17 +125,27 @@ export function requireCsrf(app, req, res) {
 // ---------------------------------------------------------------------------
 // Bloqueo por intentos fallidos (en memoria: el server es un proceso).
 // ---------------------------------------------------------------------------
+// La clave usa remoteAddress: X-Forwarded-For lo controla el cliente y con un
+// header falsificado se rotaba de IP y se esquivaba el bloqueo.
 const MAX_ATTEMPTS = 5;
 const WINDOW_MS = 15 * 60 * 1000;
 const LOCK_MS = 15 * 60 * 1000;
+const MAX_KEYS = 256;
 const attempts = new Map();
 
 function clientKey(req, user) {
-  const xff = String(req.headers['x-forwarded-for'] || '').split(',')[0].trim();
-  const ip = xff || (req.socket && req.socket.remoteAddress) || 'desconocido';
+  const ip = (req.socket && req.socket.remoteAddress) || 'desconocido';
   return `${ip}|${String(user || '').trim().toLowerCase()}`;
 }
 
+function sweepStale(now) {
+  if (attempts.size < MAX_KEYS) return;
+  for (const [key, st] of attempts) {
+    const expired = (!st.lockUntil || st.lockUntil < now) && now - st.first > WINDOW_MS;
+    if (expired) attempts.delete(key);
+  }
+}
+
 export function loginLockRemaining(req, user) {
   const now = Date.now();
   const st = attempts.get(clientKey(req, user));
@@ -133,6 +156,7 @@ export function loginLockRemaining(req, user) {
 
 export function loginRecordFailure(req, user) {
   const now = Date.now();
+  sweepStale(now);
   const key = clientKey(req, user);
   let st = attempts.get(key);
   if (!st || (!st.lockUntil && now - st.first > WINDOW_MS)) st = { count: 0, first: now, lockUntil: 0 };

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

@@ -0,0 +1,77 @@
+// Pedazos compartidos del scaffolding "correr un agente" (chat HTTP, Telegram,
+// subagentes). La creacion de tools y el onEvent de cada canal siguen siendo
+// propios (los canales de salida son distintos); lo combinable vive aca.
+
+import { summarizeToolCall, previewToolResult } from './core.js';
+
+const FAILED_RE = /^Error|^Permiso denegado/i;
+
+/** Payload estandar de un tool_result para eventos SSE: preview + failed. */
+export function toolResultPayload(event) {
+  const { preview, truncated } = previewToolResult(event.name, event.result);
+  return { preview, truncated, failed: FAILED_RE.test(String(event.result)) };
+}
+
+export function toolCallPayload(event) {
+  return { id: event.id, name: event.name, args: event.args, summary: summarizeToolCall(event.name, event.args) };
+}
+
+/**
+ * Combina tools locales + admin + subagentes en un toolset unificado.
+ * `approve` es el callback de aprobacion de las tools de administraación.
+ */
+export function combineToolset({ local, admin = null, tasks = null, exposeAdmin = false, approve = null }) {
+  const definitions = [
+    ...local.definitions,
+    ...(exposeAdmin && admin ? admin.definitions : []),
+    ...(tasks ? tasks.definitions : []),
+  ];
+  const execute = (name, args, context) => {
+    if (tasks?.handles(name)) return tasks.execute(name, args);
+    if (exposeAdmin && admin?.handles(name)) {
+      return admin.execute(name, args, approve ? { approve } : undefined);
+    }
+    return local.execute(name, args, context);
+  };
+  return { definitions, execute };
+}
+
+/** Resuelve proveedor + config con la API key almacenada. */
+export function resolveProviderFor(ctx, providerId, extra = {}) {
+  return ctx.resolveProvider({
+    ...ctx.providerSettings(providerId),
+    apiKey: ctx.apiKeyFor(providerId),
+    ...extra,
+  });
+}
+
+/** Mensaje del usuario, multinodal si hay imagenes (data URLs). */
+export function buildUserMessage(input, images = []) {
+  if (images.length) {
+    return {
+      role: 'user',
+      content: [
+        { type: 'text', text: input },
+        ...images.map((url) => ({ type: 'image_url', image_url: { url } })),
+      ],
+    };
+  }
+  return { role: 'user', content: input };
+}
+
+/**
+ * Arma el array de mensajes del turno: system prompt (con el del modo) +
+ * objetivo/resumen de la sesion + historial + mensaje del usuario.
+ */
+export async function composeAgentMessages({ ctx, cwd, mode, history = [], userMessage, sessionRecord = null }) {
+  const basePrompt = await ctx.systemPromptFor(cwd);
+  const goal = sessionRecord?.meta?.goal;
+  const summary = sessionRecord?.meta?.summary;
+  return [
+    { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
+    ...(goal ? [{ role: 'system', content: `Objetivo de la sesión: ${goal}` }] : []),
+    ...(summary ? [{ role: 'system', content: `Resumen de la conversación anterior:\n${summary}` }] : []),
+    ...history,
+    userMessage,
+  ];
+}

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

@@ -0,0 +1,92 @@
+// Frases habladas del agente: un resumen corto de lo que esta haciendo, armado
+// por plantillas a partir de los eventos del run (sin llamar al modelo). Se
+// adjuntan como `say` a los eventos del turno (start/tool_call/done) para que
+// la consola las sintetice con el TTS, y las usa Telegram para la nota de voz
+// final. La idea es narrar el progreso, no leer la respuesta entera.
+
+const MAX_FRASE = 200;
+
+/** Recorta una frase al tope, sin cortar una palabra a la mitad. */
+function recortar(frase) {
+  const value = String(frase ?? '').replace(/\s+/g, ' ').trim();
+  if (value.length <= MAX_FRASE) return value;
+  return `${value.slice(0, MAX_FRASE - 1).replace(/\s+\S*$/, '')}…`;
+}
+
+const VERBOS = {
+  read: 'Leyendo',
+  list: 'Explorando',
+  glob: 'Buscando',
+  grep: 'Buscando',
+  write: 'Escribiendo',
+  edit: 'Editando',
+  bash: 'Ejecutando',
+  fetch_url: 'Consultando',
+  git_status: 'Mirando el estado de git',
+  git_diff: 'Mirando los cambios de git',
+  git_log: 'Mirando el historial de git',
+  git_commit: 'Commiteando',
+  task: 'Delegando en un subagente',
+  spawn_agent: 'Delegando en un subagente',
+};
+
+/**
+ * Frase para un tool-call: verbo + resumen de la tool. Devuelve '' para tools
+ * mudas (la consola ya las colapsa por ser ruido de lectura).
+ */
+export function fraseTool(name, summary) {
+  const tool = String(name ?? '');
+  if (tool.startsWith('mcp__')) {
+    const server = tool.split('__')[1] ?? '';
+    return server ? `Usando una herramienta de ${server}` : '';
+  }
+  const verbo = VERBOS[tool];
+  if (!verbo) return '';
+  if (tool === 'git_status' || tool === 'git_diff' || tool === 'git_log' || tool === 'git_commit') {
+    return summary ? `${verbo}: ${summary}` : verbo;
+  }
+  if (!summary) return verbo;
+  return recortar(`${verbo} ${summary}`);
+}
+
+/** Frase de arranque del turno. */
+export function fraseInicio() {
+  return 'Empecé a trabajar en tu pedido.';
+}
+
+/** Frase de cierre: rondas, herramientas y duracion, o el motivo del corte. */
+export function fraseFin({ stopReason, rounds, toolCalls, durationMs } = {}) {
+  const segundos = Math.round((Number(durationMs) || 0) / 1000);
+  const tiempo = segundos >= 1 ? `, ${segundos} segundo${segundos === 1 ? '' : 's'}` : '';
+  if (stopReason === 'aborted') return 'Cancelado.';
+  if (['max_rounds', 'no_progress', 'budget'].includes(stopReason)) {
+    return `Terminé por un corte de seguridad tras ${rounds ?? '?'} ronda${rounds === 1 ? '' : 's'}${tiempo}.`;
+  }
+  const rondas = Number(rounds) || 0;
+  const herramientas = Number(toolCalls) || 0;
+  if (!herramientas) return 'Listo. Respondí sin usar herramientas.';
+  return `Listo. ${rondas} ronda${rondas === 1 ? '' : 's'}, ${herramientas} herramienta${herramientas === 1 ? '' : 's'}${tiempo}.`;
+}
+
+/** Frase para un error del turno. */
+export function fraseError() {
+  return 'Ocurrió un error.';
+}
+
+/**
+ * Filtro con memoria para no hablar cada tool-call: descarta la misma frase
+ * consecutiva y aplica una ventana minima entre frases de tools.
+ */
+export function createFiltroTools({ minGapMs = 20000 } = {}) {
+  let ultima = 0;
+  let ultimaFrase = '';
+  return (name, summary) => {
+    const frase = fraseTool(name, summary);
+    if (!frase || frase === ultimaFrase) return '';
+    const ahora = Date.now();
+    if (ahora - ultima < minGapMs) return '';
+    ultima = ahora;
+    ultimaFrase = frase;
+    return frase;
+  };
+}

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

@@ -4,6 +4,11 @@
  * event; the console answers by POSTing to `/api/permissions/:id`, which calls
  * `decide`. Requests that nobody answers expire to `false` (deny).
  *
+ * `ask` guarda tambien los `meta` de que se pidio. Eso es lo que permite que un
+ * cliente que **no** esta suscrito al stream de la sesion sepa igual que hay un
+ * permiso esperando: sin esto el permiso solo existe dentro del SSE y un celular
+ * sin stream no tiene forma de enterarse.
+ *
  * @param {object} [opts]
  * @param {number} [opts.timeoutMs] - how long to wait before denying
  */
@@ -20,12 +25,16 @@ export function createApprovalBroker({ timeoutMs = 300000 } = {}) {
   }
 
   return {
-    /** Register a pending request; resolves to a boolean decision. */
-    ask(id) {
+    /**
+     * Register a pending request; resolves to a boolean decision.
+     * `meta` (sessionId, name, args...) es opcional y solo sirve para poder
+     * listar lo pendiente.
+     */
+    ask(id, meta = {}) {
       return new Promise((resolve) => {
         const timer = setTimeout(() => settle(id, false), timeoutMs);
         timer.unref?.();
-        pending.set(id, { resolve, timer });
+        pending.set(id, { resolve, timer, requestedAt: Date.now(), ...meta });
       });
     },
 
@@ -44,6 +53,19 @@ export function createApprovalBroker({ timeoutMs = 300000 } = {}) {
       for (const id of [...pending.keys()]) settle(id, false);
     },
 
+    /**
+     * Lo que sigue esperando, para que cualquier cliente pueda mostrarlo sin
+     * depender de tener un stream abierto. `sessionId` filtra por sesion.
+     */
+    list({ sessionId } = {}) {
+      const items = [];
+      for (const [askId, entry] of pending) {
+        if (sessionId !== undefined && entry.sessionId !== sessionId) continue;
+        items.push({ askId, sessionId: entry.sessionId ?? null, name: entry.name ?? '', args: entry.args ?? {}, requestedAt: entry.requestedAt });
+      }
+      return items.sort((a, b) => a.requestedAt - b.requestedAt);
+    },
+
     get pending() {
       return pending.size;
     },

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

@@ -3,8 +3,18 @@
 // inline. Cada chat mapea a una sesion del harness.
 
 import { randomUUID } from 'node:crypto';
-import { runAgent, createTools, resolveMode, summarizeToolCall, listProviderModels, PROVIDER_META } from '../core.js';
+import { runAgent, createTools, resolveMode, listProviderModels, PROVIDER_META, sintetizar, MAX_TEXTO } from '../core.js';
 import { resolveExistingDir } from '../workspace.js';
+import {
+  combineToolset,
+  composeAgentMessages,
+  buildUserMessage,
+  resolveProviderFor,
+  toolCallPayload,
+} from '../agentRun.js';
+import { fraseFin } from '../announcer.js';
+import { mp3AOgg } from '../ffmpeg.js';
+import { resolveTts } from '../ttsSettings.js';
 
 const API = 'https://api.telegram.org';
 
@@ -61,6 +71,23 @@ async function downloadFile(token, fileId) {
   return Buffer.from(await res.arrayBuffer());
 }
 
+/** Variante multipart de `tg` (sendVoice/sendAudio llevan el archivo adjunto). */
+async function tgForm(token, method, form) {
+  const res = await fetch(`${API}/bot${token}/${method}`, { method: 'POST', body: form });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+    data = null;
+  }
+  if (!data?.ok) {
+    const error = new Error(data?.description || `HTTP ${res.status}`);
+    error.status = res.status;
+    throw error;
+  }
+  return data.result;
+}
+
 function splitMessage(text, max = 3900) {
   const value = String(text ?? '').trim() || '(sin texto)';
   const parts = [];
@@ -115,6 +142,39 @@ export function startTelegramChannel(
     }
   }
 
+  /**
+   * Nota de voz con un texto cualquiera. Con ffmpeg manda OGG/Opus
+   * (`sendVoice`, aparece como nota de voz); sin ffmpeg cae a audio MP3.
+   * Un fallo del TTS no debe romper el run: se loguea y sigue.
+   */
+  async function enviarNotaDeVoz(chatId, texto, { voice, rate } = {}) {
+    const tts = resolveTts(ctx.app);
+    const frase = String(texto ?? '').trim().slice(0, MAX_TEXTO);
+    if (!frase) return;
+    try {
+      const mp3 = await sintetizar(frase, { voice: voice || tts.voice, rate: rate || tts.rate });
+      const ogg = await mp3AOgg(mp3);
+      const form = new FormData();
+      form.append('chat_id', chatId);
+      if (ogg) {
+        form.append('voice', new Blob([ogg], { type: 'audio/ogg' }), 'resumen.ogg');
+        await tgForm(token, 'sendVoice', form);
+      } else {
+        form.append('audio', new Blob([mp3], { type: 'audio/mpeg' }), 'resumen.mp3');
+        await tgForm(token, 'sendAudio', form);
+      }
+    } catch (error) {
+      log(`telegram: nota de voz falló: ${error?.message ?? error}`);
+    }
+  }
+
+  /** Resumen hablado del cierre del turno, según los ajustes de voz. */
+  async function sendResumenDeVoz(chatId, texto) {
+    const tts = resolveTts(ctx.app);
+    if (!tts.enabled || tts.announce.end === false) return;
+    await enviarNotaDeVoz(chatId, texto);
+  }
+
   function ensureSession(chatId) {
     const key = sessionKey(chatId);
     let sessionId = ctx.store.getSetting(key);
@@ -205,24 +265,10 @@ export function startTelegramChannel(
     });
     const exposeAdmin = !mode.tools;
     const admin = ctx.agentTools;
-    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
-    const execute = (name, args, context) =>
-      exposeAdmin && admin.handles(name)
-        ? admin.execute(name, args, { approve: onAsk })
-        : local.execute(name, args, context);
-    const { provider, config } = ctx.resolveProvider({
-      ...ctx.providerSettings(providerId),
-      apiKey: ctx.apiKeyFor(providerId),
-    });
-    const basePrompt = await ctx.systemPromptFor(cwd);
-    const userMessage = images.length
-      ? { role: 'user', content: [{ type: 'text', text: input }, ...images.map((url) => ({ type: 'image_url', image_url: { url } }))] }
-      : { role: 'user', content: input };
-    const messages = [
-      { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
-      ...history,
-      userMessage,
-    ];
+    const { definitions, execute } = combineToolset({ local, admin, exposeAdmin, approve: onAsk });
+    const { provider, config } = resolveProviderFor(ctx, providerId);
+    const userMessage = buildUserMessage(input, images);
+    const messages = await composeAgentMessages({ ctx, cwd, mode, history, userMessage });
 
     const controller = new AbortController();
     controllers.set(String(chatId), controller);
@@ -256,7 +302,10 @@ export function startTelegramChannel(
           if (event.type === 'text') {
             full = event.full;
           } else if (event.type === 'tool_call') {
-            activity = `${event.name} ${summarizeToolCall(event.name, event.args)}`.trim();
+            activity = `${event.name} ${toolCallPayload(event).summary}`.trim();
+            if (event.name === 'speak') {
+              enviarNotaDeVoz(chatId, event.args?.texto, { voice: event.args?.voice, rate: event.args?.rate });
+            }
           } else if (event.type === 'tool_result') {
             activity = `${event.name} ✓`;
           } else {
@@ -290,6 +339,7 @@ export function startTelegramChannel(
       }
       const footer = completionFooter(result.stopReason, result.rounds, toolCalls, durationMs);
       await edit(chatId, message.message_id, `${body}\n\n— ${footer}`);
+      await sendResumenDeVoz(chatId, fraseFin({ stopReason: result.stopReason, rounds: result.rounds, toolCalls, durationMs }));
       ctx.store.addMessages(sessionId, newMessages);
       ctx.store.touchSession(sessionId, { provider: providerId, model });
     } catch (error) {
@@ -527,8 +577,23 @@ export function startTelegramChannel(
       if (!chatId) return;
       if (event.type === 'done') {
         send(chatId, `✅ Sesión terminada.\n\n${String(event.data?.content ?? '').slice(0, 3500)}`).catch(() => {});
+        sendResumenDeVoz(
+          chatId,
+          event.data?.say ??
+            fraseFin({
+              stopReason: event.data?.stopReason,
+              rounds: event.data?.rounds,
+              toolCalls: event.data?.toolCalls,
+              durationMs: event.data?.durationMs,
+            })
+        );
       } else if (event.type === 'error') {
         send(chatId, `✗ Error en la sesión: ${event.data?.message ?? ''}`).catch(() => {});
+      } else if (event.type === 'tool_call' && event.data?.name === 'speak') {
+        enviarNotaDeVoz(chatId, event.data?.args?.texto, {
+          voice: event.data?.args?.voice,
+          rate: event.data?.args?.rate,
+        });
       } else if (event.type === 'agent_end') {
         send(chatId, `🤖 Subagente ${event.data?.status}: ${String(event.data?.content ?? '').slice(0, 1500)}`).catch(() => {});
       } else if (event.type === 'permission') {