@danieltmn/tamnora 0.9.1 → 0.9.3

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

@@ -72,6 +72,10 @@ const ICON_PATHS = {
   'refresh-cw': ['M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8', 'M21 3v5h-5', 'M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16', 'M8 16H3v5'],
   trash: ['M3 6h18', 'M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6', 'M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2', 'M10 11v6', 'M14 11v6'],
   'dots-vertical': ['M12 5h.01', 'M12 12h.01', 'M12 19h.01'],
+  'dots-horizontal': ['M5 12h.01', 'M12 12h.01', 'M19 12h.01'],
+  play: ['m6 4 14 8-14 8z'],
+  pause: ['M8 5v14', 'M16 5v14'],
+  square: ['M6 6h12v12H6z'],
   copy: ['M8 8V5a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2h-3', 'M5 8h9a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2Z'],
   pencil: ['M17 3a2.85 2.83 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5Z', 'm15 5 4 4'],
 };
@@ -213,7 +217,7 @@ function activateTab(name) {
   hideMoreMenu();
   if (name === 'runs') refreshRuns();
   if (name === 'providers') refreshProviders();
-  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshChannels(); refreshLimits(); refreshVoz(); }
+  if (name === 'ajustes') { refreshMcp(); refreshSkills(); refreshChannels(); refreshLimits(); refreshVoz(); refreshTranscribe(); refreshProfile(); }
 }
 
 document.querySelectorAll('.tab[data-tab]').forEach((t) =>
@@ -301,6 +305,8 @@ if (statusbarEl) {
 const PALETTE_COMMANDS = [
   { id: 'new', label: 'Nueva sesión en otra carpeta', hint: '/new', run: () => openFolderPicker() },
   { id: 'init', label: 'Analizar el proyecto y crear AGENTS.md', hint: '/init', run: () => runSlash('init') },
+  { id: 'resumen', label: 'Resumir la conversación', hint: '/resumen', run: () => runSlash('resumen') },
+  { id: 'audioresumen', label: 'Resumen como audio', hint: '/audioresumen', run: () => runSlash('audioresumen') },
   { id: 'compact', label: 'Compactar la conversación', hint: '/compact', run: () => runSlash('compact') },
   { id: 'clear', label: 'Limpiar la conversación', hint: '/clear', run: () => runSlash('clear') },
   { id: 'mode', label: 'Cambiar Plan / Build', hint: 'Ctrl+.', run: () => toggleMode() },
@@ -330,7 +336,7 @@ function runSlash(name) {
 function paletteItems(query) {
   const q = query.trim().toLowerCase();
   const items = PALETTE_COMMANDS.filter(
-    (c) => !q || c.label.toLowerCase().includes(q) || c.id.includes(q)
+    (c) => !q || c.label.toLowerCase().includes(q) || c.id.includes(q) || (c.hint ?? '').toLowerCase().includes(q)
   ).map((c) => ({ label: c.label, hint: c.hint || 'comando', run: c.run }));
 
   for (const session of palette.results.sessions) {
@@ -461,6 +467,14 @@ async function loadModes() {
   const settings = await api('/api/settings').catch(() => null);
   const active = settings?.settings?.mode || 'agent';
   if ([...modeSelect.options].some((o) => o.value === active)) modeSelect.value = active;
+  defaultCwdCache = settings?.settings?.defaultCwd || '';
+  if (!defaultCwdCache) {
+    // Migración: la carpeta predeterminada vivía en localStorage; la subimos al
+    // server una vez para que Telegram también la vea.
+    const legacy = storage.get('tamnora-default-cwd', '');
+    if (legacy) writeDefaultCwd(legacy);
+  }
+  syncDefaultCwd();
   updateStatus();
 }
 
@@ -894,7 +908,7 @@ function addMessageActions(message) {
   const actions = el('div', 'msg-actions');
   const trigger = el('button', 'msg-menu-btn');
   trigger.type = 'button';
-  trigger.appendChild(icon('dots-vertical', 16));
+  trigger.appendChild(icon(window.matchMedia('(min-width: 821px)').matches ? 'dots-horizontal' : 'dots-vertical', 16));
   trigger.title = 'opciones del mensaje';
   trigger.setAttribute('aria-haspopup', 'menu');
   trigger.setAttribute('aria-expanded', 'false');
@@ -1244,18 +1258,13 @@ async function loadFullToolResult(entry, message) {
   }
 }
 
-/** Reproductor del tool `speak`: sintetiza el texto pedido contra /api/tts. */
-function speakAudio(args) {
+/** Botón del tool `speak`: encola el audio pedido en el reproductor global. */
+function speakControl(args) {
   const texto = String(args?.texto ?? '').trim();
   if (!texto) return null;
-  const params = new URLSearchParams({ texto });
-  if (args?.voice) params.set('voice', args.voice);
-  if (args?.rate) params.set('rate', args.rate);
-  const audio = el('audio', 'tool-audio');
-  audio.controls = true;
-  audio.preload = 'none';
-  audio.src = `/api/tts?${params.toString()}`;
-  return audio;
+  const btn = button('', () => reproducirVoz(texto, { voice: args?.voice, rate: args?.rate, label: 'voz' }).catch(() => {}), 'tool-audio-btn');
+  btn.append(icon('play', 13), el('span', '', 'escuchar'));
+  return btn;
 }
 
 /** Texto de la tarjeta: el server ya manda `summary` calculado; esto es el fallback. */
@@ -1269,17 +1278,17 @@ function addToolCard(message, name, args, { callId = null, open = null, round =
   const argsEl = el('span', 'tool-args', summary ?? toolSummary(name, args));
   head.append(glyph, el('span', 'tool-name', name), argsEl);
   const out = el('div', 'tool-out');
-  const audio = name === 'speak' ? speakAudio(args) : null;
+  const speak = name === 'speak' ? speakControl(args) : null;
   const more = button('ver completo', () => loadFullToolResult(entry, message), 'tool-more');
   more.hidden = true;
   card.append(head, out);
-  if (audio) card.appendChild(audio);
+  if (speak) card.appendChild(speak);
   card.appendChild(more);
   message.tools.appendChild(card);
   ensureToolsToggle(message);
   scrollMessages(paneOf(message));
 
-  const entry = { card, out, glyph, argsEl, more, audio, callId, full: false, truncated: false };
+  const entry = { card, out, glyph, argsEl, more, callId, full: false, truncated: false };
   card.addEventListener('toggle', () => {
     if (card.open && entry.truncated && !entry.full) loadFullToolResult(entry, message);
   });
@@ -1476,8 +1485,20 @@ function persistCollapsedGroups() {
   storage.setJson('tamnora-collapsed-groups', [...state.collapsedGroups]);
 }
 
+// Pestañas cerradas desde el último reporte: para que el server las olvide ya,
+// sin esperar el TTL de presencia.
+const presenceClosed = new Set();
+
+/** Reporta al server qué pestañas están abiertas (proyectos "habilitados"). */
+function sendPresence() {
+  const closed = [...presenceClosed];
+  presenceClosed.clear();
+  return api('/api/presence', { method: 'POST', body: { sessions: state.tabOrder, closed } }).catch(() => {});
+}
+
 function persistTabs() {
   storage.setJson('tamnora-open-tabs', { ids: state.tabOrder, active: state.activeTab });
+  sendPresence();
 }
 
 /**
@@ -1760,6 +1781,7 @@ function closeTab(id) {
   state.panes.delete(id);
   state.queues.delete(id);
   state.tabOrder = state.tabOrder.filter((item) => item !== id);
+  presenceClosed.add(id);
   if (state.activeTab === id) {
     const next = state.tabOrder[state.tabOrder.length - 1] ?? null;
     if (next) {
@@ -2001,8 +2023,8 @@ function handleChatEvent(event, data, turn) {
     setActivity(target, 'working');
     turn.lastTool = addToolCard(target, data.name, data.args, { callId: data.id, summary: data.summary });
     if (turn.live && data.name === 'speak') {
-      const player = turn.lastTool?.audio;
-      if (player) player.play?.().catch?.(() => {});
+      const texto = String(data.args?.texto ?? '').trim();
+      if (texto) reproducirVoz(texto, { voice: data.args?.voice, rate: data.args?.rate, label: 'voz' }).catch(() => {});
     }
   } else if (event === 'tool_result') {
     setActivity(turn.assistant(), 'thinking');
@@ -2419,6 +2441,365 @@ chatInput.addEventListener('keydown', (event) => {
 });
 chatInput.addEventListener('input', onChatInputChanged);
 
+/* --- voz de entrada (dictado) --------------------------------------------- */
+
+const micBtn = $('#mic-btn');
+
+// La cuenta 3-2-1 le da tiempo al micro a arrancar (si hablás apenas tocás se
+// pierden las primeras palabras); la cola al cortar evita perder el final.
+const REC_COUNT = [3, 2, 1, 0];
+const REC_COUNT_STEP_MS = 500;
+const REC_TAIL_MS = 500;
+
+/** Estado visual del botón de dictado: cuenta regresiva, grabando (verde) o transcribiendo. */
+function micVisual(button, { live = false, count = null, busy = false } = {}) {
+  if (!button) return;
+  button.classList.toggle('recording', live);
+  button.classList.toggle('busy', busy);
+  button.classList.toggle('mic-counting', count !== null);
+  const span = button.querySelector('.mic-count');
+  if (span) {
+    span.hidden = count === null;
+    span.textContent = count === null ? '' : String(count);
+  }
+}
+
+/** Cuenta regresiva antes de que empieces a hablar. Devuelve false si se canceló. */
+async function micCountdown(button, isCancelled) {
+  for (const count of REC_COUNT) {
+    if (isCancelled()) return false;
+    micVisual(button, { live: true, count });
+    await new Promise((resolve) => setTimeout(resolve, REC_COUNT_STEP_MS));
+  }
+  if (isCancelled()) return false;
+  micVisual(button, { live: true });
+  return true;
+}
+
+function blobToDataUrl(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(new Error('No se pudo leer el audio'));
+    reader.onload = () => resolve(reader.result);
+    reader.readAsDataURL(blob);
+  });
+}
+
+async function transcribirBlob(blob) {
+  const audio = await blobToDataUrl(blob);
+  const data = await api('/api/transcribe', { method: 'POST', body: { audio } });
+  return String(data?.text ?? '').trim();
+}
+
+/** Une los bloques de muestras Float32 en uno solo. */
+function mergeFloat32(chunks) {
+  const length = chunks.reduce((total, chunk) => total + chunk.length, 0);
+  const out = new Float32Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+
+/** Remuestrea a 16 kHz mono con OfflineAudioContext (sin dependencias). */
+async function resampleTo16k(samples, inputRate) {
+  if (!samples.length || Math.round(inputRate) === 16000) return samples;
+  const targetLength = Math.max(1, Math.round((samples.length * 16000) / inputRate));
+  const Ctx = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+  const off = new Ctx(1, targetLength, 16000);
+  const buffer = off.createBuffer(1, samples.length, inputRate);
+  buffer.copyToChannel(samples, 0);
+  const source = off.createBufferSource();
+  source.buffer = buffer;
+  source.connect(off.destination);
+  source.start();
+  const rendered = await off.startRendering();
+  return rendered.getChannelData(0);
+}
+
+/** Codifica muestras Float32 (-1..1) como WAV PCM 16-bit (lo acepta cualquier proveedor). */
+function encodeWav(samples, rate = 16000) {
+  const buffer = new ArrayBuffer(44 + samples.length * 2);
+  const view = new DataView(buffer);
+  const writeString = (offset, text) => {
+    for (let i = 0; i < text.length; i++) view.setUint8(offset + i, text.charCodeAt(i));
+  };
+  writeString(0, 'RIFF');
+  view.setUint32(4, 36 + samples.length * 2, true);
+  writeString(8, 'WAVE');
+  writeString(12, 'fmt ');
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, rate, true);
+  view.setUint32(28, rate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  writeString(36, 'data');
+  view.setUint32(40, samples.length * 2, true);
+  let offset = 44;
+  for (let i = 0; i < samples.length; i++) {
+    const sample = Math.max(-1, Math.min(1, samples[i]));
+    view.setInt16(offset, sample < 0 ? sample * 0x8000 : sample * 0x7fff, true);
+    offset += 2;
+  }
+  return new Blob([view], { type: 'audio/wav' });
+}
+
+/**
+ * Una grabación de micrófono (motor del servidor). Graba con Web Audio y devuelve
+ * un **WAV** (no WebM): así el proveedor no depende del contenedor que produce
+ * `MediaRecorder`. `start()` abre el micro (la cuenta 3-2-1 la maneja el que llama);
+ * `stop()` espera la cola antes de cortar. La usan el micrófono del chat y el
+ * "probar" de Ajustes.
+ */
+function createRecording() {
+  let resolveBlob;
+  const done = new Promise((resolve) => {
+    resolveBlob = resolve;
+  });
+  let stream = null;
+  let audioCtx = null;
+  let processor = null;
+  let source = null;
+  let sink = null;
+  let stopping = false;
+  let started = false;
+  const chunks = [];
+
+  async function cleanup() {
+    try {
+      processor?.disconnect();
+    } catch {
+      // ya desconectado
+    }
+    try {
+      source?.disconnect();
+    } catch {
+      // ya desconectado
+    }
+    try {
+      sink?.disconnect();
+    } catch {
+      // ya desconectado
+    }
+    try {
+      await audioCtx?.close();
+    } catch {
+      // contexto ya cerrado
+    }
+    stream?.getTracks?.().forEach((track) => track.stop());
+  }
+
+  return {
+    async start() {
+      const Ctx = window.AudioContext || window.webkitAudioContext;
+      if (!navigator.mediaDevices?.getUserMedia || !Ctx) {
+        throw new Error('Este navegador no soporta dictado por voz.');
+      }
+      stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      audioCtx = new Ctx();
+      if (audioCtx.state === 'suspended') await audioCtx.resume();
+      source = audioCtx.createMediaStreamSource(stream);
+      processor = audioCtx.createScriptProcessor(4096, 1, 1);
+      processor.onaudioprocess = (event) => {
+        chunks.push(new Float32Array(event.inputBuffer.getChannelData(0)));
+      };
+      // El procesador solo corre si llega al destination: un gain en 0 evita el eco.
+      sink = audioCtx.createGain();
+      sink.gain.value = 0;
+      source.connect(processor);
+      processor.connect(sink);
+      sink.connect(audioCtx.destination);
+      started = true;
+    },
+    get stopping() {
+      return stopping;
+    },
+    stop() {
+      if (stopping || !started) return;
+      stopping = true;
+      setTimeout(async () => {
+        const rate = audioCtx?.sampleRate || 48000;
+        const merged = mergeFloat32(chunks);
+        await cleanup();
+        const resampled = await resampleTo16k(merged, rate);
+        resolveBlob(encodeWav(resampled, 16000));
+      }, REC_TAIL_MS);
+    },
+    done,
+  };
+}
+
+const ERRORES_DICTADO = {
+  network:
+    'el dictado del navegador necesita el servicio de voz de Google y no respondió (pasa en Brave o sin internet). Probá el motor «Servidor» en Ajustes → Transcripción.',
+  'not-allowed': 'permiso de micrófono denegado.',
+  'service-not-allowed': 'el navegador bloqueó el servicio de dictado.',
+  aborted: 'dictado cancelado.',
+  'audio-capture': 'no encontré micrófono.',
+  'no-speech': 'no escuché nada.',
+};
+const DICTADO_FATAL = new Set(['network', 'not-allowed', 'service-not-allowed', 'audio-capture']);
+
+/**
+ * Dictado nativo del navegador (Web Speech API). `start()`/`stop()` controlan el
+ * ciclo. Los cortes por silencio (`no-speech`) se reconectan solos para no perder
+ * el hilo; los errores fatales (p. ej. `network`) se informan y se cortan.
+ */
+function createBrowserDictation({ language, onText, onEnd, onError } = {}) {
+  const Ctor = window.SpeechRecognition || window.webkitSpeechRecognition;
+  if (!Ctor) throw new Error('Este navegador no soporta dictado nativo (probá Chrome/Edge).');
+  const rec = new Ctor();
+  rec.lang = language || 'es-AR';
+  rec.continuous = true;
+  rec.interimResults = true;
+  let finalText = '';
+  let wanted = false;
+  let fatal = false;
+  let restarts = 0;
+
+  rec.onresult = (event) => {
+    let interim = '';
+    for (let i = event.resultIndex; i < event.results.length; i++) {
+      const result = event.results[i];
+      if (result.isFinal) finalText += result[0].transcript;
+      else interim += result[0].transcript;
+    }
+    onText?.(finalText, finalText + interim);
+  };
+  rec.onerror = (event) => {
+    const code = event.error || 'unknown';
+    if (DICTADO_FATAL.has(code)) {
+      fatal = true;
+      wanted = false;
+      onError?.(new Error(ERRORES_DICTADO[code] || `error de dictado (${code}).`));
+    } else if (code !== 'no-speech' && code !== 'aborted') {
+      onError?.(new Error(ERRORES_DICTADO[code] || `error de dictado (${code}).`));
+    }
+  };
+  rec.onend = () => {
+    // Chrome corta tras una pausa: si seguimos "escuchando", reconectamos.
+    if (wanted && !fatal && restarts < 30) {
+      restarts += 1;
+      setTimeout(() => {
+        if (!wanted || fatal) return;
+        try {
+          rec.start();
+        } catch {
+          // se reintenta en el proximo onend
+        }
+      }, 300);
+      return;
+    }
+    wanted = false;
+    onEnd?.();
+  };
+
+  return {
+    start() {
+      wanted = true;
+      fatal = false;
+      restarts = 0;
+      rec.start();
+    },
+    stop() {
+      wanted = false;
+      try {
+        rec.stop();
+      } catch {
+        // ya estaba detenido
+      }
+    },
+  };
+}
+
+let composerRecording = null;
+let browserDictation = null;
+
+function startBrowserMic() {
+  const base = chatInput.value.trim();
+  let dictation;
+  try {
+    dictation = createBrowserDictation({
+      language: transcribeConfig.language,
+      onText: (_final, combined) => {
+        chatInput.value = [base, combined.trim()].filter(Boolean).join(' ');
+        onChatInputChanged();
+      },
+      onEnd: () => {
+        if (browserDictation === dictation) browserDictation = null;
+        micVisual(micBtn);
+      },
+      onError: (error) => toast(`Dictado: ${error.message}`),
+    });
+  } catch (error) {
+    return toast(error.message);
+  }
+  browserDictation = dictation;
+  micVisual(micBtn, { live: true });
+  try {
+    dictation.start();
+  } catch (error) {
+    browserDictation = null;
+    micVisual(micBtn);
+    return toast(`Dictado: ${error.message}`);
+  }
+}
+
+async function toggleMic() {
+  if (!micBtn) return;
+  if (browserDictation) {
+    browserDictation.stop();
+    return;
+  }
+  if (composerRecording) {
+    composerRecording.stop();
+    return;
+  }
+  if (micBtn.disabled) return;
+  if (transcribeConfig.mode === 'browser') return startBrowserMic();
+
+  const rec = createRecording();
+  micBtn.disabled = true;
+  try {
+    await rec.start();
+  } catch (error) {
+    micBtn.disabled = false;
+    micVisual(micBtn);
+    return toast(`No pude acceder al micrófono: ${error.message}`);
+  }
+  micBtn.disabled = false;
+  composerRecording = rec;
+
+  // El manejo va antes de la cuenta: si cortás durante el 3-2-1, igual transcribe.
+  rec.done.then(async (blob) => {
+    if (composerRecording === rec) composerRecording = null;
+    if (!blob.size) {
+      micVisual(micBtn);
+      return;
+    }
+    micVisual(micBtn, { busy: true });
+    try {
+      const text = await transcribirBlob(blob);
+      if (!text) return toast('No se entendió el audio.');
+      chatInput.value = chatInput.value.trim() ? `${chatInput.value.trim()} ${text}` : text;
+      onChatInputChanged();
+      chatInput.focus();
+    } catch (error) {
+      toast(`No pude transcribir: ${error.message}`);
+    } finally {
+      micVisual(micBtn);
+    }
+  });
+
+  await micCountdown(micBtn, () => rec.stopping);
+}
+
+micBtn?.addEventListener('click', toggleMic);
+
 /* --- image attachments ---------------------------------------------------- */
 
 const attachInput = $('#image-input');
@@ -2511,6 +2892,8 @@ const COMMANDS = [
   ['/new', 'nueva sesión (elegís carpeta)'],
   ['/init', 'analizar el proyecto y crear/actualizar AGENTS.md'],
   ['/goal <texto>', 'fijar el objetivo de la sesión'],
+  ['/resumen', 'resumir la conversación (sin borrarla)'],
+  ['/audioresumen', 'el resumen como audio'],
   ['/compact', 'resumir la conversación y liberar contexto'],
   ['/clear', 'borrar los mensajes de esta sesión'],
   ['/cwd', 'mostrar la carpeta de trabajo'],
@@ -2520,7 +2903,9 @@ const COMMANDS = [
 
 function notify(markdown, kind = 'notice') {
   const message = addMessage('assistant', '');
-  message.textEl.classList.add(kind);
+  // `kind` puede traer varias clases ("notice err"): classList.add no acepta
+  // espacios, asi que se agregan una por una.
+  for (const cls of String(kind).split(/\s+/).filter(Boolean)) message.textEl.classList.add(cls);
   message.textEl.innerHTML = renderMarkdown(markdown);
   scrollMessages();
   return message;
@@ -2609,6 +2994,32 @@ async function runCommand(name, arg) {
       notify(`Objetivo de la sesión: **${arg}**`);
       return { handled: true };
     }
+    case 'resumen':
+    case 'resume': {
+      if (!state.sessionId) return needSession();
+      notify('Resumiendo la conversación…');
+      const out = await api(`/api/sessions/${state.sessionId}/summary`, { method: 'POST' }).catch((error) => ({
+        error: error.message,
+      }));
+      if (out.error) notify(`No se pudo resumir: ${out.error}`, 'notice err');
+      else notify(`**Resumen**\n\n${out.summary}`);
+      return { handled: true };
+    }
+    case 'audioresumen':
+    case 'audio-resumen': {
+      if (!state.sessionId) return needSession();
+      notify('Preparando el resumen…');
+      const out = await api(`/api/sessions/${state.sessionId}/summary`, { method: 'POST' }).catch((error) => ({
+        error: error.message,
+      }));
+      if (out.error) {
+        notify(`No se pudo resumir: ${out.error}`, 'notice err');
+        return { handled: true };
+      }
+      notify(`**Resumen**\n\n${out.summary}`);
+      reproducirVoz(out.summary, { label: 'resumen' }).catch((error) => notify(`No se pudo reproducir el audio: ${error.message}`, 'notice err'));
+      return { handled: true };
+    }
     case 'compact': {
       if (!state.sessionId) return needSession();
       notify('Compactando la conversación…');
@@ -2671,7 +3082,10 @@ function updateSlashMenu() {
   const value = chatInput.value;
   if (!value.startsWith('/') || /\s/.test(value)) return hideSlashMenu();
   const query = value.slice(1).toLowerCase();
-  slashMatches = slashCommandEntries().filter((entry) => entry.name.slice(1).toLowerCase().startsWith(query));
+  slashMatches = slashCommandEntries().filter(
+    (entry) =>
+      entry.name.slice(1).toLowerCase().startsWith(query) || entry.desc.toLowerCase().includes(query)
+  );
   if (!slashMatches.length) return hideSlashMenu();
   if (slashIndex >= slashMatches.length) slashIndex = 0;
   renderSlashMenu();
@@ -2734,16 +3148,18 @@ let folderListPath = null;
 let folderParent = null;
 let folderDirs = [];
 
-const DEFAULT_CWD_KEY = 'tamnora-default-cwd';
 let folderPickerMode = 'session';
+// La carpeta predeterminada vive en el server (la usan la consola y Telegram),
+// no en localStorage; acá se cachea para poder leerla sin await.
+let defaultCwdCache = '';
 
 function readDefaultCwd() {
-  return storage.get(DEFAULT_CWD_KEY, '') || '';
+  return defaultCwdCache || '';
 }
 
 function writeDefaultCwd(value) {
-  if (value) storage.set(DEFAULT_CWD_KEY, value);
-  else storage.remove(DEFAULT_CWD_KEY);
+  defaultCwdCache = value || '';
+  api('/api/settings', { method: 'PUT', body: { defaultCwd: defaultCwdCache } }).catch(() => {});
 }
 
 function syncDefaultCwd() {
@@ -3165,6 +3581,11 @@ const tgTokenEl = $('#tg-token');
 const tgChatsEl = $('#tg-chats');
 const tgTranscribeEl = $('#tg-transcribe');
 const tgTranscribeProviderEl = $('#tg-transcribe-provider');
+const tgNotifyEl = $('#tg-notify');
+const tgNotifyDoneEl = $('#tg-notify-done');
+const tgNotifyErrorEl = $('#tg-notify-error');
+const tgNotifyPermissionEl = $('#tg-notify-permission');
+const tgNotifyAgentEl = $('#tg-notify-agent');
 const tgStatusEl = $('#tg-status');
 const vozEnabledEl = $('#voz-enabled');
 const vozVoiceEl = $('#voz-voice');
@@ -3173,6 +3594,8 @@ const vozAnnStartEl = $('#voz-ann-start');
 const vozAnnToolsEl = $('#voz-ann-tools');
 const vozAnnEndEl = $('#voz-ann-end');
 const vozFfmpegEl = $('#voz-ffmpeg');
+const trProviderEl = $('#tr-provider');
+const trModelEl = $('#tr-model');
 
 /* --- ajustes: pestañas internas + límites del agente --------------------- */
 
@@ -3450,6 +3873,12 @@ async function refreshChannels() {
   if (tgTranscribeProviderEl && document.activeElement !== tgTranscribeProviderEl) {
     tgTranscribeProviderEl.value = tg.transcribeProvider ?? '';
   }
+  const notify = tg.notify ?? {};
+  if (tgNotifyEl) tgNotifyEl.checked = notify.enabled === true;
+  if (tgNotifyDoneEl) tgNotifyDoneEl.checked = notify.done !== false;
+  if (tgNotifyErrorEl) tgNotifyErrorEl.checked = notify.error !== false;
+  if (tgNotifyPermissionEl) tgNotifyPermissionEl.checked = notify.permission !== false;
+  if (tgNotifyAgentEl) tgNotifyAgentEl.checked = notify.agent !== false;
   if (tgTokenEl && document.activeElement !== tgTokenEl) {
     tgTokenEl.value = '';
     tgTokenEl.placeholder = tg.tokenHint ? `${tg.tokenHint} (dejar vacío para no cambiar)` : '123456:ABC…';
@@ -3463,6 +3892,13 @@ async function submitChannel() {
     allowedChatIds: tgChatsEl?.value ?? '',
     transcribeModel: tgTranscribeEl?.value.trim() || 'whisper-1',
     transcribeProvider: tgTranscribeProviderEl?.value.trim() || '',
+    notify: {
+      enabled: tgNotifyEl?.checked === true,
+      done: tgNotifyDoneEl?.checked !== false,
+      error: tgNotifyErrorEl?.checked !== false,
+      permission: tgNotifyPermissionEl?.checked !== false,
+      agent: tgNotifyAgentEl?.checked !== false,
+    },
   };
   const token = tgTokenEl.value.trim();
   if (token) body.token = token;
@@ -3492,35 +3928,139 @@ const voz = {
     rate: '+0%',
     announce: { start: true, tools: true, end: true },
   },
-  cola: Promise.resolve(),
 };
 
-/** Reproduce una frase contra el endpoint de sintesis del server. */
-function reproducirVoz(frase, { voice, rate } = {}) {
+/**
+ * Un único reproductor para TODO el audio (narración, tool `speak`,
+ * `/audioresumen`, prueba de voz): encola y reproduce de a uno, en orden, con
+ * controles visibles para pausar o detener. Antes cada audio creaba su propio
+ * `<audio>` y, si el modelo pedía dos, sonaban encimados y sin forma de pararlos.
+ */
+const ap = { el: $('#audio-player'), audio: new Audio(), queue: [], current: null, ready: false };
+
+function ensurePlayer() {
+  if (!ap.el || ap.ready) return;
+  ap.ready = true;
+  ap.toggle = button('', () => toggleAudio(), 'ap-btn');
+  ap.iconEl = el('span', 'ap-icon');
+  ap.toggle.appendChild(ap.iconEl);
+  ap.labelEl = el('span', 'ap-label');
+  ap.barEl = el('div', 'ap-bar');
+  const progress = el('div', 'ap-progress');
+  progress.appendChild(ap.barEl);
+  const info = el('div', 'ap-info');
+  info.append(ap.labelEl, progress);
+  ap.queueEl = el('span', 'ap-queue');
+  ap.stopBtn = button('', () => stopAudio(), 'ap-btn ap-stop');
+  ap.stopBtn.title = 'detener';
+  ap.stopBtn.setAttribute('aria-label', 'detener audio');
+  ap.stopBtn.appendChild(icon('square', 14));
+  ap.el.append(ap.toggle, info, ap.queueEl, ap.stopBtn);
+
+  ap.audio.addEventListener('ended', () => advanceAudio(ap.current));
+  ap.audio.addEventListener('error', () => {
+    if (ap.current && ap.audio.getAttribute('src')) advanceAudio(ap.current, new Error('No se pudo reproducir el audio.'));
+  });
+  ap.audio.addEventListener('play', renderAudio);
+  ap.audio.addEventListener('pause', renderAudio);
+  ap.audio.addEventListener('timeupdate', () => {
+    const { duration, currentTime } = ap.audio;
+    if (!Number.isFinite(duration) || duration <= 0) return;
+    ap.barEl.style.width = `${Math.min(100, (currentTime / duration) * 100)}%`;
+  });
+}
+
+/** Encola un audio. La promesa se resuelve al terminar (o al detenerlo). */
+function enqueueSpeech({ texto, voice, rate, label = 'audio', maxAgeMs = 0 } = {}) {
+  const frase = String(texto ?? '').trim();
+  if (!frase) return Promise.resolve();
+  ensurePlayer();
   return new Promise((resolve, reject) => {
-    const params = new URLSearchParams({
-      texto: frase,
-      voice: voice ?? voz.settings.voice,
-      rate: rate ?? voz.settings.rate,
-    });
-    const audio = new Audio(`/api/tts?${params}`);
-    audio.onended = () => resolve();
-    audio.onerror = () => reject(new Error('no se pudo reproducir (¿sin conexión?)'));
-    audio.play().catch(() => reject(new Error('el navegador bloqueó el audio: tocá la página y probá de nuevo')));
+    ap.queue.push({ texto: frase, voice, rate, label, createdAt: Date.now(), maxAgeMs, resolve, reject });
+    if (ap.current) renderAudio();
+    else playNextAudio();
   });
 }
 
+function playNextAudio() {
+  const item = ap.queue.shift();
+  if (!item) {
+    ap.current = null;
+    renderAudio();
+    return;
+  }
+  if (item.maxAgeMs && Date.now() - item.createdAt > item.maxAgeMs) {
+    item.resolve?.();
+    return playNextAudio();
+  }
+  ap.current = item;
+  const params = new URLSearchParams({
+    texto: item.texto,
+    voice: item.voice ?? voz.settings.voice,
+    rate: item.rate ?? voz.settings.rate,
+  });
+  ap.audio.src = `/api/tts?${params}`;
+  ap.audio.play().catch(() => {
+    advanceAudio(item, new Error('el navegador bloqueó el audio: tocá la página y probá de nuevo'));
+  });
+  renderAudio();
+}
+
+function advanceAudio(item, error) {
+  if (!item || ap.current !== item) return;
+  ap.current = null;
+  if (error) item.reject?.(error);
+  else item.resolve?.();
+  playNextAudio();
+}
+
+function toggleAudio() {
+  if (!ap.current) return;
+  if (ap.audio.paused) ap.audio.play().catch(() => {});
+  else ap.audio.pause();
+}
+
+/** Detiene lo que suena y vacía lo que espera. */
+function stopAudio() {
+  for (const item of ap.queue) item.resolve?.();
+  ap.queue = [];
+  const current = ap.current;
+  ap.current = null;
+  current?.resolve?.();
+  ap.audio.pause();
+  ap.audio.removeAttribute('src');
+  ap.audio.load();
+  if (ap.barEl) ap.barEl.style.width = '0%';
+  renderAudio();
+}
+
+function renderAudio() {
+  if (!ap.el || !ap.ready) return;
+  const active = Boolean(ap.current) || ap.queue.length > 0;
+  ap.el.hidden = !active;
+  if (!active) return;
+  ap.labelEl.textContent = ap.current?.label ?? 'audio';
+  ap.queueEl.hidden = ap.queue.length === 0;
+  ap.queueEl.textContent = ap.queue.length ? `+${ap.queue.length}` : '';
+  const playing = Boolean(ap.current) && !ap.audio.paused;
+  ap.iconEl.replaceChildren(icon(playing ? 'pause' : 'play', 14));
+  ap.toggle.title = playing ? 'pausar' : 'reproducir';
+  ap.toggle.setAttribute('aria-label', ap.toggle.title);
+}
+
+/** Reproduce una frase contra el endpoint de sintesis del server. */
+function reproducirVoz(frase, { voice, rate, label, maxAgeMs } = {}) {
+  return enqueueSpeech({ texto: frase, voice, rate, label, maxAgeMs });
+}
+
 /**
- * Encola una frase para hablar (secuencial: una a la vez). Si el turno tarda y
- * la frase quedó vieja en la cola, se descarta: narrar el pasado no informa.
+ * Narra una frase del turno. Si el turno tarda y la frase quedó vieja en la
+ * cola, se descarta al llegar su turno (`maxAgeMs`): narrar el pasado no informa.
  */
 function hablar(texto) {
   const frase = String(texto ?? '').trim();
   if (!frase || !voz.settings.enabled) return;
-  const creado = Date.now();
-  voz.cola = voz.cola
-    .then(() => (Date.now() - creado > 45000 ? null : reproducirVoz(frase)))
-    .catch(() => {});
+  reproducirVoz(frase, { label: 'narrando', maxAgeMs: 45000 }).catch(() => {});
 }
 
 /** Habla el progreso de un turno EN VIVO: el replay de una reconexion no habla. */
@@ -3535,9 +4075,11 @@ function narrar(event, data, turn) {
 
 async function cargarVoces() {
   if (!vozVoiceEl || vozVoiceEl.options.length) return;
-  const data = await api('/api/tts/voices').catch(() => null);
+  const data = await api('/api/tts/voices?filter=es-').catch(() => null);
   if (!data?.voices?.length) return;
-  for (const v of [...data.voices].sort((a, b) => String(a.ShortName).localeCompare(String(b.ShortName)))) {
+  // Solo voces en español (el server ya filtra; guarda por si cambia).
+  const espanol = data.voices.filter((v) => /^es[-_]/i.test(String(v.Locale || v.ShortName || '')));
+  for (const v of espanol.sort((a, b) => String(a.ShortName).localeCompare(String(b.ShortName)))) {
     const option = el('option', '', `${v.ShortName}${v.Gender === 'Female' ? ' · femenina' : v.Gender === 'Male' ? ' · masculina' : ''}`);
     option.value = v.ShortName;
     vozVoiceEl.appendChild(option);
@@ -3602,10 +4144,166 @@ async function submitVoz() {
   setStatus('#voz-msg', 'guardado', 'ok');
 }
 
+/* --- ajustes: transcripción ----------------------------------------------- */
+
+const trModeEl = $('#tr-mode');
+const trLanguageEl = $('#tr-language');
+
+// Config efectiva del dictado; se carga al boot para que el micrófono del chat
+// la use sin abrir Ajustes.
+const transcribeConfig = {
+  mode: 'server',
+  language: 'es-AR',
+  provider: '',
+  model: '',
+  fallback: { provider: '', model: '' },
+};
+
+function syncTranscribeMode() {
+  const mode = trModeEl?.value ?? transcribeConfig.mode;
+  const serverFields = $('#tr-server-fields');
+  if (serverFields) serverFields.hidden = mode !== 'server';
+  const browserNote = $('#tr-browser-note');
+  if (browserNote) browserNote.hidden = mode !== 'browser';
+  const googleNote = $('#tr-google-note');
+  if (googleNote) googleNote.hidden = mode !== 'google';
+}
+
+function aplicarTranscribe(data) {
+  if (!data) return;
+  transcribeConfig.mode = ['browser', 'google'].includes(data.mode) ? data.mode : 'server';
+  transcribeConfig.language = data.language || 'es-AR';
+  transcribeConfig.provider = data.provider ?? '';
+  transcribeConfig.model = data.model ?? '';
+  transcribeConfig.fallback = data.fallback ?? { provider: '', model: '' };
+  if (trModeEl && document.activeElement !== trModeEl) trModeEl.value = transcribeConfig.mode;
+  if (trLanguageEl && document.activeElement !== trLanguageEl) trLanguageEl.value = transcribeConfig.language;
+  if (trProviderEl && document.activeElement !== trProviderEl) trProviderEl.value = transcribeConfig.provider;
+  if (trModelEl && document.activeElement !== trModelEl) trModelEl.value = transcribeConfig.model;
+  if (trProviderEl) trProviderEl.placeholder = transcribeConfig.fallback.provider || 'groq · openai';
+  if (trModelEl) trModelEl.placeholder = transcribeConfig.fallback.model || 'whisper-large-v3-turbo';
+  syncTranscribeMode();
+  if (transcribeConfig.mode === 'browser') {
+    setStatus('#tr-status', `navegador · ${transcribeConfig.language}`, '');
+  } else if (transcribeConfig.mode === 'google') {
+    setStatus('#tr-status', `google (sin API key) · ${transcribeConfig.language}`, '');
+  } else {
+    const effProvider = transcribeConfig.provider || transcribeConfig.fallback.provider || 'proveedor activo';
+    const effModel = transcribeConfig.model || transcribeConfig.fallback.model || 'whisper-1';
+    setStatus('#tr-status', `usa: ${effProvider} · ${effModel}`, '');
+  }
+}
+
+async function refreshTranscribe() {
+  if (!trModeEl) return;
+  const data = await api('/api/transcribe/settings').catch(() => null);
+  if (data) aplicarTranscribe(data);
+}
+
+async function submitTranscribe() {
+  setStatus('#tr-msg', 'guardando…');
+  const data = await api('/api/transcribe/settings', {
+    method: 'PUT',
+    body: {
+      mode: trModeEl?.value || 'server',
+      language: trLanguageEl?.value.trim() || 'es-AR',
+      provider: trProviderEl?.value.trim() || '',
+      model: trModelEl?.value.trim() || '',
+    },
+  }).catch((e) => ({ error: e.message }));
+  if (data?.error) return setStatus('#tr-msg', data.error, 'err');
+  setStatus('#tr-msg', 'guardado', 'ok');
+  aplicarTranscribe(data);
+}
+
+$('#tr-save')?.addEventListener('click', submitTranscribe);
+trModeEl?.addEventListener('change', syncTranscribeMode);
+
+const trTestBtn = $('#tr-test');
+let trRecording = null;
+let browserTest = null;
+
+function startBrowserTest() {
+  let dictation;
+  try {
+    dictation = createBrowserDictation({
+      language: transcribeConfig.language,
+      onText: (_final, combined) => {
+        const text = combined.trim();
+        setStatus('#tr-test-result', text ? `“${text}”` : 'escuchando…', text ? 'ok' : '');
+      },
+      onEnd: () => {
+        if (browserTest === dictation) browserTest = null;
+        micVisual(trTestBtn);
+      },
+      onError: (error) => setStatus('#tr-test-result', error.message, 'err'),
+    });
+  } catch (error) {
+    return setStatus('#tr-test-result', error.message, 'err');
+  }
+  browserTest = dictation;
+  setStatus('#tr-test-result', '');
+  micVisual(trTestBtn, { live: true });
+  try {
+    dictation.start();
+  } catch (error) {
+    browserTest = null;
+    micVisual(trTestBtn);
+    setStatus('#tr-test-result', error.message, 'err');
+  }
+}
+
+/** Graba con el micrófono y muestra acá qué devuelve la transcripción. */
+async function toggleTrTest() {
+  if (!trTestBtn) return;
+  if (browserTest) {
+    browserTest.stop();
+    return;
+  }
+  if (trRecording) {
+    trRecording.stop();
+    return;
+  }
+  if (transcribeConfig.mode === 'browser') return startBrowserTest();
+
+  const rec = createRecording();
+  trTestBtn.disabled = true;
+  setStatus('#tr-test-result', '');
+  try {
+    await rec.start();
+  } catch (error) {
+    trTestBtn.disabled = false;
+    micVisual(trTestBtn);
+    return setStatus('#tr-test-result', `No pude acceder al micrófono: ${error.message}`, 'err');
+  }
+  trTestBtn.disabled = false;
+  trRecording = rec;
+  rec.done.then(async (blob) => {
+    if (trRecording === rec) trRecording = null;
+    if (!blob.size) {
+      micVisual(trTestBtn);
+      return setStatus('#tr-test-result', 'no se grabó audio', 'err');
+    }
+    micVisual(trTestBtn, { busy: true });
+    setStatus('#tr-test-result', 'transcribiendo…');
+    try {
+      const text = await transcribirBlob(blob);
+      setStatus('#tr-test-result', text ? `“${text}”` : 'no se entendió el audio', text ? 'ok' : 'err');
+    } catch (error) {
+      setStatus('#tr-test-result', error.message, 'err');
+    } finally {
+      micVisual(trTestBtn);
+    }
+  });
+  await micCountdown(trTestBtn, () => rec.stopping);
+}
+
+trTestBtn?.addEventListener('click', toggleTrTest);
+
 async function testVoz() {
   setStatus('#voz-msg', 'sintetizando…');
   try {
-    await reproducirVoz('Hola, así cuento lo que estoy haciendo.', {
+    await reproducirVoz('Hola, soy tamnora y así es la voz con la que cuento lo que estoy haciendo. ¿Qué te parece?', {
       voice: vozVoiceEl?.value,
       rate: vozRateEl?.value,
     });
@@ -3615,6 +4313,83 @@ async function testVoz() {
   }
 }
 
+/* --- ajustes: perfil del usuario ------------------------------------------ */
+
+const perfil = {
+  address: $('#perfil-address'),
+  name: $('#perfil-name'),
+  language: $('#perfil-language'),
+  notes: $('#perfil-notes'),
+  fields: $('#perfil-fields'),
+  add: $('#perfil-add-field'),
+  save: $('#perfil-save'),
+};
+
+function addPerfilFieldRow(key = '', value = '') {
+  if (!perfil.fields) return;
+  const row = el('div', 'perfil-field');
+  const keyInput = el('input', 'pf-key');
+  keyInput.placeholder = 'clave';
+  keyInput.value = key;
+  keyInput.spellcheck = false;
+  const valueInput = el('input', 'pf-value');
+  valueInput.placeholder = 'valor';
+  valueInput.value = value;
+  valueInput.spellcheck = false;
+  const remove = button('', () => row.remove(), 'btn icon');
+  remove.appendChild(icon('x', 12));
+  row.append(keyInput, valueInput, remove);
+  perfil.fields.appendChild(row);
+}
+
+function renderPerfilFields(fields = {}) {
+  if (!perfil.fields) return;
+  clear(perfil.fields);
+  for (const [key, value] of Object.entries(fields)) addPerfilFieldRow(key, value);
+}
+
+function collectPerfilFields() {
+  const out = {};
+  for (const row of perfil.fields?.querySelectorAll('.perfil-field') ?? []) {
+    const key = row.querySelector('.pf-key').value.trim();
+    const value = row.querySelector('.pf-value').value.trim();
+    if (key && value) out[key] = value;
+  }
+  return out;
+}
+
+async function refreshProfile() {
+  if (!perfil.address) return;
+  const data = await api('/api/profile').catch(() => null);
+  if (!data?.profile) return;
+  const p = data.profile;
+  perfil.address.value = p.address ?? '';
+  perfil.name.value = p.name ?? '';
+  perfil.language.value = p.language ?? '';
+  perfil.notes.value = p.notes ?? '';
+  renderPerfilFields(p.fields ?? {});
+  setStatus('#perfil-status', p.address || p.name ? `trato: ${p.address || p.name}` : 'sin datos', '');
+}
+
+async function submitProfile() {
+  if (!perfil.address) return;
+  setStatus('#perfil-msg', 'guardando…');
+  const body = {
+    address: perfil.address.value.trim(),
+    name: perfil.name.value.trim(),
+    language: perfil.language.value.trim(),
+    notes: perfil.notes.value.trim(),
+    fields: collectPerfilFields(),
+  };
+  const data = await api('/api/profile', { method: 'PUT', body }).catch((e) => ({ error: e.message }));
+  if (data?.error) return setStatus('#perfil-msg', data.error, 'err');
+  setStatus('#perfil-msg', 'guardado', 'ok');
+  refreshProfile();
+}
+
+perfil.add?.addEventListener('click', () => addPerfilFieldRow());
+perfil.save?.addEventListener('click', submitProfile);
+
 async function importMcp() {
   const input = $('#mcp-import');
   const value = input.value.trim();
@@ -4623,6 +5398,7 @@ function watchLifecycle() {
   // background, asi que esperar al proximo tick puede ser Mucho tiempo.
   const wake = () => {
     reconcile({ immediate: true });
+    sendPresence();
     if (!eventsController || eventsController.signal.aborted) followEvents();
   };
   document.addEventListener('visibilitychange', () => {
@@ -4657,10 +5433,13 @@ async function boot() {
   await refreshProviders();
   await loadModes();
   await loadModels();
+  await refreshTranscribe();
   await reconcile();
   await restoreTabs();
   renderAlertSignals();
   followEvents();
   watchLifecycle();
+  // Latido de presencia: mantiene frescas las pestañas abiertas (TTL del server).
+  setInterval(sendPresence, 30000);
 }
 boot();