@danieltmn/tamnora 0.9.1 → 0.9.2

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

@@ -213,7 +213,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) =>
@@ -461,6 +461,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();
 }
 
@@ -1476,8 +1484,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 +1780,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) {
@@ -2419,6 +2440,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];
+const REC_COUNT_STEP_MS = 900;
+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');
@@ -2520,7 +2900,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;
@@ -2734,16 +3116,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 +3549,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 +3562,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 +3841,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 +3860,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;
@@ -3535,9 +3939,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 +4008,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 +4177,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 +5262,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 +5297,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();