@danieltmn/tamnora 0.9.2 → 0.9.4

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

@@ -4,8 +4,18 @@
 // proyecto (una carpeta de la raiz configurada en la consola).
 
 import path from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
-import { runAgent, createTools, resolveMode, listProviderModels, PROVIDER_META, sintetizar, MAX_TEXTO } from '../core.js';
+import {
+  runAgent,
+  createTools,
+  resolveMode,
+  listProviderModels,
+  PROVIDER_META,
+  sintetizar,
+  MAX_TEXTO,
+  screenshotsDir,
+} from '../core.js';
 import { resolveExistingDir, listSubdirs } from '../workspace.js';
 import {
   combineToolset,
@@ -14,7 +24,6 @@ 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';
@@ -43,6 +52,72 @@ const HELP = [
   'Podés mandar texto, imágenes o notas de voz.',
 ].join('\n');
 
+function humanSize(bytes) {
+  const n = Number(bytes) || 0;
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function oneLine(value, max = 400) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+}
+
+/**
+ * Explica en una frase qué va a hacer el agente si se aprueba el permiso, en
+ * vez de volcar el JSON crudo (que para `write` mostraba medio archivo).
+ */
+export function describePermission(name, args = {}) {
+  const a = args && typeof args === 'object' ? args : {};
+  switch (name) {
+    case 'bash':
+      return { action: 'ejecutar un comando en el proyecto', detail: oneLine(a.command, 700) };
+    case 'write':
+      return {
+        action: `escribir el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.content ? `Contenido: ${humanSize(Buffer.byteLength(String(a.content)))}` : '',
+      };
+    case 'edit':
+      return {
+        action: `editar el archivo ${a.path ?? '(sin ruta)'}`,
+        detail: a.oldString ? `Reemplaza: "${oneLine(a.oldString, 100)}"` : '',
+      };
+    case 'git_commit':
+      return { action: 'hacer un commit', detail: oneLine(a.message, 200) };
+    case 'screenshot':
+      return { action: 'sacar una captura de la página', detail: oneLine(a.url, 200) };
+    case 'console_errors':
+      return { action: 'revisar la consola de una página', detail: oneLine(a.url, 200) };
+    case 'fetch_url':
+      return { action: 'consultar una URL', detail: oneLine(a.url, 200) };
+    case 'read':
+      return { action: `leer ${oneLine(a.path, 120) || 'un archivo'}`, detail: '' };
+    default:
+      return { action: `usar la herramienta "${name}"`, detail: oneLine(JSON.stringify(a), 200) };
+  }
+}
+
+function permissionMessage(project, name, args) {
+  const { action, detail } = describePermission(name, args);
+  const lines = [`⚠ [${project}] Permiso: el agente quiere ${action}.`];
+  if (detail) lines.push('', detail);
+  lines.push('', '¿Qué hacemos?');
+  return lines.join('\n');
+}
+
+function permissionKeyboard(askId) {
+  return {
+    inline_keyboard: [
+      [
+        { text: 'Permitir', callback_data: `perm:${askId}:allow` },
+        { text: 'Permitir todo', callback_data: `perm:${askId}:all` },
+      ],
+      [{ text: 'Denegar', callback_data: `perm:${askId}:deny` }],
+    ],
+  };
+}
+
 async function tg(token, method, payload) {
   const res = await fetch(`${API}/bot${token}/${method}`, {
     method: 'POST',
@@ -145,6 +220,7 @@ export function startTelegramChannel(
   const modelChoices = new Map();
   const projectChoices = new Map();
   const pendingInputs = new Map();
+  const askSessions = new Map(); // askId -> sessionId, para "Permitir todo"
   let running = true;
   let offset = 0;
 
@@ -195,11 +271,30 @@ 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);
+  /** Manda una imagen (una captura del tool `screenshot`). */
+  async function enviarFoto(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(token, 'sendPhoto', form);
+    } catch (error) {
+      log(`telegram: foto falló: ${error?.message ?? error}`);
+    }
+  }
+
+  /** Entrega una captura guardada en la casa (por nombre, sin path traversal). */
+  async function enviarCaptura(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(chatId, buffer, caption);
   }
 
   // --- proyectos ------------------------------------------------------------
@@ -359,19 +454,15 @@ export function startTelegramChannel(
     }
 
     const onAsk = async (name, args) => {
+      // "Permitir todo" activa el auto-approve de la sesion (compartido con la
+      // consola): a partir de ahi no se vuelve a preguntar.
+      if (ctx.isAutoApprove?.(sessionId)) return true;
       const askId = randomUUID();
-      const preview = JSON.stringify(args ?? {}).slice(0, 300);
-      await send(chatId, `⚠ [${projectLabel(session)}] Permiso para ${name}\n${preview}`, {
-        reply_markup: {
-          inline_keyboard: [
-            [
-              { text: 'Permitir', callback_data: `perm:${askId}:allow` },
-              { text: 'Denegar', callback_data: `perm:${askId}:deny` },
-            ],
-          ],
-        },
+      askSessions.set(askId, sessionId);
+      await send(chatId, permissionMessage(projectLabel(session), name, args), {
+        reply_markup: permissionKeyboard(askId),
       });
-      return ctx.approvals.ask(askId);
+      return ctx.approvals.ask(askId, { sessionId, name, args });
     };
 
     const local = createTools({
@@ -427,6 +518,9 @@ export function startTelegramChannel(
             }
           } else if (event.type === 'tool_result') {
             activity = `${event.name} ✓`;
+            if (event.name === 'screenshot' && event.meta?.screenshot?.name) {
+              enviarCaptura(chatId, event.meta.screenshot.name, event.meta.screenshot.url);
+            }
           } else {
             return;
           }
@@ -458,7 +552,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) {
@@ -665,8 +758,12 @@ export function startTelegramChannel(
     let toast = '';
 
     if (kind === 'perm') {
-      ctx.approvals.decide(a, b === 'allow');
-      toast = b === 'allow' ? 'Permitido' : 'Denegado';
+      const all = b === 'all';
+      ctx.approvals.decide(a, b === 'allow' || all);
+      const sessionId = askSessions.get(a);
+      if (sessionId) askSessions.delete(a);
+      if (all && sessionId) ctx.setAutoApprove?.(sessionId, true);
+      toast = all ? 'Permitidos todos' : b === 'allow' ? 'Permitido' : 'Denegado';
     } else if (kind === 'proj') {
       if (a === 'root') {
         await selectProject(chatId, projectRoot());
@@ -764,7 +861,7 @@ export function startTelegramChannel(
     notify(sessionId, event) {
       if (ownSessions.has(sessionId)) return;
 
-      // La tool `speak` entrega audio en vivo a un chat vinculado.
+      // Las tools `speak` y `screenshot` entregan en vivo a un chat vinculado.
       if (event.type === 'tool_call') {
         if (event.data?.name !== 'speak') return;
         const linked = ctx.store.getSetting(reverseKey(sessionId));
@@ -776,6 +873,12 @@ export function startTelegramChannel(
         }
         return;
       }
+      if (event.type === 'tool_result' && event.data?.name === 'screenshot') {
+        const linked = ctx.store.getSetting(reverseKey(sessionId));
+        const shot = event.data?.meta?.screenshot;
+        if (linked && shot?.name) enviarCaptura(linked, shot.name, shot.url);
+        return;
+      }
 
       const targets = notifyTargets(sessionId);
       if (!targets.length) return;
@@ -784,18 +887,7 @@ export function startTelegramChannel(
 
       if (event.type === 'done' && notifyConfig.done) {
         const text = `[${project}] ✅ Sesión terminada.\n\n${String(event.data?.content ?? '').slice(0, 3500)}`;
-        const decir =
-          event.data?.say ??
-          fraseFin({
-            stopReason: event.data?.stopReason,
-            rounds: event.data?.rounds,
-            toolCalls: event.data?.toolCalls,
-            durationMs: event.data?.durationMs,
-          });
-        for (const chatId of targets) {
-          send(chatId, text).catch(() => {});
-          sendResumenDeVoz(chatId, `${project}. ${decir}`);
-        }
+        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(() => {});
@@ -805,17 +897,10 @@ export function startTelegramChannel(
       } else if (event.type === 'permission' && notifyConfig.permission) {
         const askId = event.data?.askId;
         if (!askId) return;
+        if (event.data?.sessionId) askSessions.set(askId, event.data.sessionId);
+        const text = permissionMessage(project, event.data?.name ?? 'una tool', event.data?.args);
         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(() => {});
+          send(chatId, text, { reply_markup: permissionKeyboard(askId) }).catch(() => {});
         }
       }
     },

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

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { readJson, sendJson, sendError } from '../lib/http.js';
-import { staticServerChip } from '../lib/core.js';
+import { staticServerChip, screenshotsDir } from '../lib/core.js';
 import { isInside, localOk, requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
 const MAX_PREVIEW = 200 * 1024;
@@ -144,4 +144,28 @@ export function registerFiles(route, ctx) {
       port: proc.port,
     });
   });
+
+  // Capturas del tool `screenshot`: viven en la casa, no en el workspace.
+  route('GET', '/api/screenshots/:name', ({ req, res, params }) => {
+    const local = localOk(req);
+    if (!local && !ctx.authEnabled) {
+      return sendError(res, 403, 'Las capturas solo están disponibles en conexiones locales.');
+    }
+    const name = String(params.name ?? '');
+    if (!/^[a-z0-9][a-z0-9-]*\.png$/i.test(name)) return sendError(res, 400, 'Nombre de captura inválido.');
+    const file = path.join(screenshotsDir(), name);
+    let info;
+    try {
+      info = fs.statSync(file);
+    } catch {
+      return sendError(res, 404, 'La captura no existe.');
+    }
+    if (!info.isFile()) return sendError(res, 404, 'La captura no existe.');
+    res.writeHead(200, { 'Content-Type': 'image/png', 'Content-Length': info.size, 'Cache-Control': 'no-store' });
+    if (req.method === 'HEAD') {
+      res.end();
+      return;
+    }
+    fs.createReadStream(file).pipe(res);
+  });
 }

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

@@ -6,6 +6,49 @@ import { sessionView, sessionState, awaitingBySession } from '../lib/sessionView
 const COMPACT_INSTRUCTION =
   'Resumí la conversación en un texto conciso que preserve decisiones tomadas, archivos tocados, hallazgos y el estado actual, para poder continuar el trabajo sin el historial completo.';
 
+const SUMMARY_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.';
+
+function sessionTranscript(messages) {
+  return messages
+    .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+    .join('\n');
+}
+
+/**
+ * Corre un resumen no destructivo de la sesión (no toca el historial).
+ * Devuelve `{ summary }` o `{ error, status }`.
+ */
+async function summarizeSession(ctx, session, instruction) {
+  const messages = ctx.store.getMessages(session.id);
+  if (!messages.length) return { error: 'La sesión no tiene mensajes para resumir.', status: 400 };
+  const providerId = session.provider || ctx.effectiveProviderId();
+  const model = session.model || ctx.effectiveModel();
+  if (!model) return { error: 'Falta el modelo para resumir.', status: 400 };
+
+  try {
+    const { provider, config } = ctx.resolveProvider({
+      ...ctx.providerSettings(providerId),
+      apiKey: ctx.apiKeyFor(providerId),
+    });
+    const result = await runAgent({
+      provider,
+      config,
+      model,
+      messages: [
+        { role: 'system', content: instruction },
+        { role: 'user', content: sessionTranscript(messages).slice(0, 60000) },
+      ],
+      tools: [],
+    });
+    const summary = result.content?.trim();
+    if (!summary) return { error: 'El modelo no devolvió un resumen.', status: 502 };
+    return { summary };
+  } catch (error) {
+    return { error: `No se pudo resumir: ${error?.message ?? error}`, status: 502 };
+  }
+}
+
 export function registerSessions(route, ctx) {
   route('GET', '/api/sessions', ({ res }) => {
     const awaiting = awaitingBySession(ctx.approvals.list());
@@ -123,40 +166,19 @@ export function registerSessions(route, ctx) {
   route('POST', '/api/sessions/:id/compact', async ({ res, params }) => {
     const session = ctx.store.getSession(params.id);
     if (!session) return sendError(res, 404, 'Sesión no encontrada.');
-    const messages = ctx.store.getMessages(params.id);
-    if (!messages.length) return sendError(res, 400, 'La sesión no tiene mensajes para compactar.');
-
-    const providerId = session.provider || ctx.effectiveProviderId();
-    const model = session.model || ctx.effectiveModel();
-    if (!model) return sendError(res, 400, 'Falta el modelo para compactar.');
-
-    const transcript = messages
-      .map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
-      .join('\n');
+    const out = await summarizeSession(ctx, session, COMPACT_INSTRUCTION);
+    if (out.error) return sendError(res, out.status, out.error);
+    ctx.store.clearMessages(params.id);
+    ctx.store.touchSession(params.id, { meta: { summary: out.summary } });
+    sendJson(res, 200, { summary: out.summary, messages: 0 });
+  });
 
-    try {
-      const { provider, config } = ctx.resolveProvider({
-        ...ctx.providerSettings(providerId),
-        apiKey: ctx.apiKeyFor(providerId),
-      });
-      const result = await runAgent({
-        provider,
-        config,
-        model,
-        messages: [
-          { role: 'system', content: COMPACT_INSTRUCTION },
-          { role: 'user', content: transcript.slice(0, 60000) },
-        ],
-        tools: [],
-      });
-      const summary = result.content?.trim();
-      if (!summary) return sendError(res, 502, 'El modelo no devolvió un resumen.');
-      ctx.store.clearMessages(params.id);
-      ctx.store.touchSession(params.id, { meta: { summary } });
-      sendJson(res, 200, { summary, messages: 0 });
-    } catch (error) {
-      sendError(res, 502, `No se pudo compactar: ${error?.message ?? error}`);
-    }
+  route('POST', '/api/sessions/:id/summary', async ({ res, params }) => {
+    const session = ctx.store.getSession(params.id);
+    if (!session) return sendError(res, 404, 'Sesión no encontrada.');
+    const out = await summarizeSession(ctx, session, SUMMARY_INSTRUCTION);
+    if (out.error) return sendError(res, out.status, out.error);
+    sendJson(res, 200, { summary: out.summary });
   });
 
   route('DELETE', '/api/sessions/:id', ({ res, params }) => {

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

@@ -6,7 +6,7 @@ import { mkdtemp, mkdir, writeFile, readFile, stat } from 'node:fs/promises';
 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 { setHome, ensureApp, readApp, writeApp, makeUser, screenshotsDir } from '../../core/src/index.js';
 import { completionFooter } from '../src/lib/channels/telegram.js';
 
 const fakeProvider = {
@@ -1719,6 +1719,40 @@ test('compact summarizes the session and clears its messages', async () => {
   }
 });
 
+test('the summary endpoint returns a summary without clearing the messages', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-summary-'));
+  const provider = {
+    id: 'sum',
+    async streamChat(_config, opts) {
+      const system = opts.messages.find((m) => m.role === 'system')?.content ?? '';
+      return { content: system.includes('Resumí la conversación') ? 'RESUMEN FINAL' : 'hola', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 'S' }) })
+    ).json();
+    const id = created.session.id;
+    await (await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+    })).text();
+
+    const summary = await (
+      await fetch(`${base}/api/sessions/${id}/summary`, { method: 'POST', headers: json })
+    ).json();
+    assert.equal(summary.summary, 'RESUMEN FINAL');
+
+    const detail = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.ok(detail.messages.length > 0, 'no borra el historial');
+  } finally {
+    await instance.close();
+  }
+});
+
 test('exposes modes and persists the active mode', async () => {
   const { instance, base } = await startServer();
   const json = { 'Content-Type': 'application/json' };
@@ -1758,7 +1792,21 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
         body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
       })
     ).text();
-    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read', 'speak', 'task']);
+    assert.deepEqual(captured.tools, [
+      'console_errors',
+      'fetch_url',
+      'git_diff',
+      'git_log',
+      'git_status',
+      'glob',
+      'grep',
+      'list',
+      'preview_url',
+      'read',
+      'screenshot',
+      'speak',
+      'task',
+    ]);
     assert.match(captured.system, /modo PLAN/);
   } finally {
     await instance.close();
@@ -1992,16 +2040,38 @@ test('truncates a session from a message id', async () => {
     const firstId = detail.messages[0].id;
     assert.ok(firstId);
 
-    const res = await fetch(`${base}/api/sessions/${sessionId}/truncate`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ fromId: firstId }),
-    });
-    assert.equal(res.status, 200);
-
-    detail = await (await fetch(`${base}/api/sessions/${sessionId}`)).json();
-    assert.equal(detail.messages.length, 0);
-  } finally {
-    await instance.close();
-  }
+    const res = await fetch(`${base}/api/sessions/${sessionId}/truncate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ fromId: firstId }),
+    });
+    assert.equal(res.status, 200);
+
+    detail = await (await fetch(`${base}/api/sessions/${sessionId}`)).json();
+    assert.equal(detail.messages.length, 0);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('serves browser screenshots from the home dir, confined to png names', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-shots-'));
+  const { instance, base } = await startServer({ cwd });
+  try {
+    const dir = screenshotsDir();
+    await mkdir(dir, { recursive: true });
+    const png = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    await writeFile(path.join(dir, 'abc-123.png'), png);
+
+    const ok = await fetch(`${base}/api/screenshots/abc-123.png`);
+    assert.equal(ok.status, 200);
+    assert.equal(ok.headers.get('content-type'), 'image/png');
+    assert.equal((await ok.arrayBuffer()).byteLength, png.length);
+
+    assert.equal((await fetch(`${base}/api/screenshots/bad.txt`)).status, 400);
+    assert.equal((await fetch(`${base}/api/screenshots/missing.png`)).status, 404);
+  } finally {
+    await instance.close();
+  }
 });
