@danieltmn/tamnora 0.19.0 → 0.20.1

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

@@ -465,7 +465,9 @@ async function loadModes() {
 async function setMode(id, { persist = true } = {}) {
   if (![...modeSelect.options].some((o) => o.value === id)) return;
   modeSelect.value = id;
-  if (persist) await api('/api/settings', { method: 'PUT', body: { mode: id } }).catch(() => null);
+  if (persist) await persistAgent({ mode: id });
+  // Modo Voz = manos libres (conversación); al salir, se apaga.
+  setHandsFree(id === 'voice');
   updateStatus();
 }
 
@@ -499,16 +501,26 @@ function renderCwdPill() {
   if (cwdPill) cwdPill.title = state.cwd || 'sin carpeta de trabajo';
 }
 
-// El pill de permisos resume modo + auto-aprobación en uno de tres niveles
-// estilo Codex: Read Only, Workspace Write y Full access.
+// El pill de permisos resume modo + auto-aprobación en un control estilo Codex:
+// Read Only, Workspace Write, Full access y Voz (notas .md/.json).
 function renderModePill() {
   const plan = modeSelect.value === 'plan';
-  const full = !plan && Boolean(yesInput?.checked);
-  if (modePillLabel) modePillLabel.textContent = plan ? 'Read Only' : full ? 'Full access' : 'Workspace Write';
+  const voice = modeSelect.value === 'voice';
+  const full = !plan && !voice && Boolean(yesInput?.checked);
+  if (modePillLabel) {
+    modePillLabel.textContent = voice ? 'Voz' : plan ? 'Read Only' : full ? 'Full access' : 'Workspace Write';
+  }
   if (!modeMenu) return;
   for (const item of modeMenu.querySelectorAll('.ctrl-menu-item')) {
     const kind = item.dataset.kind;
-    const active = kind === 'read' ? plan : kind === 'full' ? full : !plan && !full;
+    const active =
+      kind === 'read'
+        ? plan
+        : kind === 'voice'
+          ? voice
+          : kind === 'full'
+            ? full
+            : !plan && !voice && !full;
     item.classList.toggle('active', active);
     item.setAttribute('aria-checked', active ? 'true' : 'false');
   }
@@ -516,8 +528,11 @@ function renderModePill() {
 
 function renderModelPill() {
   if (!modelPillLabel) return;
-  modelPillLabel.textContent = state.active.model || 'elegí un modelo';
-  if (modelPill) modelPill.title = `${state.active.provider || '—'} / ${state.active.model || '—'}`;
+  const record = state.panes.get(state.sessionId);
+  const provider = record?.provider || state.active.provider;
+  const model = record?.model || state.active.model;
+  modelPillLabel.textContent = model || 'elegí un modelo';
+  if (modelPill) modelPill.title = `${provider || '—'} / ${model || '—'}`;
 }
 
 function closeModeMenu() {
@@ -543,7 +558,7 @@ modeMenu?.addEventListener('click', async (event) => {
     if (yesInput) yesInput.checked = true;
   } else {
     if (yesInput) yesInput.checked = false;
-    await setMode(kind === 'read' ? 'plan' : 'agent');
+    await setMode(kind === 'read' ? 'plan' : kind === 'voice' ? 'voice' : 'agent');
   }
   renderModePill();
 });
@@ -773,7 +788,45 @@ async function saveSettings(patch) {
   updateStatus();
 }
 
-async function loadModels({ save = false } = {}) {
+/**
+ * Persiste el tipo de agente elegido. Con una sesion abierta, ese tipo es de la
+ * sesion (asi dos pestañas pueden correr con proveedor/modelo/modo distintos);
+ * ademas se actualiza el default global para que las sesiones nuevas hereden.
+ */
+async function persistAgent(patch) {
+  const record = state.panes.get(state.sessionId);
+  if (record) {
+    if (patch.provider) record.provider = patch.provider;
+    if (patch.model) record.model = patch.model;
+    if (patch.mode) record.mode = patch.mode;
+    api(`/api/sessions/${record.id}`, { method: 'PUT', body: patch }).catch(() => null);
+  }
+  await saveSettings(patch);
+}
+
+/** Aplica a los controles compartidos el tipo de agente guardado en una sesion. */
+async function applySessionAgent(record) {
+  if (!record) return;
+  const id = record.id;
+  const provider = record.provider || state.active.provider;
+  if (provider && [...providerSelect.options].some((o) => o.value === provider)) {
+    providerSelect.value = provider;
+  }
+  await loadModels({ prefer: record.model || null });
+  if (state.sessionId !== id) return;
+  const model = record.model || state.active.model;
+  if (model && [...modelSelect.options].some((o) => o.value === model)) modelSelect.value = model;
+  const mode = record.mode || modeSelect.value || 'agent';
+  if ([...modeSelect.options].some((o) => o.value === mode)) modeSelect.value = mode;
+  // No auto-encendemos manos libres al abrir (evita pedir el micro al recargar);
+  // si la sesión no es de voz, sí apagamos.
+  if (mode !== 'voice') setHandsFree(false);
+  updateStatus();
+  renderModePill();
+  renderModelPill();
+}
+
+async function loadModels({ save = false, prefer = null } = {}) {
   const provider = providerSelect.value;
   modelSelect.disabled = true;
   const data = await api(`/api/models?provider=${encodeURIComponent(provider)}`).catch((error) => ({
@@ -801,8 +854,9 @@ async function loadModels({ save = false } = {}) {
     if (model.context) option.dataset.context = String(model.context);
     modelSelect.appendChild(option);
   }
-  if (state.active.model && models.some((m) => m.id === state.active.model)) {
-    modelSelect.value = state.active.model;
+  const wanted = prefer || state.active.model;
+  if (wanted && models.some((m) => m.id === wanted)) {
+    modelSelect.value = wanted;
   } else {
     modelSelect.value = models[0].id;
     if (save) await saveSettings({ model: modelSelect.value });
@@ -813,10 +867,10 @@ async function loadModels({ save = false } = {}) {
 }
 
 providerSelect.addEventListener('change', async () => {
-  await saveSettings({ provider: providerSelect.value });
-  await loadModels({ save: true });
+  await loadModels({ save: false });
+  await persistAgent({ provider: providerSelect.value, model: modelSelect.value || undefined });
 });
-modelSelect.addEventListener('change', () => saveSettings({ model: modelSelect.value }));
+modelSelect.addEventListener('change', () => persistAgent({ model: modelSelect.value }));
 
 /* --- chat ---------------------------------------------------------------- */
 
@@ -1091,6 +1145,7 @@ async function deleteFrom(message) {
 const ACTIVITY = {
   thinking: { cls: 'loader-thinking', label: 'pensando…' },
   working: { cls: 'loader-working', label: 'trabajando…' },
+  listening: { cls: 'loader-working', label: 'escuchando…' },
   reconnecting: { cls: 'loader-working', label: 'reconectando…' },
   stopping: { cls: 'loader-working', label: 'deteniendo…' },
 };
@@ -1721,8 +1776,31 @@ function addAdvisorCard(container, { text, kind } = {}) {
   return card;
 }
 
+/**
+ * Marca del punto de compactación: una línea que corta el historial y, debajo,
+ * el resumen que pasa a ser el contexto del modelo. Lo de arriba sigue visible
+ * como histórico; al modelo solo le llega lo de abajo (más los mensajes nuevos).
+ */
+function addCompactCard(container, { text, label = 'contexto compactado' } = {}) {
+  if (!container) return null;
+  const card = el('div', 'compact-card');
+  card.append(el('div', 'compact-rule', label));
+  const clean = String(text ?? '').trim();
+  if (clean) {
+    const body = el('div', 'compact-text text');
+    body.innerHTML = renderMarkdown(clean);
+    card.append(body);
+  }
+  container.appendChild(card);
+  return card;
+}
+
 function renderStored(message, pane) {
   if (message.agent_id) return;
+  if (message.name === 'compact') {
+    addCompactCard(pane, { text: typeof message.content === 'string' ? message.content : '' });
+    return;
+  }
   if (message.role === 'assistant' && message.name === 'advisor') {
     addAdvisorCard(pane, {
       text: typeof message.content === 'string' ? message.content : '',
@@ -1955,6 +2033,11 @@ function registerSession(session, messages = [], tokens = { in: 0, out: 0 }, run
     el: pane,
     title: session.title || '(sin título)',
     cwd: session.cwd || '',
+    // Tipo de agente de la sesion: se aplica a los controles al abrirla y se
+    // persiste al cambiarlos. Cada pestaña puede correr con uno distinto.
+    provider: session.provider || '',
+    model: session.model || '',
+    mode: session.mode || '',
     working: false,
     tokens,
     lastTurn: { prompt: 0, completion: 0 },
@@ -2048,6 +2131,7 @@ function activateSession(id) {
   auditStatus(record);
   updateStatus();
   renderTokens();
+  applySessionAgent(record);
   renderQueue(id);
   renderTabs();
   refreshSessions();
@@ -2610,6 +2694,9 @@ async function startTurn(sessionKey, pane, input, images, opts = {}) {
   controllers.set(sessionKey, controller);
   setWorking(sessionKey, true);
 
+  // El tipo de agente lo manda la sesion (no los controles globales): asi dos
+  // pestañas con modelos distintos no se pisan.
+  const owner = state.panes.get(sessionKey);
   try {
     await streamPost(
       '/api/chat',
@@ -2617,9 +2704,9 @@ async function startTurn(sessionKey, pane, input, images, opts = {}) {
         input: input || '(imagen adjunta)',
         images: images.length ? images : undefined,
         sessionId: sessionKey,
-        provider: providerSelect.value || undefined,
-        model: modelSelect.value || undefined,
-        mode: modeSelect.value || undefined,
+        provider: owner?.provider || providerSelect.value || undefined,
+        model: owner?.model || modelSelect.value || undefined,
+        mode: owner?.mode || modeSelect.value || undefined,
         yes: yesInput.checked ? true : undefined,
         contextTokens: contextTokensForRequest(),
         interrupt: opts.interrupt ? true : undefined,
@@ -2755,11 +2842,12 @@ async function sendMessage() {
   if (input.startsWith('/') && !images.length) {
     const name = input.slice(1).split(/\s+/)[0].toLowerCase();
     const arg = input.slice(1 + name.length).trim();
+    // Limpiamos el input de una: hay comandos lentos (compactar, resumir) y no
+    // queremos dejar el comando escrito mientras corren.
+    chatInput.value = '';
+    onChatInputChanged();
     const outcome = await runCommand(name, arg);
-    if (!outcome || outcome.handled) {
-      chatInput.value = '';
-      return;
-    }
+    if (!outcome || outcome.handled) return;
     input = outcome.input ?? input;
   }
   if (!input && !images.length) return;
@@ -2984,7 +3072,7 @@ function encodeWav(samples, rate = 16000) {
  * `stop()` espera la cola antes de cortar. La usan el micrófono del chat y el
  * "probar" de Ajustes.
  */
-function createRecording() {
+function createRecording({ silenceMs = 0, noSpeechMs = 0, maxMs = 0, speechThreshold = 0.02 } = {}) {
   let resolveBlob;
   const done = new Promise((resolve) => {
     resolveBlob = resolve;
@@ -2996,9 +3084,15 @@ function createRecording() {
   let sink = null;
   let stopping = false;
   let started = false;
+  let startedAt = 0;
+  let hasSpeech = false;
+  let lastLoudAt = 0;
+  let watchdog = null;
   const chunks = [];
 
   async function cleanup() {
+    if (watchdog) clearInterval(watchdog);
+    watchdog = null;
     try {
       processor?.disconnect();
     } catch {
@@ -3022,6 +3116,37 @@ function createRecording() {
     stream?.getTracks?.().forEach((track) => track.stop());
   }
 
+  function stopRecording() {
+    if (stopping || !started) return;
+    stopping = true;
+    if (watchdog) clearInterval(watchdog);
+    watchdog = null;
+    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);
+  }
+
+  // Manos libres: corta solo por silencio (tras haber hablado), si no hubo voz en
+  // `noSpeechMs` o al llegar a `maxMs`. Sin estas opciones no interviene.
+  function startWatchdog() {
+    if (!silenceMs && !noSpeechMs && !maxMs) return;
+    watchdog = setInterval(() => {
+      if (stopping || !started) return;
+      const now = Date.now();
+      if (maxMs && now - startedAt >= maxMs) return stopRecording();
+      if (!silenceMs) return;
+      if (!hasSpeech) {
+        if (noSpeechMs && now - startedAt >= noSpeechMs) stopRecording();
+        return;
+      }
+      if (now - lastLoudAt >= silenceMs) stopRecording();
+    }, 150);
+  }
+
   return {
     async start() {
       const Ctx = window.AudioContext || window.webkitAudioContext;
@@ -3034,7 +3159,16 @@ function createRecording() {
       source = audioCtx.createMediaStreamSource(stream);
       processor = audioCtx.createScriptProcessor(4096, 1, 1);
       processor.onaudioprocess = (event) => {
-        chunks.push(new Float32Array(event.inputBuffer.getChannelData(0)));
+        const frame = event.inputBuffer.getChannelData(0);
+        chunks.push(new Float32Array(frame));
+        if (!silenceMs) return;
+        let sum = 0;
+        for (let i = 0; i < frame.length; i += 2) sum += frame[i] * frame[i];
+        const rms = Math.sqrt(sum / (frame.length / 2));
+        if (rms >= speechThreshold) {
+          hasSpeech = true;
+          lastLoudAt = Date.now();
+        }
       };
       // El procesador solo corre si llega al destination: un gain en 0 evita el eco.
       sink = audioCtx.createGain();
@@ -3043,21 +3177,13 @@ function createRecording() {
       processor.connect(sink);
       sink.connect(audioCtx.destination);
       started = true;
+      startedAt = Date.now();
+      startWatchdog();
     },
     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);
-    },
+    stop: stopRecording,
     done,
   };
 }
@@ -3180,6 +3306,8 @@ function startBrowserMic() {
 
 async function toggleMic() {
   if (!micBtn) return;
+  // Con manos libres el micro lo maneja el loop: no dejamos que se pisen.
+  if (handsFree.active) return;
   if (browserDictation) {
     browserDictation.stop();
     return;
@@ -3229,6 +3357,155 @@ async function toggleMic() {
 
 micBtn?.addEventListener('click', toggleMic);
 
+/* --- manos libres: conversación por voz ----------------------------------- */
+
+const HANDS_FREE_SILENCE_MS = 1400; // silencio que cierra tu turno
+const HANDS_FREE_NOSPEECH_MS = 8000; // si no hablás, vuelve a intentar
+const HANDS_FREE_MAX_MS = 45000; // tope duro de una intervención
+
+const handsFreeBtn = $('#hands-free-btn');
+const handsFree = { active: false, phase: 'idle', token: 0 };
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+function renderHandsFree() {
+  if (handsFreeBtn) {
+    handsFreeBtn.classList.toggle('hands-free-active', handsFree.active);
+    handsFreeBtn.classList.toggle('listening', handsFree.active && handsFree.phase === 'listening');
+    handsFreeBtn.setAttribute('aria-pressed', handsFree.active ? 'true' : 'false');
+    handsFreeBtn.title = handsFree.active
+      ? 'manos libres: activado (tocá para desactivar)'
+      : 'manos libres: conversación por voz';
+  }
+  if (handsFree.active && handsFree.phase === 'listening') renderFooterActivity('listening');
+  else if (handsFree.active && handsFree.phase === 'thinking') renderFooterActivity('thinking');
+  else if (handsFree.active) renderFooterActivity(null);
+}
+
+function setHandsFreePhase(phase) {
+  handsFree.phase = phase;
+  renderHandsFree();
+}
+
+function setHandsFree(on) {
+  const next = Boolean(on);
+  if (handsFree.active === next) return;
+  handsFree.active = next;
+  handsFree.token += 1;
+  if (next) {
+    // Cortamos un dictado manual en curso para no pisarlo.
+    composerRecording?.stop();
+    setHandsFreePhase('idle');
+    renderHandsFree();
+    runHandsFree(handsFree.token).catch(() => {});
+  } else {
+    // Cortamos lo que esté grabando para no dejar el micro abierto.
+    handsFree.recording?.stop();
+    handsFree.recording = null;
+    browserDictation?.stop();
+    setHandsFreePhase('idle');
+    renderHandsFree();
+  }
+}
+
+function toggleHandsFree() {
+  setHandsFree(!handsFree.active);
+}
+
+handsFreeBtn?.addEventListener('click', toggleHandsFree);
+
+/** Una escucha de manos libres: graba hasta el silencio y devuelve el texto. */
+async function handsFreeListen(token) {
+  if (transcribeConfig.mode === 'browser') {
+    const text = await new Promise((resolve, reject) => {
+      let combined = '';
+      let dictation;
+      const finish = () => {
+        if (browserDictation === dictation) browserDictation = null;
+        resolve(combined.trim());
+      };
+      try {
+        dictation = createBrowserDictation({
+          language: transcribeConfig.language,
+          onText: (_final, all) => {
+            combined = all;
+          },
+          onEnd: finish,
+          onError: reject,
+        });
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      browserDictation = dictation;
+      dictation.start();
+      setTimeout(() => {
+        if (browserDictation === dictation) dictation.stop();
+      }, HANDS_FREE_MAX_MS);
+    });
+    return token === handsFree.token ? text : '';
+  }
+
+  const rec = createRecording({
+    silenceMs: HANDS_FREE_SILENCE_MS,
+    noSpeechMs: HANDS_FREE_NOSPEECH_MS,
+    maxMs: HANDS_FREE_MAX_MS,
+  });
+  await rec.start();
+  if (token !== handsFree.token) {
+    rec.stop();
+    return '';
+  }
+  handsFree.recording = rec;
+  setHandsFreePhase('listening');
+  const blob = await rec.done;
+  handsFree.recording = null;
+  if (token !== handsFree.token || !blob.size) return '';
+  setHandsFreePhase('thinking');
+  try {
+    return await transcribirBlob(blob);
+  } catch (error) {
+    toast(`No pude transcribir: ${error.message}`);
+    return '';
+  }
+}
+
+/** Loop conversacional: escuchar → enviar → esperar la voz → repetir. */
+async function runHandsFree(token) {
+  while (handsFree.active && token === handsFree.token) {
+    if (!state.sessionId) {
+      toast('Manos libres necesita una sesión abierta.');
+      setHandsFree(false);
+      return;
+    }
+    if (state.panes.get(state.sessionId)?.working) {
+      await sleep(400);
+      continue;
+    }
+
+    let text = '';
+    try {
+      text = await handsFreeListen(token);
+    } catch (error) {
+      if (token !== handsFree.token) return;
+      toast(`Manos libres: ${error.message}`);
+      setHandsFree(false);
+      return;
+    }
+    if (!handsFree.active || token !== handsFree.token) return;
+    if (!text) continue; // silencio o no se entendió: otra vuelta
+
+    chatInput.value = text;
+    onChatInputChanged();
+    setHandsFreePhase('thinking');
+    await sendMessage();
+    if (!handsFree.active || token !== handsFree.token) return;
+    // Esperamos a que termine de hablar antes de volver a escuchar (evita el eco).
+    await whenAudioIdle();
+    await sleep(250);
+  }
+}
+
 /* --- image attachments ---------------------------------------------------- */
 
 const attachInput = $('#image-input');
@@ -3465,13 +3742,18 @@ async function runCommand(name, arg) {
     }
     case 'compact': {
       if (!state.sessionId) return needSession();
-      notify('Compactando la conversación…');
+      toast('Compactando la conversación…');
       const out = await api(`/api/sessions/${state.sessionId}/compact`, { method: 'POST' }).catch((error) => ({
         error: error.message,
       }));
-      clear(activePane);
-      if (out.error) notify(`No se pudo compactar: ${out.error}`, 'notice err');
-      else notify(`Contexto compactado. Resumen guardado:\n\n${out.summary}`);
+      if (out.error) {
+        notify(`No se pudo compactar: ${out.error}`, 'notice err');
+        return { handled: true };
+      }
+      // No borramos el pane: el historial queda a la vista y marcamos el corte
+      // con la línea + el resumen que ahora ve el modelo.
+      addCompactCard(activePane, { text: out.summary });
+      scrollMessages();
       refreshSessions();
       return { handled: true };
     }
@@ -3736,7 +4018,17 @@ async function loadFolders(target = '') {
 }
 
 async function createSessionIn(cwd, { title = 'Nueva sesión' } = {}) {
-  const created = await api('/api/sessions', { method: 'POST', body: { title, cwd } }).catch((error) => ({
+  const current = state.panes.get(state.sessionId);
+  const created = await api('/api/sessions', {
+    method: 'POST',
+    body: {
+      title,
+      cwd,
+      provider: current?.provider || providerSelect.value || undefined,
+      model: current?.model || modelSelect.value || undefined,
+      mode: current?.mode || modeSelect.value || undefined,
+    },
+  }).catch((error) => ({
     error: error.message,
   }));
   if (created?.error) return created;
@@ -3866,6 +4158,8 @@ async function refreshProviders() {
   state.active = data.active;
   syncTopbar();
   renderProviderList();
+  const record = state.panes.get(state.sessionId);
+  if (record) await applySessionAgent(record);
 }
 
 function isConfigured(p) {
@@ -3881,7 +4175,8 @@ function syncTopbar() {
     option.textContent = p.label && p.label !== p.id ? `${p.label} (${p.id})` : p.id;
     providerSelect.appendChild(option);
   }
-  const active = state.active.provider;
+  const record = state.panes.get(state.sessionId);
+  const active = record?.provider || state.active.provider;
   if (active && !configured.some((p) => p.id === active)) {
     const current = state.providers.find((p) => p.id === active);
     const option = document.createElement('option');
@@ -3930,8 +4225,9 @@ function renderProviderList() {
 }
 
 async function useProvider(id) {
-  await saveSettings({ provider: id });
-  await loadModels({ save: true });
+  providerSelect.value = id;
+  await loadModels({ save: false });
+  await persistAgent({ provider: id, model: modelSelect.value || undefined });
   await refreshProviders();
 }
 
@@ -4661,6 +4957,18 @@ const voz = {
  */
 const ap = { el: $('#audio-player'), audio: new Audio(), queue: [], current: null, ready: false };
 
+// Avisa cuando el reproductor queda en silencio (cola vacia). Lo usa manos libres
+// para saber cuando el asistente termino de hablar y volver a escuchar.
+const audioIdleWaiters = [];
+function whenAudioIdle() {
+  if (!ap.current && !ap.queue.length) return Promise.resolve();
+  return new Promise((resolve) => audioIdleWaiters.push(resolve));
+}
+function notifyAudioIdle() {
+  if (ap.current || ap.queue.length) return;
+  for (const resolve of audioIdleWaiters.splice(0)) resolve();
+}
+
 function ensurePlayer() {
   if (!ap.el || ap.ready) return;
   ap.ready = true;
@@ -4750,6 +5058,7 @@ function playNextAudio() {
   if (!item) {
     ap.current = null;
     renderAudio();
+    notifyAudioIdle();
     return;
   }
   if (item.maxAgeMs && Date.now() - item.createdAt > item.maxAgeMs) {
@@ -4796,6 +5105,7 @@ function stopAudio() {
   ap.audio.load();
   if (ap.barEl) ap.barEl.style.width = '0%';
   renderAudio();
+  notifyAudioIdle();
 }
 
 function renderAudio() {
@@ -4821,16 +5131,32 @@ function reproducirVoz(frase, { voice, rate, pitch, label, maxAgeMs } = {}) {
  * 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, { label = 'narrando', maxAgeMs = 45000 } = {}) {
+function hablar(texto, { label = 'narrando', maxAgeMs = 45000, force = false } = {}) {
   const frase = String(texto ?? '').trim();
-  if (!frase || !voz.settings.enabled) return;
+  if (!frase || (!voz.settings.enabled && !force)) return;
   reproducirVoz(frase, { label, maxAgeMs }).catch(() => {});
 }
 
 /** Habla el progreso de un turno EN VIVO: el replay de una reconexion no habla. */
 function narrar(event, data, turn) {
   if (!turn?.live) return;
+  const handsFreeOn = handsFree.active;
   const { enabled, announce } = voz.settings;
+  if (!enabled && !handsFreeOn) return;
+  // Manos libres: conversacion, sin narracion de arranque/herramientas; lee la
+  // respuesta final (y el asesor) aunque la narracion este apagada en Ajustes.
+  if (handsFreeOn) {
+    if (event === 'advice') {
+      if (data?.say) hablar(data.say, { label: 'asesor', maxAgeMs: 0, force: true });
+    } else if (event === 'done') {
+      const spoken = speechText(data?.content);
+      if (spoken) hablar(spoken, { label: 'respuesta', maxAgeMs: 0, force: true });
+      else if (data?.say) hablar(data.say, { maxAgeMs: 0, force: true });
+    } else if ((event === 'aborted' || event === 'error') && data?.say) {
+      hablar(data.say, { maxAgeMs: 0, force: true });
+    }
+    return;
+  }
   if (!enabled) return;
   if (event === 'start' && announce.start) hablar(data?.say);
   else if (event === 'tool_call' && announce.tools) hablar(data?.say);
@@ -5162,8 +5488,7 @@ async function testAsesor() {
   setStatus('#asesor-msg', 'consultando…');
   const data = await api('/api/advisor/test', { method: 'POST' }).catch((e) => ({ error: e.message }));
   if (data?.error) return setStatus('#asesor-msg', data.error, 'err');
-  const partes = [data.speak ? data.text : '', data.summary ? `resumen: ${data.summary}` : ''].filter(Boolean);
-  setStatus('#asesor-msg', partes.length ? partes.join(' · ') : '(no diría nada en este caso)', 'ok');
+  setStatus('#asesor-msg', data?.speak && data.text ? data.text : '(no diría nada en este caso)', 'ok');
 }
 
 /* --- ajustes: perfil del usuario ------------------------------------------ */
@@ -6768,6 +7093,10 @@ async function boot() {
   await loadModes();
   await loadModels();
   await refreshTranscribe();
+  // La config de voz se carga al boot (sin `await`, para no bloquear con el
+  // fetch del catálogo de voces): si no, `voz.settings.enabled` queda en el
+  // default `false` hasta abrir Ajustes y la narración no arranca al entrar.
+  refreshVoz();
   await reconcile();
   await restoreTabs();
   renderAlertSignals();