@danieltmn/tamnora 0.22.0 → 0.23.0

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

@@ -0,0 +1,309 @@
+// Mensajes entrantes de Telegram: comandos (`/proyecto`, `/model`, ...), notas
+// de voz, fotos y los botones de los paneles.
+
+import { resolveMode, listProviderModels, PROVIDER_META } from '../../core.js';
+import { downloadFile, send, tg } from './api.js';
+import { enviarNotaDeVoz } from './media.js';
+import {
+  activeSessionId,
+  projectLabel,
+  projectRoot,
+  resolveProjectArg,
+  selectProject,
+  sendProjectPicker,
+} from './projects.js';
+import { resumirSesion, run } from './run.js';
+import { transcribeAudio } from '../../transcribe.js';
+
+const HELP = [
+  'Tamnora Harness — bot',
+  '',
+  '/proyecto [nombre] — elegí el proyecto (sin argumento: lista)',
+  '/new — nueva sesión (vuelve a preguntar el proyecto)',
+  '/resumen — resumen en texto de la conversación',
+  '/audioresumen — el resumen como nota de voz',
+  '/menu — panel con botones (modelo, modo, proveedor)',
+  '/status — proveedor, modelo, modo, proyecto y sesión',
+  '/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)',
+  '/estricto [on|off] — el agente hace solo lo pedido (sin arg: alterna)',
+  '/stop — cancela la respuesta en curso',
+  '/help — esta ayuda',
+  '',
+  'Podés mandar texto, imágenes o notas de voz.',
+].join('\n');
+
+function transcribe(T, buffer, filename) {
+  return transcribeAudio(T.ctx, {
+    buffer,
+    filename,
+    providerId: T.transcribeProvider || undefined,
+    model: T.transcribeModel,
+  });
+}
+
+export async function sendMenu(T, chatId) {
+  const sessionId = activeSessionId(T, chatId);
+  const session = sessionId ? T.ctx.store.getSession(sessionId) : null;
+  const providerId = session?.provider || T.ctx.effectiveProviderId();
+  const model = session?.model || T.ctx.effectiveModel() || '-';
+  const mode = resolveMode(T.ctx.effectiveMode());
+  const text = [
+    '⚙ Panel',
+    `proyecto: ${session ? projectLabel(session) : '(elegí con /proyecto)'}`,
+    `proveedor: ${providerId}`,
+    `modelo: ${model}`,
+    `modo: ${mode.label}`,
+  ].join('\n');
+  await send(T, 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: '?? proyecto', callback_data: 'menu:project' },
+          { text: '?? nueva', callback_data: 'menu:new' },
+        ],
+        [{ text: '⚙ detener', callback_data: 'menu:stop' }],
+      ],
+    },
+  });
+}
+
+export async function sendModels(T, chatId) {
+  const sessionId = activeSessionId(T, chatId);
+  const session = sessionId ? T.ctx.store.getSession(sessionId) : null;
+  const providerId = session?.provider || T.ctx.effectiveProviderId();
+  const models = await listProviderModels({
+    ...T.ctx.providerSettings(providerId),
+    apiKey: T.ctx.apiKeyFor(providerId),
+  }).catch(() => []);
+
+  const current = session?.model || T.ctx.effectiveModel();
+  if (!models?.length) return send(T, chatId, 'No pude listar modelos. Usá /model <id>.');
+  const capped = models.slice(0, 12);
+  T.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(T, chatId, `Modelos de ${providerId} (elegí uno):`, { reply_markup: { inline_keyboard: rows } });
+  if (models.length > capped.length) {
+    send(T, chatId, `Hay ${models.length} modelos; mostré 12. Para otro, usá /model <id>.`).catch(() => {});
+  }
+}
+
+export async function sendProviders(T, chatId) {
+  const custom = T.ctx.customProviderDefs?.() ?? [];
+  const ids = [...new Set([...PROVIDER_META.map((p) => p.id), ...custom.map((p) => p.id)])];
+  const current = T.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(T, chatId, 'Proveedores (elegí uno):', { reply_markup: { inline_keyboard: rows } });
+}
+
+export async function handleCommand(T, chatId, text) {
+  const [raw, ...rest] = text.slice(1).split(/\s+/);
+  const cmd = raw.toLowerCase();
+  const arg = rest.join(' ').trim();
+  const sessionId = activeSessionId(T, chatId);
+  if (cmd === 'start') {
+    if (sessionId) {
+      return send(T, chatId, `Hola. Proyecto actual: «${projectLabel(T.ctx.store.getSession(sessionId))}».\n\n${HELP}`);
+    }
+    return sendProjectPicker(T, chatId, { text: 'Hola. ¿En qué proyecto vas a trabajar?' });
+  }
+  if (cmd === 'help' || cmd === 'ayuda') return send(T, chatId, HELP);
+  if (cmd === 'menu' || cmd === 'panel' || cmd === 'config') return sendMenu(T, chatId);
+  if (cmd === 'new' || cmd === 'nueva') {
+    T.ctx.store.setSetting(T.sessionKey(chatId), null);
+    T.pendingInputs.delete(String(chatId));
+    return sendProjectPicker(T, chatId, { text: 'Nueva sesión. ¿En qué proyecto vas a trabajar?' });
+  }
+  if (cmd === 'proyecto' || cmd === 'proyectos' || cmd === 'project') {
+    if (!arg) return sendProjectPicker(T, chatId);
+    const projectPath = resolveProjectArg(T, arg);
+    if (!projectPath) {
+      return send(T, chatId, `No encontré el proyecto "${arg}". Usá /proyecto sin argumento para ver la lista.`);
+    }
+    return selectProject(T, chatId, projectPath);
+  }
+  if (cmd === 'status') {
+    const session = sessionId ? T.ctx.store.getSession(sessionId) : null;
+    return send(
+      T,
+      chatId,
+      `proyecto: ${session ? projectLabel(session) : '-'}\nproveedor: ${session?.provider || T.ctx.effectiveProviderId()}\nmodelo: ${session?.model || T.ctx.effectiveModel() || '-'}\nmodo: ${T.ctx.effectiveMode()}\nsolo lo pedido: ${T.ctx.store.getSetting('strictScope') === true ? 'sí' : 'no'}\nsesión: ${session?.title || '-'}`,
+    );
+  }
+  if (cmd === 'resumen' || cmd === 'resume') {
+    if (!sessionId) return send(T, chatId, 'No hay una conversación todavía. Elegí un proyecto con /proyecto.');
+    const data = await resumirSesion(T, sessionId).catch((error) => ({ error: error.message }));
+    if (data.error) return send(T, chatId, `No pude resumir: ${data.error}`);
+    return send(T, chatId, `?📝 Resumen\n\n${data.summary}`);
+  }
+  if (cmd === 'audioresumen' || cmd === 'audio-resumen') {
+    if (!sessionId) return send(T, chatId, 'No hay una conversación todavía. Elegí un proyecto con /proyecto.');
+    await send(T, chatId, '?📝 Preparando el resumen.');
+    const data = await resumirSesion(T, sessionId).catch((error) => ({ error: error.message }));
+    if (data.error) return send(T, chatId, `No pude resumir: ${data.error}`);
+    await send(T, chatId, `?📝 Resumen\n\n${data.summary}`);
+    return enviarNotaDeVoz(T, chatId, data.summary);
+  }
+  if (cmd === 'model' || cmd === 'modelo') {
+    if (!arg) return sendModels(T, chatId);
+    T.ctx.store.setSetting('activeModel', arg);
+    if (sessionId) T.ctx.store.touchSession(sessionId, { model: arg });
+    return send(T, chatId, `modelo: ${arg}`);
+  }
+  if (cmd === 'provider' || cmd === 'proveedor') {
+    if (!arg) return sendProviders(T, chatId);
+    T.ctx.store.setSetting('activeProvider', arg);
+    if (sessionId) T.ctx.store.touchSession(sessionId, { provider: arg });
+    return send(T, chatId, `proveedor: ${arg}`);
+  }
+  if (cmd === 'mode' || cmd === 'modo') {
+    if (!arg) return sendMenu(T, chatId);
+    const id = arg.toLowerCase() === 'build' ? 'agent' : arg.toLowerCase();
+    T.ctx.store.setSetting('activeMode', resolveMode(id).id);
+    return send(T, chatId, `modo: ${resolveMode(id).label}`);
+  }
+  if (cmd === 'stop' || cmd === 'parar') {
+    T.controllers.get(String(chatId))?.abort();
+    return send(T, chatId, 'Cancelando.');
+  }
+  if (cmd === 'estricto' || cmd === 'strict') {
+    const current = T.ctx.store.getSetting('strictScope') === true;
+    const value = arg ? /^(on|si|sí|1|true)$/i.test(arg) : !current;
+    T.ctx.store.setSetting('strictScope', value);
+    return send(T, chatId, `solo lo pedido: ${value ? 'activado' : 'desactivado'}`);
+  }
+  return send(T, chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
+}
+
+export async function handleVoice(T, chatId, voice) {
+  await send(T, chatId, '?📝 Transcribiendo.');
+  try {
+    const buffer = await downloadFile(T.token, voice.file_id);
+    const text = await transcribe(T, buffer, voice.file_name || 'audio.ogg');
+    if (!text) return send(T, chatId, 'No pude transcribir el audio.');
+    await send(T, chatId, `?? ${text}`);
+    return deliver(T, chatId, text);
+  } catch (error) {
+    return send(T, chatId, `No pude procesar el audio: ${error.message}`);
+  }
+}
+
+/** Entrega un mensaje: si no hay proyecto elegido, primero pregunta cuál. */
+export async function deliver(T, chatId, input, images = []) {
+  if (!activeSessionId(T, chatId)) {
+    T.pendingInputs.set(String(chatId), { input, images });
+    return sendProjectPicker(T, chatId);
+  }
+  return run(T, chatId, input, images);
+}
+
+export async function handleMessage(T, message) {
+  const chatId = String(message.chat.id);
+  if (!T.authorized(chatId)) {
+    await send(T, chatId, `No autorizado. Tu chat id es ${chatId}; agregalo a telegram.allowedChatIds para habilitarlo.`);
+    return;
+  }
+  const text = String(message.text ?? message.caption ?? '').trim();
+  if (text.startsWith('/')) {
+    await handleCommand(T, chatId, text);
+    return;
+  }
+  if (message.voice || message.audio) {
+    await handleVoice(T, chatId, message.voice ?? message.audio);
+    return;
+  }
+  if (message.photo?.length) {
+    try {
+      const largest = message.photo[message.photo.length - 1];
+      const buffer = await downloadFile(T.token, largest.file_id);
+      const dataUrl = `data:image/jpeg;base64,${buffer.toString('base64')}`;
+      await deliver(T, chatId, text || '(imagen)', [dataUrl]);
+    } catch (error) {
+      await send(T, chatId, `No pude procesar la imagen: ${error.message}`);
+    }
+    return;
+  }
+  if (text) await deliver(T, chatId, text);
+}
+
+export async function handleCallback(T, query) {
+  const chatId = String(query.message?.chat.id ?? '');
+  const [kind, a, b] = String(query.data ?? '').split(':');
+  let toast = '';
+
+  if (kind === 'perm') {
+    const all = b === 'all';
+    T.ctx.approvals.decide(a, b === 'allow' || all);
+    const sessionId = T.askSessions.get(a);
+    if (sessionId) T.askSessions.delete(a);
+    if (all && sessionId) T.ctx.setAutoApprove?.(sessionId, true);
+    toast = all ? 'Permitidos todos' : b === 'allow' ? 'Permitido' : 'Denegado';
+  } else if (kind === 'proj') {
+    if (a === 'root') {
+      await selectProject(T, chatId, projectRoot(T));
+      toast = 'Proyecto elegido';
+    } else {
+      const choice = (T.projectChoices.get(chatId) ?? [])[Number(a)];
+      if (choice) {
+        await selectProject(T, chatId, choice.path);
+        toast = `Proyecto ${choice.name}`;
+      } else {
+        toast = 'Elegí de nuevo';
+      }
+    }
+  } else if (kind === 'mode') {
+    T.ctx.store.setSetting('activeMode', resolveMode(a).id);
+    toast = `Modo ${resolveMode(a).label}`;
+  } else if (kind === 'provider') {
+    T.ctx.store.setSetting('activeProvider', a);
+    const sid = activeSessionId(T, chatId);
+    if (sid) T.ctx.store.touchSession(sid, { provider: a });
+    toast = `Proveedor ${a}`;
+  } else if (kind === 'model') {
+    const id = (T.modelChoices.get(chatId) ?? [])[Number(a)];
+    if (id) {
+      T.ctx.store.setSetting('activeModel', id);
+      const sid = activeSessionId(T, chatId);
+      if (sid) T.ctx.store.touchSession(sid, { model: id });
+      toast = `Modelo ${id}`;
+    }
+  } else if (kind === 'menu') {
+    if (a === 'models') await sendModels(T, chatId);
+    else if (a === 'providers') await sendProviders(T, chatId);
+    else if (a === 'home') await sendMenu(T, chatId);
+    else if (a === 'project') await sendProjectPicker(T, chatId, { text: 'Elegí el proyecto:' });
+    else if (a === 'new') {
+      T.ctx.store.setSetting(T.sessionKey(chatId), null);
+      T.pendingInputs.delete(String(chatId));
+      await sendProjectPicker(T, chatId, { text: 'Nueva sesión. ¿En qué proyecto vas a trabajar?' });
+    } else if (a === 'stop') {
+      T.controllers.get(chatId)?.abort();
+      await send(T, chatId, 'Cancelando.');
+    }
+    toast = 'ok';
+  }
+
+  await tg(T.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(T.token, 'editMessageReplyMarkup', {
+      chat_id: query.message.chat.id,
+      message_id: query.message.message_id,
+    }).catch(() => null);
+  }
+}
+
+export { HELP };

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

@@ -0,0 +1,64 @@
+// Entrega de multimedia a un chat: fotos (capturas del tool `screenshot`) y
+// notas de voz (TTS). Un fallo del servicio no debe romper el run.
+
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { sintetizar, MAX_TEXTO, screenshotsDir } from '../../core.js';
+import { mp3AOgg } from '../../ffmpeg.js';
+import { resolveTts } from '../../ttsSettings.js';
+import { tgForm } from './api.js';
+
+/**
+ * Nota de voz con un texto cualquiera. Con ffmpeg manda OGG/Opus
+ * (`sendVoice`, aparece como nota de voz); sin ffmpeg cae a audio MP3.
+ */
+export async function enviarNotaDeVoz(T, chatId, texto, { voice, rate, pitch } = {}) {
+  const tts = resolveTts(T.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,
+      pitch: pitch || tts.pitch,
+    });
+    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(T.token, 'sendVoice', form);
+    } else {
+      form.append('audio', new Blob([mp3], { type: 'audio/mpeg' }), 'resumen.mp3');
+      await tgForm(T.token, 'sendAudio', form);
+    }
+  } catch (error) {
+    T.log(`telegram: nota de voz falló: ${error?.message ?? error}`);
+  }
+}
+
+/** Manda una imagen (una captura del tool `screenshot`). */
+export async function enviarFoto(T, chatId, buffer, caption) {
+  try {
+    const form = new FormData();
+    form.append('chat_id', chatId);
+    if (caption) form.append('caption', String(caption).slice(0, 1000));
+    form.append('photo', new Blob([buffer], { type: 'image/png' }), 'captura.png');
+    await tgForm(T.token, 'sendPhoto', form);
+  } catch (error) {
+    T.log(`telegram: foto falló: ${error?.message ?? error}`);
+  }
+}
+
+/** Entrega una captura guardada en la casa (por nombre, sin path traversal). */
+export async function enviarCaptura(T, chatId, name, caption) {
+  const safe = String(name ?? '');
+  if (!/^[a-z0-9][a-z0-9-]*\.png$/i.test(safe)) return;
+  let buffer;
+  try {
+    buffer = await readFile(path.join(screenshotsDir(), safe));
+  } catch {
+    return;
+  }
+  await enviarFoto(T, chatId, buffer, caption);
+}

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