+

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

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { Store } from '../../core/src/index.js';
 import { createApprovalBroker } from '../src/lib/approvals.js';
 import { createPresence } from '../src/lib/presence.js';
-import { startTelegramChannel } from '../src/lib/channels/telegram.js';
+import { startTelegramChannel, describePermission } from '../src/lib/channels/telegram.js';
 
 const reply = (data) => ({ ok: true, json: async () => data });
 
@@ -227,15 +227,36 @@ test('notify de permiso incluye el proyecto y los botones', async () => {
     log: () => {},
   });
   try {
-    channel.notify(sessionId, { type: 'permission', data: { askId: 'ask-1', name: 'bash' } });
-    await waitFor(() => mock.sent.some((m) => /Permiso para bash/.test(m.text ?? '')));
-    const msg = mock.sent.find((m) => /Permiso para bash/.test(m.text ?? ''));
+    channel.notify(sessionId, {
+      type: 'permission',
+      data: { askId: 'ask-1', sessionId, name: 'bash', args: { command: 'npm test' } },
+    });
+    await waitFor(() => mock.sent.some((m) => /Permiso:/.test(m.text ?? '')));
+    const msg = mock.sent.find((m) => /Permiso:/.test(m.text ?? ''));
     assert.match(msg.text, new RegExp(`\\[${path.basename(cwd)}\\]`));
+    assert.match(msg.text, /ejecutar un comando/);
+    assert.match(msg.text, /npm test/);
     const datas = msg.reply_markup.inline_keyboard.flat().map((b) => b.callback_data);
     assert.ok(datas.includes('perm:ask-1:allow'));
+    assert.ok(datas.includes('perm:ask-1:all'));
+    assert.ok(datas.includes('perm:ask-1:deny'));
   } finally {
     channel.stop();
     mock.restore();
     ctx.store.close();
   }
 });
