@danieltmn/tamnora 0.9.1 → 0.9.3

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

@@ -1,10 +1,12 @@
 // Canal de Telegram: long polling (no necesita URL publica) con soporte de
 // texto, imagenes, notas de voz (transcripcion) y aprobaciones por botones
-// inline. Cada chat mapea a una sesion del harness.
+// inline. Cada chat mapea a una sesion del harness, que ahora empieza eligiendo
+// proyecto (una carpeta de la raiz configurada en la consola).
 
+import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { runAgent, createTools, resolveMode, listProviderModels, PROVIDER_META, sintetizar, MAX_TEXTO } from '../core.js';
-import { resolveExistingDir } from '../workspace.js';
+import { resolveExistingDir, listSubdirs } from '../workspace.js';
 import {
   combineToolset,
   composeAgentMessages,
@@ -12,18 +14,25 @@ import {
   resolveProviderFor,
   toolCallPayload,
 } from '../agentRun.js';
-import { fraseFin } from '../announcer.js';
 import { mp3AOgg } from '../ffmpeg.js';
 import { resolveTts } from '../ttsSettings.js';
+import { transcribeAudio } from '../transcribe.js';
 
 const API = 'https://api.telegram.org';
+const MAX_PROJECTS = 24;
+
+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.';
 
 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)',