@@ -0,0 +1,102 @@
+// Elegir proyecto: un chat de Telegram arranca eligiendo en qué carpeta de la
+// raíz trabajar, y cada proyecto tiene su propia sesión del harness.
+
+import path from 'node:path';
+import { resolveExistingDir, listSubdirs } from '../../workspace.js';
+import { send } from './api.js';
+
+export const MAX_PROJECTS = 24;
+
+/** Carpeta raíz para elegir proyecto: la predeterminada de la consola o el cwd. */
+export function projectRoot(T) {
+  const stored = T.ctx.store.getSetting('defaultCwd');
+  const candidate = stored || T.root || T.ctx.cwd;
+  try {
+    return resolveExistingDir(candidate);
+  } catch {
+    return T.ctx.cwd;
+  }
+}
+
+export function listProjects(T) {
+  try {
+    return listSubdirs(projectRoot(T)).map((dir) => ({ name: dir.name, path: dir.path }));
+  } catch {
+    return [];
+  }
+}
+
+export function projectLabel(session) {
+  const cwd = session?.cwd || '';
+  return cwd ? path.basename(cwd) : 'sin carpeta';
+}
+
+/** Un proyecto está habilitado si alguna pestaña abierta de la consola lo usa. */
+export function projectIsOpen(T, session) {
+  const ids = T.ctx.presence?.ids?.() ?? [];
+  if (!ids.length) return false;
+  const cwd = session?.cwd || '';
+  return ids.some((id) => {
+    const open = T.ctx.store.getSession(id);
+    return open && (open.cwd || '') === cwd;
+  });
+}
+
+export function activeSessionId(T, chatId) {
+  const id = T.ctx.store.getSetting(T.sessionKey(chatId));
+  if (id && T.ctx.store.getSession(id)) return id;
+  return null;
+}
+
+export function createSessionForProject(T, chatId, cwd) {
+  const sessionId = T.ctx.store.createSession({
+    title: path.basename(cwd) || `Telegram ${chatId}`,
+    provider: T.ctx.effectiveProviderId(),
+    model: T.ctx.effectiveModel(),
+    cwd,
+    meta: { telegramChatId: String(chatId) },
+  });
+  T.ctx.store.setSetting(T.sessionKey(chatId), sessionId);
+  T.ctx.store.setSetting(T.reverseKey(sessionId), String(chatId));
+  return sessionId;
+}
+
+export function resolveProjectArg(T, arg) {
+  const value = String(arg ?? '').trim();
+  if (!value) return null;
+  if (/[\\/]/.test(value) || /^[a-zA-Z]:/.test(value)) return value;
+  const projects = listProjects(T);
+  const exact = projects.find((p) => p.name.toLowerCase() === value.toLowerCase());
+  if (exact) return exact.path;
+  const matches = projects.filter((p) => p.name.toLowerCase().includes(value.toLowerCase()));
+  return matches.length === 1 ? matches[0].path : null;
+}
+
+export async function sendProjectPicker(T, chatId, { text } = {}) {
+  const base = projectRoot(T);
+  const all = listProjects(T);
+  const shown = all.slice(0, MAX_PROJECTS);
+  T.projectChoices.set(String(chatId), shown);
+  const rows = shown.map((project, index) => [{ text: project.name, callback_data: `proj:${index}` }]);
+  rows.push([{ text: `?? usar «${path.basename(base)}»`, callback_data: 'proj:root' }]);
+  const intro = text || '¿En qué proyecto vas a trabajar?';
+  await send(T, chatId, `${intro}\n\nraíz: ${base}`, { reply_markup: { inline_keyboard: rows } });
+  if (all.length > shown.length) {
+    await send(T, chatId, `Hay ${all.length} proyectos; mostré ${shown.length}. Para otro, usá /proyecto <nombre>.`);
+  }
+}
+
+export async function selectProject(T, chatId, projectPath) {
+  let cwd;
+  try {
+    cwd = resolveExistingDir(projectPath);
+  } catch (error) {
+    return send(T, chatId, `No pude usar ese proyecto: ${error.message}`);
+  }
+  createSessionForProject(T, chatId, cwd);
+  const key = String(chatId);
+  const pending = T.pendingInputs.get(key);
+  T.pendingInputs.delete(key);
+  await send(T, chatId, `Proyecto «${path.basename(cwd)}».${pending ? '' : ' Mandá tu mensaje.'}`);
+  if (pending) T.run(T, chatId, pending.input, pending.images).catch((error) => T.log(`telegram: ${error?.message ?? error}`));
+}

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