+
+test('describePermission explica la accion sin volcar el JSON', () => {
+  assert.deepEqual(describePermission('bash', { command: 'npm test' }), {
+    action: 'ejecutar un comando en el proyecto',
+    detail: 'npm test',
+  });
+  const write = describePermission('write', { path: 'nota.txt', content: 'hola mundo' });
+  assert.match(write.action, /escribir el archivo nota\.txt/);
+  assert.match(write.detail, /Contenido: 10 B/);
+  assert.doesNotMatch(write.detail, /hola mundo/);
+  assert.match(describePermission('edit', { path: 'a.js', oldString: 'const a = 1;' }).detail, /const a = 1;/);
+  assert.match(describePermission('screenshot', { url: 'http://127.0.0.1:5173' }).detail, /127\.0\.0\.1/);
+  assert.match(describePermission('desconocida', { x: 1 }).action, /desconocida/);
+});

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

@@ -107,7 +107,7 @@ function preselect(ctx, cwd, chatId = '7') {
   return sessionId;
 }
 
-test('con la voz activada, el turno de Telegram termina con una nota de voz', async () => {
+test('el cierre del turno de Telegram no manda audio aunque la voz esté activada', async () => {
   const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgvoz-'));
   const ctx = makeCtx(cwd, { tts: { enabled: true, voice: 'es-AR-ElenaNeural', rate: '+0%', announce: { end: true } } });
   preselect(ctx, cwd);
@@ -117,10 +117,8 @@ test('con la voz activada, el turno de Telegram termina con una nota de voz', as
   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.multipart.length > 0);
-    const nota = mock.multipart[0];
-    assert.equal(nota.chatId, '7');
-    assert.match(nota.method, /^send(Voice|Audio)$/);
+    await waitFor(() => mock.sent.some((m) => /✓ terminado/.test(m.text ?? '')));
+    assert.equal(mock.multipart.length, 0);
   } finally {
     global.WebSocket = original;
     channel.stop();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "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",