-  '/new — nueva sesión',
-  '/status — proveedor, modelo, modo y sesión',
+  '/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)',
@@ -111,13 +120,30 @@ export function completionFooter(stopReason, rounds, toolCalls, durationMs) {
  */
 export function startTelegramChannel(
   ctx,
-  { token, allowedChatIds = [], transcribeModel = 'whisper-1', transcribeProvider = '', log = () => {} } = {}
+  {
+    token,
+    allowedChatIds = [],
+    transcribeModel = 'whisper-1',
+    transcribeProvider = '',
+    notify = {},
+    root = '',
+    log = () => {},
+  } = {}
 ) {
   if (!token) return null;
   const allowed = new Set(allowedChatIds.map(String));
+  const notifyConfig = {
+    enabled: notify?.enabled === true,
+    done: notify?.done !== false,
+    error: notify?.error !== false,
+    permission: notify?.permission !== false,
+    agent: notify?.agent !== false,
+  };
   const controllers = new Map();
   const ownSessions = new Set();
   const modelChoices = new Map();
+  const projectChoices = new Map();
+  const pendingInputs = new Map();
   let running = true;
   let offset = 0;
 
@@ -168,59 +194,144 @@ export function startTelegramChannel(
     }
   }
 
-  /** 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);
+  // --- proyectos ------------------------------------------------------------
+
+  /** Carpeta raíz para elegir proyecto: la predeterminada de la consola o el cwd. */
+  function projectRoot() {
+    const stored = ctx.store.getSetting('defaultCwd');
+    const candidate = stored || root || ctx.cwd;
+    try {
+      return resolveExistingDir(candidate);
+    } catch {
+      return ctx.cwd;
+    }
   }
 
-  function ensureSession(chatId) {
-    const key = sessionKey(chatId);
-    let sessionId = ctx.store.getSetting(key);
-    if (!sessionId || !ctx.store.getSession(sessionId)) {
-      sessionId = ctx.store.createSession({
-        title: `Telegram ${chatId}`,
-        provider: ctx.effectiveProviderId(),
-        model: ctx.effectiveModel(),
-        cwd: ctx.cwd,
-        meta: { telegramChatId: String(chatId) },
-      });
-      ctx.store.setSetting(key, sessionId);
+  function listProjects() {
+    try {
+      return listSubdirs(projectRoot()).map((dir) => ({ name: dir.name, path: dir.path }));
+    } catch {
+      return [];
     }
+  }
+
+  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. */
+  function projectIsOpen(session) {
+    const ids = ctx.presence?.ids?.() ?? [];
+    if (!ids.length) return false;
+    const cwd = session?.cwd || '';
+    return ids.some((id) => {
+      const open = ctx.store.getSession(id);
+      return open && (open.cwd || '') === cwd;
+    });
+  }
+
+  function activeSessionId(chatId) {
+    const id = ctx.store.getSetting(sessionKey(chatId));
+    if (id && ctx.store.getSession(id)) return id;
+    return null;
+  }
+
+  function createSessionForProject(chatId, cwd) {
+    const sessionId = ctx.store.createSession({
+      title: path.basename(cwd) || `Telegram ${chatId}`,
+      provider: ctx.effectiveProviderId(),
+      model: ctx.effectiveModel(),
+      cwd,
+      meta: { telegramChatId: String(chatId) },
+    });
+    ctx.store.setSetting(sessionKey(chatId), sessionId);
     ctx.store.setSetting(reverseKey(sessionId), String(chatId));
     return sessionId;
   }
 
-  async function transcribe(buffer, filename) {
-    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 "${providerId}" no tiene baseUrl para transcribir`);
-    const form = new FormData();
-    form.append('file', new Blob([buffer]), filename);
-    form.append('model', transcribeModel);
-    const res = await fetch(`${baseUrl}/audio/transcriptions`, {
-      method: 'POST',
-      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
-      body: form,
-    });
-    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.`
-      );
+  function resolveProjectArg(arg) {
+    const value = String(arg ?? '').trim();
+    if (!value) return null;
+    if (/[\\/]/.test(value) || /^[a-zA-Z]:/.test(value)) return value;
+    const projects = listProjects();
+    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;
+  }
+
+  async function sendProjectPicker(chatId, { text } = {}) {
+    const base = projectRoot();
+    const all = listProjects();
+    const shown = all.slice(0, MAX_PROJECTS);
+    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(chatId, `${intro}\n\nraíz: ${base}`, { reply_markup: { inline_keyboard: rows } });
+    if (all.length > shown.length) {
+      await send(chatId, `Hay ${all.length} proyectos; mostré ${shown.length}. Para otro, usá /proyecto <nombre>.`);
     }
-    const data = await res.json();
-    return String(data.text ?? '').trim();
+  }
+
+  async function selectProject(chatId, projectPath) {
+    let cwd;
+    try {
+      cwd = resolveExistingDir(projectPath);
+    } catch (error) {
+      return send(chatId, `No pude usar ese proyecto: ${error.message}`);
+    }
+    createSessionForProject(chatId, cwd);
+    const key = String(chatId);
+    const pending = pendingInputs.get(key);
+    pendingInputs.delete(key);
+    await send(chatId, `Proyecto «${path.basename(cwd)}».${pending ? '' : ' Mandá tu mensaje.'}`);
+    if (pending) run(chatId, pending.input, pending.images).catch((error) => log(`telegram: ${error?.message ?? error}`));
+  }
+
+  function transcribe(buffer, filename) {
+    return transcribeAudio(ctx, {
+      buffer,
+      filename,
+      providerId: transcribeProvider || undefined,
+      model: transcribeModel,
+    });
+  }
+
+  /** Resumen de la conversación de una sesión (sin tocar el historial). */
+  async function resumirSesion(sessionId) {
+    const messages = ctx.store.getMessages(sessionId);
+    if (!messages.length) throw new Error('La conversación está vacía.');
+    const session = ctx.store.getSession(sessionId);
+    const providerId = session?.provider || ctx.effectiveProviderId();
+    const model = session?.model || 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(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 };
   }
 
   async function run(chatId, input, images = []) {
-    const sessionId = ensureSession(chatId);
+    const sessionId = activeSessionId(chatId);
+    if (!sessionId) {
+      pendingInputs.set(String(chatId), { input, images });
+      return sendProjectPicker(chatId);
+    }
     const session = ctx.store.getSession(sessionId);
     const providerId = session.provider || ctx.effectiveProviderId();
     const model = session.model || ctx.effectiveModel();
@@ -242,7 +353,7 @@ export function startTelegramChannel(
     const onAsk = async (name, args) => {
       const askId = randomUUID();
       const preview = JSON.stringify(args ?? {}).slice(0, 300);
-      await send(chatId, `⚠ Permiso para ${name}\n${preview}`, {
+      await send(chatId, `⚠ [${projectLabel(session)}] Permiso para ${name}\n${preview}`, {
         reply_markup: {
           inline_keyboard: [
             [
@@ -339,7 +450,6 @@ 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) {
@@ -352,12 +462,18 @@ export function startTelegramChannel(
   }
 
   async function sendMenu(chatId) {
-    const sessionId = ensureSession(chatId);
-    const session = ctx.store.getSession(sessionId);
+    const sessionId = activeSessionId(chatId);
+    const session = sessionId ? ctx.store.getSession(sessionId) : null;
     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');
+    const text = [
+      '⚙ Panel',
+      `proyecto: ${session ? projectLabel(session) : '(elegí con /proyecto)'}`,
+      `proveedor: ${providerId}`,
+      `modelo: ${model}`,
+      `modo: ${mode.label}`,
+    ].join('\n');
     await send(chatId, text, {
       reply_markup: {
         inline_keyboard: [
@@ -370,23 +486,25 @@ export function startTelegramChannel(
             { text: 'proveedores', callback_data: 'menu:providers' },
           ],
           [
+            { text: '📁 proyecto', callback_data: 'menu:project' },
             { text: '🆕 nueva', callback_data: 'menu:new' },
-            { text: '⏹ detener', callback_data: 'menu:stop' },
           ],
+          [{ text: '⏹ detener', callback_data: 'menu:stop' }],
         ],
       },
     });
   }
 
   async function sendModels(chatId) {
-    const sessionId = ensureSession(chatId);
-    const providerId = ctx.store.getSession(sessionId)?.provider || ctx.effectiveProviderId();
+    const sessionId = activeSessionId(chatId);
+    const session = sessionId ? ctx.store.getSession(sessionId) : null;
+    const providerId = session?.provider || ctx.effectiveProviderId();
     const models = await listProviderModels({
       ...ctx.providerSettings(providerId),
       apiKey: ctx.apiKeyFor(providerId),
     }).catch(() => []);
 
-    const current = ctx.store.getSession(sessionId)?.model || ctx.effectiveModel();
+    const current = session?.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));
@@ -413,20 +531,49 @@ export function startTelegramChannel(
     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);
+    const sessionId = activeSessionId(chatId);
+    if (cmd === 'start') {
+      if (sessionId) {
+        return send(chatId, `Hola. Proyecto actual: «${projectLabel(ctx.store.getSession(sessionId))}».\n\n${HELP}`);
+      }
+      return sendProjectPicker(chatId, { text: 'Hola. ¿En qué proyecto vas a trabajar?' });
+    }
+    if (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.');
+      pendingInputs.delete(String(chatId));
+      return sendProjectPicker(chatId, { text: 'Nueva sesión. ¿En qué proyecto vas a trabajar?' });
+    }
+    if (cmd === 'proyecto' || cmd === 'proyectos' || cmd === 'project') {
+      if (!arg) return sendProjectPicker(chatId);
+      const projectPath = resolveProjectArg(arg);
+      if (!projectPath) {
+        return send(chatId, `No encontré el proyecto "${arg}". Usá /proyecto sin argumento para ver la lista.`);
+      }
+      return selectProject(chatId, projectPath);
     }
     if (cmd === 'status') {
       const session = sessionId ? ctx.store.getSession(sessionId) : null;
       return send(
         chatId,
-        `proveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
+        `proyecto: ${session ? projectLabel(session) : '—'}\nproveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
       );
     }
+    if (cmd === 'resumen' || cmd === 'resume') {
+      if (!sessionId) return send(chatId, 'No hay una conversación todavía. Elegí un proyecto con /proyecto.');
+      const data = await resumirSesion(sessionId).catch((error) => ({ error: error.message }));
+      if (data.error) return send(chatId, `No pude resumir: ${data.error}`);
+      return send(chatId, `📝 Resumen\n\n${data.summary}`);
+    }
+    if (cmd === 'audioresumen' || cmd === 'audio-resumen') {
+      if (!sessionId) return send(chatId, 'No hay una conversación todavía. Elegí un proyecto con /proyecto.');
+      await send(chatId, '🎧 Preparando el resumen…');
+      const data = await resumirSesion(sessionId).catch((error) => ({ error: error.message }));
+      if (data.error) return send(chatId, `No pude resumir: ${data.error}`);
+      await send(chatId, `📝 Resumen\n\n${data.summary}`);
+      return enviarNotaDeVoz(chatId, data.summary);
+    }
     if (cmd === 'model' || cmd === 'modelo') {
       if (!arg) return sendModels(chatId);
       ctx.store.setSetting('activeModel', arg);
@@ -459,12 +606,21 @@ export function startTelegramChannel(
       const text = await transcribe(buffer, voice.file_name || 'audio.ogg');
       if (!text) return send(chatId, 'No pude transcribir el audio.');
       await send(chatId, `📝 ${text}`);
-      return run(chatId, text);
+      return deliver(chatId, text);
     } catch (error) {
       return send(chatId, `No pude procesar el audio: ${error.message}`);
     }
   }
 
+  /** Entrega un mensaje: si no hay proyecto elegido, primero pregunta cuál. */
+  async function deliver(chatId, input, images = []) {
+    if (!activeSessionId(chatId)) {
+      pendingInputs.set(String(chatId), { input, images });
+      return sendProjectPicker(chatId);
+    }
+    return run(chatId, input, images);
+  }
+
   async function handleMessage(message) {
     const chatId = String(message.chat.id);
     if (!authorized(chatId)) {
@@ -485,13 +641,13 @@ export function startTelegramChannel(
         const largest = message.photo[message.photo.length - 1];
         const buffer = await downloadFile(token, largest.file_id);
         const dataUrl = `data:image/jpeg;base64,${buffer.toString('base64')}`;
-        await run(chatId, text || '(imagen)', [dataUrl]);
+        await deliver(chatId, text || '(imagen)', [dataUrl]);
       } catch (error) {
         await send(chatId, `No pude procesar la imagen: ${error.message}`);
       }
       return;
     }
-    if (text) await run(chatId, text);
+    if (text) await deliver(chatId, text);
   }
 
   async function handleCallback(query) {
@@ -502,19 +658,32 @@ export function startTelegramChannel(
     if (kind === 'perm') {
       ctx.approvals.decide(a, b === 'allow');
       toast = b === 'allow' ? 'Permitido' : 'Denegado';
+    } else if (kind === 'proj') {
+      if (a === 'root') {
+        await selectProject(chatId, projectRoot());
+        toast = 'Proyecto elegido';
+      } else {
+        const choice = (projectChoices.get(chatId) ?? [])[Number(a)];
+        if (choice) {
+          await selectProject(chatId, choice.path);
+          toast = `Proyecto ${choice.name}`;
+        } else {
+          toast = 'Elegí de nuevo';
+        }
+      }
     } 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));
+      const sid = activeSessionId(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));
+        const sid = activeSessionId(chatId);
         if (sid) ctx.store.touchSession(sid, { model: id });
         toast = `Modelo ${id}`;
       }
@@ -522,9 +691,11 @@ export function startTelegramChannel(
       if (a === 'models') await sendModels(chatId);
       else if (a === 'providers') await sendProviders(chatId);
       else if (a === 'home') await sendMenu(chatId);
+      else if (a === 'project') await sendProjectPicker(chatId, { text: 'Elegí el proyecto:' });
       else if (a === 'new') {
         ctx.store.setSetting(sessionKey(chatId), null);
-        await send(chatId, 'Nueva sesión. Mandá tu mensaje.');
+        pendingInputs.delete(String(chatId));
+        await sendProjectPicker(chatId, { text: 'Nueva sesión. ¿En qué proyecto vas a trabajar?' });
       } else if (a === 'stop') {
         controllers.get(chatId)?.abort();
         await send(chatId, 'Cancelando…');
@@ -563,6 +734,16 @@ export function startTelegramChannel(
 
   loop().catch((error) => log(`telegram: ${error?.message ?? error}`));
 
+  /** Chats que deben recibir un aviso de una sesión (vínculo explícito o proyecto abierto). */
+  function notifyTargets(sessionId) {
+    const explicit = ctx.store.getSetting(reverseKey(sessionId));
+    if (explicit) return [String(explicit)];
+    if (!notifyConfig.enabled) return [];
+    const session = ctx.store.getSession(sessionId);
+    if (!session || !projectIsOpen(session)) return [];
+    return [...allowed];
+  }
+
   return {
     id: 'telegram',
     stop() {
@@ -570,45 +751,52 @@ export function startTelegramChannel(
       for (const controller of controllers.values()) controller.abort();
       controllers.clear();
     },
-    /** Avisa a un chat vinculado sobre un run de otra interfaz (p.ej. la consola). */
+    /** Avisa sobre un run de otra interfaz (la consola), siempre con el proyecto. */
     notify(sessionId, event) {
       if (ownSessions.has(sessionId)) return;
-      const chatId = ctx.store.getSetting(reverseKey(sessionId));
-      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') {
+
+      // La tool `speak` entrega audio en vivo a un chat vinculado.
+      if (event.type === 'tool_call') {
+        if (event.data?.name !== 'speak') return;
+        const linked = ctx.store.getSetting(reverseKey(sessionId));
+        if (linked) {
+          enviarNotaDeVoz(linked, event.data?.args?.texto, {
+            voice: event.data?.args?.voice,
+            rate: event.data?.args?.rate,
+          });
+        }
+        return;
+      }
+
+      const targets = notifyTargets(sessionId);
+      if (!targets.length) return;
+      const session = ctx.store.getSession(sessionId);
+      const project = projectLabel(session);
+
+      if (event.type === 'done' && notifyConfig.done) {
+        const text = `[${project}] ✅ Sesión terminada.\n\n${String(event.data?.content ?? '').slice(0, 3500)}`;
+        for (const chatId of targets) send(chatId, text).catch(() => {});
+      } else if (event.type === 'error' && notifyConfig.error) {
+        const text = `[${project}] ✗ Error en la sesión: ${event.data?.message ?? ''}`;
+        for (const chatId of targets) send(chatId, text).catch(() => {});
+      } else if (event.type === 'agent_end' && notifyConfig.agent) {
+        const text = `[${project}] 🤖 Subagente ${event.data?.status}: ${String(event.data?.content ?? '').slice(0, 1500)}`;
+        for (const chatId of targets) send(chatId, text).catch(() => {});
+      } else if (event.type === 'permission' && notifyConfig.permission) {
         const askId = event.data?.askId;
         if (!askId) return;
-        send(chatId, `⚠ Permiso para ${event.data?.name ?? 'una tool'} (desde la consola)`, {
-          reply_markup: {
-            inline_keyboard: [
-              [
-                { text: 'Permitir', callback_data: `perm:${askId}:allow` },
-                { text: 'Denegar', callback_data: `perm:${askId}:deny` },
+        for (const chatId of targets) {
+          send(chatId, `[${project}] ⚠ Permiso para ${event.data?.name ?? 'una tool'}`, {
+            reply_markup: {
+              inline_keyboard: [
+                [
+                  { text: 'Permitir', callback_data: `perm:${askId}:allow` },
+                  { text: 'Denegar', callback_data: `perm:${askId}:deny` },
+                ],
               ],
-            ],
-          },
-        }).catch(() => {});
+            },
+          }).catch(() => {});
+        }
       }
     },
   };

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

@@ -0,0 +1,51 @@
+// Presencia de pestañas abiertas en la consola. El cliente reporta qué sesiones
+// (pestañas) tiene abiertas; el canal de Telegram la usa para saber qué
+// proyectos están "habilitados" para avisar (los abiertos en el chat).
+//
+// Es efímera a propósito: si la consola se cierra no hay un "adiós", así que
+// cada entrada vence por TTL y el cliente la refresca con un latido.
+
+const DEFAULT_TTL_MS = 90000;
+
+/** Tracker en memoria: sessionId -> último latido. */
+export function createPresence({ ttlMs = DEFAULT_TTL_MS, now = Date.now } = {}) {
+  const seen = new Map();
+
+  const alive = (ts) => now() - ts <= ttlMs;
+
+  return {
+    /** Marca como abiertas (vistas recién) esas sesiones. */
+    touch(ids = []) {
+      const ts = now();
+      for (const id of ids) if (id) seen.set(String(id), ts);
+      return this;
+    },
+    /** Marca como cerradas (quita la sesión sin esperar el TTL). */
+    close(ids = []) {
+      for (const id of ids) seen.delete(String(id));
+      return this;
+    },
+    has(sessionId) {
+      const id = String(sessionId ?? '');
+      const ts = seen.get(id);
+      if (ts === undefined) return false;
+      if (!alive(ts)) {
+        seen.delete(id);
+        return false;
+      }
+      return true;
+    },
+    /** Ids vivos (purga los vencidos de paso). */
+    ids() {
+      const out = [];
+      for (const [id, ts] of seen) {
+        if (alive(ts)) out.push(id);
+        else seen.delete(id);
+      }
+      return out;
+    },
+    clear() {
+      seen.clear();
+    },
+  };
+}