@@ -0,0 +1,206 @@
+// El turno del agente en Telegram: armar las tools, correr el run y editar el
+// mensaje con el progreso. También el resumen de la conversación.
+
+import { randomUUID } from 'node:crypto';
+import { runAgent, createTools, resolveMode } from '../../core.js';
+import { resolveExistingDir } from '../../workspace.js';
+import {
+  combineToolset,
+  composeAgentMessages,
+  buildUserMessage,
+  resolveProviderFor,
+  toolCallPayload,
+} from '../../agentRun.js';
+import { createRulesInjector } from '../../rules.js';
+import { edit, send, tg } from './api.js';
+import { completionFooter } from './text.js';
+import { permissionMessage, permissionKeyboard } from './permissions.js';
+import { enviarCaptura, enviarNotaDeVoz } from './media.js';
+import { activeSessionId, projectLabel, sendProjectPicker } from './projects.js';
+
+const RESUME_INSTRUCTION =
+  'Resumí la conversación para la persona: qué se pidió, qué se hizo, decisiones tomadas, archivos o comandos relevantes y el estado actual. Sé claro y conciso, en español, sin markdown pesado.';
+
+/** Resumen de la conversación de una sesión (sin tocar el historial). */
+export async function resumirSesion(T, sessionId) {
+  const messages = T.ctx.store.getMessages(sessionId);
+  if (!messages.length) throw new Error('La conversación está vacía.');
+  const session = T.ctx.store.getSession(sessionId);
+  const providerId = session?.provider || T.ctx.effectiveProviderId();
+  const model = session?.model || T.ctx.effectiveModel();
+  if (!model) throw new Error('Falta el modelo.');
+  const transcript = messages
+    .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+    .join('\n');
+  const { provider, config } = resolveProviderFor(T.ctx, providerId);
+  const result = await runAgent({
+    provider,
+    config,
+    model,
+    messages: [
+      { role: 'system', content: RESUME_INSTRUCTION },
+      { role: 'user', content: transcript.slice(0, 60000) },
+    ],
+    tools: [],
+  });
+  const summary = result.content?.trim();
+  if (!summary) throw new Error('El modelo no devolvió un resumen.');
+  return { summary };
+}
+
+export async function run(T, chatId, input, images = []) {
+  const sessionId = activeSessionId(T, chatId);
+  if (!sessionId) {
+    T.pendingInputs.set(String(chatId), { input, images });
+    return sendProjectPicker(T, chatId);
+  }
+  const session = T.ctx.store.getSession(sessionId);
+  const providerId = session.provider || T.ctx.effectiveProviderId();
+  const model = session.model || T.ctx.effectiveModel();
+  if (!model) {
+    await send(T, chatId, 'Falta el modelo. Usá /model <id> o configurá uno en Ajustes.');
+    return;
+  }
+  const mode = resolveMode(T.ctx.effectiveMode());
+  const cwd = resolveExistingDir(session.cwd || T.ctx.cwd);
+  const history = T.ctx.store.getMessages(sessionId);
+
+  let mcp = null;
+  try {
+    mcp = await T.ctx.getMcp();
+  } catch {
+    mcp = null;
+  }
+
+  const onAsk = async (name, args) => {
+    // "Permitir todo" activa el auto-approve de la sesión (compartido con la
+    // consola): a partir de ahí no se vuelve a preguntar.
+    if (T.ctx.isAutoApprove?.(sessionId)) return true;
+    const askId = randomUUID();
+    T.askSessions.set(askId, sessionId);
+    await send(T, chatId, permissionMessage(projectLabel(session), name, args), {
+      reply_markup: permissionKeyboard(askId),
+    });
+    return T.ctx.approvals.ask(askId, { sessionId, name, args });
+  };
+
+  const local = createTools({
+    root: cwd,
+    enabled: mode.tools ?? undefined,
+    permissions: T.ctx.config.permissions,
+    yes: false,
+    onAsk,
+    mcp,
+    mcpMode: T.ctx.effectiveMcpMode(),
+    mcpPinned: T.ctx.effectiveMcpPinned(),
+  });
+  const exposeAdmin = !mode.tools;
+  const admin = T.ctx.agentTools;
+  const { definitions, execute } = combineToolset({
+    local,
+    admin,
+    plugins: exposeAdmin ? T.ctx.plugins : null,
+    exposeAdmin,
+    approve: onAsk,
+  });
+  const { provider, config } = resolveProviderFor(T.ctx, providerId);
+  const userMessage = buildUserMessage(input, images);
+  const messages = await composeAgentMessages({ ctx: T.ctx, cwd, mode, history, userMessage });
+
+  const controller = new AbortController();
+  T.controllers.set(String(chatId), controller);
+  T.ownSessions.add(sessionId);
+  const startedAt = Date.now();
+  const message = await send(T, chatId, '.');
+  let full = '';
+  let activity = '';
+  let lastEdit = 0;
+
+  const render = () => {
+    const body = full.trim();
+    const suffix = activity ? `\n\n- ${activity}` : '';
+    return `${body || '.'}${suffix}`;
+  };
+
+  try {
+    await tg(T.token, 'sendChatAction', { chat_id: chatId, action: 'typing' }).catch(() => null);
+    const result = await runAgent({
+      provider,
+      config,
+      model,
+      messages,
+      tools: definitions,
+      execute,
+      toolContext: { cwd, sessionId },
+      onLifecycle: createRulesInjector({ cwd, patterns: T.ctx.config.rules ?? [] }) ?? undefined,
+      redactExtra: T.ctx.secretExtra?.() ?? [],
+      signal: controller.signal,
+      maxRounds: T.ctx.effectiveMaxRounds?.() ?? T.ctx.config.maxRounds,
+      maxTokens: T.ctx.effectiveMaxTokens?.() ?? 0,
+      maxDurationMs: T.ctx.effectiveMaxDurationMs?.() ?? 0,
+      maxOutputTokens: T.ctx.effectiveMaxOutputTokens?.() ?? T.ctx.config.maxOutputTokens ?? 0,
+      promptCaching: T.ctx.effectivePromptCaching?.() ?? T.ctx.config.promptCaching === true,
+      onEvent(event) {
+        if (event.type === 'text') {
+          full = event.full;
+        } else if (event.type === 'tool_call') {
+          activity = `${event.name} ${toolCallPayload(event).summary}`.trim();
+          if (event.name === 'speak') {
+            enviarNotaDeVoz(T, chatId, event.args?.texto, {
+              voice: event.args?.voice,
+              rate: event.args?.rate,
+              pitch: event.args?.pitch,
+            });
+          }
+        } else if (event.type === 'tool_result') {
+          activity = `${event.name} V`;
+          if (event.name === 'screenshot' && event.meta?.screenshot?.name) {
+            enviarCaptura(T, chatId, event.meta.screenshot.name, event.meta.screenshot.url);
+          }
+        } else {
+          return;
+        }
+        const now = Date.now();
+        if (now - lastEdit > 1200) {
+          lastEdit = now;
+          edit(T, chatId, message.message_id, render());
+        }
+      },
+    });
+    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 === 'no_progress') {
+        body = '✓ El agente se quedó repitiendo las mismas herramientas sin avanzar.';
+      } else if (result.stopReason === 'budget') {
+        body = '✓ El agente alcanzó el presupuesto de tokens/tiempo sin respuesta final.';
+      } else if (result.stopReason === 'max_rounds') {
+        body = `✓ El agente alcanzó el máximo de rondas (${result.rounds}) sin respuesta final.${
+          toolCalls ? ` Hizo ${toolCalls} herramientas.` : ''
+        }`;
+      } else if (toolCalls) {
+        body = 'V 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(T, chatId, message.message_id, `${body}\n\n- ${footer}`);
+    T.ctx.store.addMessages(sessionId, newMessages);
+    T.ctx.store.touchSession(sessionId, { provider: providerId, model });
+  } catch (error) {
+    await edit(
+      T,
+      chatId,
+      message.message_id,
+      error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`,
+    );
+  } finally {
+    T.controllers.delete(String(chatId));
+    T.ownSessions.delete(sessionId);
+    mcp?.close?.();
+  }
+}
+