@nac3/forge-cli 0.2.0-alpha.3 → 0.2.0-alpha.30

package/dist/chat/panel.js

@@ -237,6 +237,27 @@ body {
 }
 .header .actions button:hover { background: rgba(255,255,255,0.2); }
 
+/* alpha.29 -- settings dropdown */
+.settings-panel {
+  position: absolute; top: 56px; right: 16px; z-index: 50;
+  background: var(--bg-1); border: 1px solid rgba(255,255,255,0.15);
+  border-radius: 6px; padding: 10px; min-width: 280px;
+  box-shadow: 0 8px 24px rgba(0,0,0,0.4);
+  display: flex; flex-direction: column; gap: 8px;
+}
+.settings-panel.hidden { display: none; }
+.settings-panel .set-row {
+  display: flex; justify-content: space-between; align-items: center;
+  gap: 12px; font-size: 12px;
+}
+.settings-panel .set-lbl { color: var(--ink-2); font-weight: 500; }
+.settings-panel .set-btn {
+  background: var(--bg-2); color: var(--ink); border: 1px solid rgba(255,255,255,0.15);
+  padding: 4px 8px; border-radius: 4px; font-size: 11px; cursor: pointer;
+}
+.settings-panel .set-btn:hover { background: rgba(255,255,255,0.1); }
+.settings-panel .set-status { font-size: 11px; color: var(--ink-2); }
+
 /* ---- chat stream ---- */
 .stream { flex: 1; overflow-y: auto; padding: 12px; display: flex; flex-direction: column; gap: 10px; }
 .empty { color: var(--ink-muted); text-align: center; padding: 32px 16px; }
@@ -453,12 +474,29 @@ body {
         <div class="t"><span class="name">Yujin Forge</span><span class="proj" id="proj-full" data-nac-id="yujin.panel.project-full"></span></div>
       </div>
       <div class="actions">
+        <button class="settings-btn" data-settings-toggle aria-label="ajustes" title="Ajustes (modo voz, STT, TTS, claves)">⚙</button>
         <button class="lang-btn" data-lang-open aria-label="${escapeHtml(tr.languageButton)}" title="${escapeHtml(tr.languageButton)}">🌐</button>
         <button class="keys-btn" data-vault-open aria-label="${escapeHtml(tr.keysButton)}" title="${escapeHtml(tr.keysButton)}">${escapeHtml(tr.keysButton)}</button>
         <button id="full-mini" data-nac-id="yujin.panel.full-to-mini" aria-label="${escapeHtml(tr.minimiseButton)}" title="${escapeHtml(tr.minimiseButton)}">▭</button>
         <button id="full-close" data-nac-id="yujin.panel.full-close" aria-label="${escapeHtml(tr.closeButton)}" title="${escapeHtml(tr.closeButton)}">✕</button>
       </div>
     </div>
+    <!-- alpha.29: settings dropdown in topbar (voice mode, STT
+         provider, TTS voice, key status). Toggle via the cog. -->
+    <div id="yf-settings" class="hidden settings-panel">
+      <div class="set-row"><span class="set-lbl">Modo voz</span>
+        <button type="button" data-voice-mode-btn class="set-btn">modo mic</button>
+      </div>
+      <div class="set-row"><span class="set-lbl">STT</span>
+        <button type="button" data-stt-provider-btn class="set-btn">STT navegador</button>
+      </div>
+      <div class="set-row"><span class="set-lbl">Voz TTS</span>
+        <button type="button" data-tts-voice-btn class="set-btn">es-ES-Neural2-A (Lucia)</button>
+      </div>
+      <div class="set-row"><span class="set-lbl">Claves</span>
+        <span class="set-status" id="set-keys-status">cargando...</span>
+      </div>
+    </div>
     <div class="body">
       <div class="chat-col">
         <div id="stream-full" data-nac-id="yujin.chat.stream-full" class="stream"></div>
@@ -557,6 +595,19 @@ function renderMd(src) {
   out = out.replace(/\`([^\`]+)\`/g, '<code>$1</code>');
   out = out.replace(/\\*\\*([^*]+)\\*\\*/g, '<strong>$1</strong>');
   out = out.replace(/\\n/g, '<br>');
+  /* Layer A.2 -- linkify file paths so the minority who wants to
+   *  read code can click straight into their editor. Matches:
+   *    src/foo/bar.ts
+   *    tests/foo/bar.test.ts
+   *    docs/SPEC.md
+   *    packages/*\/src/*.ts
+   *  Optionally with :line:col suffix. The result is a
+   *  data-fpath link that the bound click handler resolves via
+   *  /api/forge/open-in-editor. */
+  out = out.replace(
+    /(?<![\\w/])((?:src|tests|docs|packages|apps|scripts)\\/[\\w./-]+(?:\\.[\\w]+)(?::\\d+(?::\\d+)?)?)/g,
+    '<a class="fpath" data-fpath="$1" href="#" title="Abrir en mi editor">$1</a>',
+  );
   return out;
 }
 
@@ -577,6 +628,37 @@ function renderStream() {
         else div.textContent = m.content;
         target.appendChild(div);
       }
+      /* Layer A.2 -- bind click handlers on .fpath links to call
+         the open-in-editor endpoint + post a trust event. Idempotent
+         re-binding is safe because we replace innerHTML each turn. */
+      target.querySelectorAll('a.fpath').forEach(function (a) {
+        a.addEventListener('click', async function (ev) {
+          ev.preventDefault();
+          const p = a.getAttribute('data-fpath');
+          if (!p) return;
+          /* Strip trailing :line:col -- the editor opens at the file. */
+          const cleanPath = p.replace(/:\\d+(?::\\d+)?$/, '');
+          try {
+            const r = await fetch('/api/forge/open-in-editor', {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ path: cleanPath }),
+            });
+            const body = await r.json();
+            if (!body.ok && body.path) {
+              navigator.clipboard.writeText(body.path).catch(function () {});
+              alert('No editor en PATH. Copie el path: ' + body.path);
+            }
+            fetch('/api/forge/trust-event', {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ kind: 'editor_open' }),
+            }).catch(function () {});
+          } catch (e) {
+            /* network down -- ignore, the link is best-effort */
+          }
+        });
+      });
     }
     if (state.busy) {
       const d = document.createElement('div');
@@ -920,10 +1002,142 @@ async function vaultTest(slot, button) {
 }
 
 /* ---- Voice integration (V1.6) ---- */
-const TTS_TOGGLE_KEY = 'yf-tts-replies-on';
+const TTS_TOGGLE_KEY  = 'yf-tts-replies-on';
+const VOICE_MODE_KEY  = 'yf-voice-mode';   /* 2026-05-31 -- 'mic' | 'auricular' */
 let mediaRecorder = null;
 let recordChunks = [];
 let recordingPanelButton = null;
+/* 2026-05-31 half-duplex: when the user's last turn came through
+   the mic (not the keyboard), auto-reopen the mic after TTS
+   finishes -- so a conversation flows without push-to-talk every
+   turn. If they typed, do NOT auto-open. Only applies in
+   'auricular' mode -- in 'mic' (push-to-talk) the user stays
+   in control. */
+let _lastInputWasVoice = false;
+let _lastVoiceButton = null;
+
+/* STT provider selector (alpha.28+). Default 'browser' = Web
+ * Speech API (instant, free, native es-AR). 'google' = our
+ * existing MediaRecorder + Google Cloud STT REST path. 'whisper'
+ * = server routes to Whisper API.
+ * Per Pablo (2026-05-31): "el default queda el del navegador,
+ * pero quiero poder elegir Google u otro". */
+const STT_PROVIDER_KEY = 'yf-stt-provider';
+function sttProvider() {
+  try {
+    const v = localStorage.getItem(STT_PROVIDER_KEY);
+    if (v === 'google' || v === 'whisper' || v === 'browser') return v;
+  } catch (_) {}
+  return 'browser';
+}
+function setSttProvider(p) {
+  try { localStorage.setItem(STT_PROVIDER_KEY, p); } catch (_) {}
+  updateSttProviderButtons();
+}
+function updateSttProviderButtons() {
+  const p = sttProvider();
+  const label = p === 'browser' ? 'STT navegador'
+              : p === 'google'  ? 'STT Google'
+              : 'STT Whisper';
+  document.querySelectorAll('[data-stt-provider-btn]').forEach((b) => {
+    b.textContent = label;
+    b.title = 'Click para alternar entre navegador (rapido + es-AR nativo + gratis), '
+      + 'Google Cloud STT (server-side, BYOK) o Whisper (server-side, BYOK).';
+  });
+}
+function cycleSttProvider() {
+  const order = ['browser', 'google', 'whisper'];
+  const i = order.indexOf(sttProvider());
+  setSttProvider(order[(i + 1) % order.length]);
+}
+
+/* alpha.29 -- TTS voice selection. Pablo: voz default debe ser
+ * la que articule mejor las "s". es-ES (Spain) Neural2 voices
+ * pronunciate finales claros vs es-US (Latin) que se las traga.
+ * Also shows the active persona name in the settings panel. */
+const TTS_VOICE_KEY = 'yf-tts-voice';
+const TTS_VOICES = [
+  { id: 'es-ES-Neural2-A', persona: 'Lucia (ES)',  gender: 'F', lang: 'es-ES' },
+  { id: 'es-ES-Neural2-B', persona: 'Javier (ES)', gender: 'M', lang: 'es-ES' },
+  { id: 'es-ES-Neural2-C', persona: 'Marta (ES)',  gender: 'F', lang: 'es-ES' },
+  { id: 'es-ES-Neural2-D', persona: 'Carlos (ES)', gender: 'M', lang: 'es-ES' },
+  { id: 'es-US-Neural2-A', persona: 'Sofia (LATAM)', gender: 'F', lang: 'es-US' },
+  { id: 'es-US-Neural2-B', persona: 'Mateo (LATAM)', gender: 'M', lang: 'es-US' },
+  { id: 'en-US-Neural2-C', persona: 'Emma (EN)',  gender: 'F', lang: 'en-US' },
+];
+function ttsVoice() {
+  try {
+    const v = localStorage.getItem(TTS_VOICE_KEY);
+    if (v && TTS_VOICES.find((x) => x.id === v)) return v;
+  } catch (_) {}
+  return 'es-ES-Neural2-A';   /* default: Lucia ES -- articula las "s" */
+}
+function setTtsVoice(id) {
+  try { localStorage.setItem(TTS_VOICE_KEY, id); } catch (_) {}
+  updateTtsVoiceButtons();
+}
+function cycleTtsVoice() {
+  const cur = ttsVoice();
+  const i = TTS_VOICES.findIndex((v) => v.id === cur);
+  const nxt = TTS_VOICES[(i + 1) % TTS_VOICES.length];
+  setTtsVoice(nxt.id);
+}
+function updateTtsVoiceButtons() {
+  const cur = ttsVoice();
+  const meta = TTS_VOICES.find((v) => v.id === cur) || TTS_VOICES[0];
+  document.querySelectorAll('[data-tts-voice-btn]').forEach((b) => {
+    b.textContent = meta.id + ' (' + meta.persona + ')';
+    b.title = 'Click para cambiar de voz. Persona actual: ' + meta.persona
+      + ' (' + meta.gender + ') -- lengua ' + meta.lang;
+  });
+}
+
+/* Keys status fetcher: GETs /api/forge/keys-status (new endpoint)
+ * and renders a short summary in the settings dropdown. */
+async function refreshKeysStatus() {
+  const el = document.getElementById('set-keys-status');
+  if (!el) return;
+  el.textContent = 'cargando...';
+  try {
+    const r = await fetch('/api/forge/keys-status');
+    const data = await r.json();
+    if (!r.ok || !data.ok) {
+      el.textContent = 'error: ' + (data.error || r.status);
+      return;
+    }
+    const k = data.keys || {};
+    const parts = [];
+    parts.push((k.anthropic ? '✓' : '✗') + ' brain');
+    parts.push((k.google_stt ? '✓' : '✗') + ' stt');
+    parts.push((k.google_tts || k.elevenlabs ? '✓' : '✗') + ' tts');
+    parts.push((k.license_paid ? '✓' : '✗') + ' license');
+    el.textContent = parts.join(' · ');
+  } catch (err) {
+    el.textContent = 'error fetching: ' + (err && err.message ? err.message : 'unknown');
+  }
+}
+
+function voiceMode() {
+  /* Default 'mic' = push-to-talk (preserves pre-2026-05-31 UX). */
+  try {
+    const v = localStorage.getItem(VOICE_MODE_KEY);
+    return v === 'auricular' ? 'auricular' : 'mic';
+  } catch (_) { return 'mic'; }
+}
+function setVoiceMode(mode) {
+  try { localStorage.setItem(VOICE_MODE_KEY, mode === 'auricular' ? 'auricular' : 'mic'); } catch (_) {}
+  updateVoiceModeButtons();
+}
+function updateVoiceModeButtons() {
+  const mode = voiceMode();
+  document.querySelectorAll('[data-voice-mode-btn]').forEach((b) => {
+    b.setAttribute('aria-pressed', String(mode === 'auricular'));
+    b.textContent = mode === 'auricular' ? 'modo auricular' : 'modo mic';
+    b.title = mode === 'auricular'
+      ? 'Manos libres -- el mic se reabre solo despues de que Yujin habla. Click para cambiar a push-to-talk.'
+      : 'Push-to-talk -- apretas para hablar, soltas. Click para activar manos libres (auricular).';
+  });
+}
 
 function ttsRepliesEnabled() {
   try {
@@ -955,12 +1169,57 @@ function setMicButtonsState(state) {
   });
 }
 
+/* 2026-05-31 -- Web Speech API path (browser-native STT).
+   Mirrors the Pilot CRM implementation. When the browser
+   exposes SpeechRecognition / webkitSpeechRecognition we use
+   IT instead of MediaRecorder + Google Cloud STT REST. Why:
+     - Instant (no server round-trip).
+     - es-AR + es-CL + es-PE + every regional Spanish locale
+       supported natively (no es-US mapping needed).
+     - Free (the browser routes to Google STT for free under
+       Chrome/Edge; Firefox uses its own backend).
+     - Interim results (text appears as you speak).
+   The Google Cloud STT path stays as a fallback for callers
+   that explicitly want server-side recognition (e.g. audio
+   pre-recorded files via the yf CLI). */
+let _webSpeechRecognition = null;
+
+function _webSpeechAvailable() {
+  return typeof window !== 'undefined'
+    && (typeof window.SpeechRecognition !== 'undefined'
+        || typeof window.webkitSpeechRecognition !== 'undefined');
+}
+
+function _webSpeechLangFromDoc() {
+  const raw = (document.documentElement.lang
+    || navigator.language || 'es-AR').toString();
+  /* Web Speech API takes the locale as-is, including es-AR.
+     No normalisation needed. */
+  return raw;
+}
+
 async function micToggle(button) {
+  if (_webSpeechRecognition) {
+    /* Already listening -> stop. */
+    try { _webSpeechRecognition.stop(); } catch (_) {}
+    return;
+  }
   if (mediaRecorder && mediaRecorder.state === 'recording') {
     /* Stop -> onstop handler dispatches transcription. */
     mediaRecorder.stop();
     return;
   }
+  /* Provider-aware dispatch. Default 'browser' uses Web Speech
+     API when available. 'google' / 'whisper' route through the
+     server-side MediaRecorder + REST path. */
+  const provider = sttProvider();
+  if (provider === 'browser' && _webSpeechAvailable()) {
+    return _micToggleWebSpeech(button);
+  }
+  if (provider === 'browser' && !_webSpeechAvailable()) {
+    setStatus('Browser STT unavailable; using server-side fallback.');
+    /* Fall through to MediaRecorder path. */
+  }
   if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
     setStatus('Your browser does not support microphone access.', true);
     return;
@@ -989,7 +1248,85 @@ async function micToggle(button) {
     mediaRecorder.ondataavailable = (e) => {
       if (e.data && e.data.size > 0) recordChunks.push(e.data);
     };
+
+    /* alpha.29 -- Real VAD for the MediaRecorder path (Google /
+       Whisper STT providers). Tap the same audio stream that
+       MediaRecorder is consuming via AudioContext + AnalyserNode,
+       compute time-domain RMS every 50ms. State machine:
+         - 'pre-voice': waiting for the first sustained speech.
+         - 'voiced':   speech detected; resets silence countdown
+                       on every chunk above threshold.
+         - 'closing':  N ms of sustained silence -> stop().
+       Per Pablo: needs to close as soon as silence falls, just
+       like Web Speech does natively. */
+    const VAD_RMS_THRESHOLD    = 0.02;  /* normalised 0..1 */
+    const VAD_SILENCE_MS       = 800;
+    const VAD_MIN_VOICED_MS    = 200;
+    let _vadCtx = null;
+    let _vadAnalyser = null;
+    let _vadSrc = null;
+    let _vadTimer = null;
+    let _vadVoicedStart = 0;
+    let _vadLastVoicedAt = 0;
+    let _vadHasVoiced = false;
+    try {
+      const AC = (window.AudioContext || window.webkitAudioContext);
+      if (AC) {
+        _vadCtx = new AC();
+        _vadSrc = _vadCtx.createMediaStreamSource(stream);
+        _vadAnalyser = _vadCtx.createAnalyser();
+        _vadAnalyser.fftSize = 512;
+        _vadSrc.connect(_vadAnalyser);
+        const buf = new Float32Array(_vadAnalyser.fftSize);
+        _vadTimer = setInterval(() => {
+          if (!mediaRecorder || mediaRecorder.state !== 'recording') return;
+          _vadAnalyser.getFloatTimeDomainData(buf);
+          let sumsq = 0;
+          for (let i = 0; i < buf.length; i++) sumsq += buf[i] * buf[i];
+          const rms = Math.sqrt(sumsq / buf.length);
+          const now = Date.now();
+          if (rms > VAD_RMS_THRESHOLD) {
+            if (!_vadHasVoiced) _vadVoicedStart = now;
+            _vadHasVoiced = (now - _vadVoicedStart) >= VAD_MIN_VOICED_MS || _vadHasVoiced;
+            _vadLastVoicedAt = now;
+          } else if (_vadHasVoiced && (now - _vadLastVoicedAt) > VAD_SILENCE_MS) {
+            /* Voice detected earlier, then sustained silence: close. */
+            try { mediaRecorder.stop(); } catch (_) {}
+          }
+        }, 50);
+      }
+    } catch (_) { /* VAD unavailable; mic still works manually */ }
+    /* Cleanup hook -- onstop also clears the VAD interval. */
+    const _vadCleanup = () => {
+      if (_vadTimer) { clearInterval(_vadTimer); _vadTimer = null; }
+      try { if (_vadSrc) _vadSrc.disconnect(); } catch (_) {}
+      try { if (_vadCtx && _vadCtx.state !== 'closed') _vadCtx.close(); } catch (_) {}
+    };
+    /* 2026-05-31 -- Google STT sync API rejects audio > 1 min
+       with HTTP 400 "Sync input too long". Cap the recording
+       at 55s (5s safety margin) + visual countdown so the user
+       knows + auto-stop when reached. To go past this we would
+       need to upload to GCS + use LongRunningRecognize; out of
+       scope today. */
+    const MAX_RECORD_MS = 55_000;
+    const stopAt = Date.now() + MAX_RECORD_MS;
+    const countdown = setInterval(() => {
+      if (!mediaRecorder || mediaRecorder.state !== 'recording') {
+        clearInterval(countdown);
+        return;
+      }
+      const secLeft = Math.max(0, Math.ceil((stopAt - Date.now()) / 1000));
+      if (secLeft <= 10) {
+        setStatus('Recording... auto-stop in ' + secLeft + 's');
+      }
+      if (secLeft <= 0) {
+        clearInterval(countdown);
+        try { mediaRecorder.stop(); } catch { /* ignore */ }
+        setStatus('Recording auto-stopped at 55s (Google STT 1-min limit). Try shorter.', true);
+      }
+    }, 1000);
     mediaRecorder.onstop = async () => {
+      _vadCleanup();
       stream.getTracks().forEach((t) => t.stop());
       const blob = new Blob(recordChunks, { type: mimeType || 'audio/webm' });
       mediaRecorder = null;
@@ -998,6 +1335,14 @@ async function micToggle(button) {
         setStatus('No audio captured. Try again.', true);
         return;
       }
+      /* Client-side size guard. 4 MB ~ 60s of WebM/Opus at
+         32 kbps which already trips the Google sync limit.
+         Refuse before even hitting the network. */
+      if (blob.size > 4_000_000) {
+        setMicButtonsState('idle');
+        setStatus('Audio too long (>1 min). Google STT sync limit. Try shorter.', true);
+        return;
+      }
       setMicButtonsState('processing');
       try {
         const buf = await blob.arrayBuffer();
@@ -1005,6 +1350,18 @@ async function micToggle(button) {
           'content-type': 'application/octet-stream',
           'x-audio-format': serverFormat,
         };
+        /* 2026-05-31 FIX: tell the server which language the
+           user is speaking. Without this header the Google STT
+           provider falls back to en-US, which silently mangles
+           Spanish input ("No me escucha" symptom in alpha.19).
+           Source-of-truth priority:
+             1. <html lang="..."> (set by the panel via i18n).
+             2. navigator.language (browser locale).
+             3. 'es-AR' as a last-resort default for our market. */
+        const langGuess = (document.documentElement.lang
+          || navigator.language
+          || 'es-AR').toString();
+        if (langGuess) headers['x-audio-language'] = langGuess;
         /* V1.32 -- carry the active reader doc_id so the
            matcher can resolve commands like "siguiente" /
            "buscar X" against the currently-open document. */
@@ -1026,6 +1383,11 @@ async function micToggle(button) {
           setStatus('Did not catch that -- try again.', true);
           return;
         }
+        /* Mark this turn as voice-originated so playTtsForText
+           knows to reopen the mic afterwards (half-duplex
+           conversational mode). */
+        _lastInputWasVoice = true;
+        _lastVoiceButton = recordingPanelButton;
         /* V1.32 -- if the matcher recognised a reader command,
            dispatch it directly (no Claude round-trip). Otherwise
            the transcript flows into the chat input as before. */
@@ -1093,7 +1455,7 @@ async function dispatchReaderIntent(utterance, intent) {
     }
     /* Update the active reader doc on a successful open so
        subsequent voice commands ("siguiente", etc) target it. */
-    if (intent.tool === 'forge.reader.open' && !data.is_error) {
+    if (intent.tool === 'forge_reader_open' && !data.is_error) {
       const docId = data.result && data.result.doc_id;
       if (docId) state.activeReaderDocId = String(docId);
     }
@@ -1212,10 +1574,25 @@ function splitIntoTtsChunks(text, opts) {
  *  status bar). */
 async function _fetchTtsChunk(text) {
   try {
+    /* Pass current panel language so the server can pick a voice
+     *  persona that matches (es-ES, en-US, etc). The TTS endpoint
+     *  resolves voice from { language } if no explicit voice given. */
+    const lang = (document && document.documentElement && document.documentElement.lang)
+      ? document.documentElement.lang : undefined;
+    /* 2026-05-31 -- speakingRate 1.05 for Spanish (mirror Pilot
+     *  CRM). Neural2 voices at rate 1.0 tend to swallow final
+     *  "s" in Latin-American Spanish; +5% rate makes the voice
+     *  articulate each syllable + drops the dropped-s symptom. */
+    let speed;
+    if (lang && /^es(-|$)/i.test(lang)) speed = 1.05;
+    const voiceId = ttsVoice();
+    const body = lang ? { text, language: lang } : { text };
+    if (speed) body.speed = speed;
+    if (voiceId) body.voice = voiceId;
     const r = await fetch('/api/voice/tts', {
       method: 'POST',
       headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ text }),
+      body: JSON.stringify(body),
     });
     if (!r.ok) {
       const data = await r.json().catch(() => ({}));
@@ -1311,7 +1688,7 @@ async function ingestSpecFile(file) {
     state.toolHistory.push({
       turnIndex: state.messages.length - 1,
       rounds: [{
-        tool: 'forge.spec.ingest',
+        tool: 'forge_spec_ingest',
         input: { filename: ing.filename, format: ing.format },
         display: 'parsed ' + ing.format + ': ' + (ing.title || ing.filename),
         is_error: false,
@@ -1326,24 +1703,182 @@ async function ingestSpecFile(file) {
   }
 }
 
+/** Strip markdown emphasis + decorative characters so the TTS
+ *  reads fluidly. Without this Forge's chat output (asterisks,
+ *  code ticks, dashes, emojis) was being read literally as
+ *  "asterisco asterisco". Output keeps acentos + n-tilde + open
+ *  punctuation chars -- those ARE pronounced. */
+function cleanForTts(raw) {
+  let s = String(raw || '');
+  /* Code fences first (greedy, capture content but strip the
+     fence markers + any language hint). */
+  s = s.replace(/\`\`\`[a-zA-Z0-9_-]*\\n?([\\s\\S]*?)\`\`\`/g, ' $1 ');
+  /* Inline code: backticks -> nothing (just keep the content). */
+  s = s.replace(/\`([^\`]+)\`/g, '$1');
+  /* Markdown links: [label](url) -> "label". */
+  s = s.replace(/\\[([^\\]]+)\\]\\([^)]+\\)/g, '$1');
+  /* Bold + italic + strikethrough markers -> nothing. */
+  s = s.replace(/\\*+([^*]+?)\\*+/g, '$1');
+  s = s.replace(/_+([^_]+?)_+/g, '$1');
+  s = s.replace(/~+([^~]+?)~+/g, '$1');
+  /* Standalone emphasis or decorative chars at any position. */
+  s = s.replace(/[*_~\`]+/g, '');
+  /* Heading hashes at line start. */
+  s = s.replace(/^#+\\s*/gm, '');
+  /* Bullet list markers at line start (- + *). */
+  s = s.replace(/^\\s*[-+]\\s+/gm, '');
+  /* Horizontal rules -> period. */
+  s = s.replace(/^[-*_=]{3,}$/gm, '.');
+  /* Emojis + symbols ranges (broad pass; leave latin-1 supplement
+     intact so acentos survive). */
+  s = s.replace(/[\\u{1F300}-\\u{1FAFF}]/gu, '');
+  s = s.replace(/[\\u{2600}-\\u{27BF}]/gu, '');
+  /* Multiple punctuation -> single period. */
+  s = s.replace(/[.!?]{2,}/g, '.');
+  /* Multiple spaces / newlines -> single space. */
+  s = s.replace(/\\s+/g, ' ');
+  return s.trim();
+}
+
+/* 2026-05-31 half-duplex fix (per Pablo: "el audio no debe quedar
+   full duplex"). When TTS is playing, the mic MUST be closed so
+   we do not capture Yujin's own voice as if it were user input.
+   That feedback loop is what made STT receive >1 min audio and
+   trip the Google 1-min sync limit.
+
+   Implementation: closeMicForTts() stops any in-progress
+   recording before TTS starts. If the user had push-to-talked,
+   the audio they captured BEFORE TTS started is already in
+   flight; we just prevent NEW captures. */
+function closeMicForTts() {
+  if (_webSpeechRecognition) {
+    try { _webSpeechRecognition.abort(); } catch (_) {}
+    _webSpeechRecognition = null;
+    setStatus('Mic closed while Yujin speaks (half-duplex).');
+  }
+  if (mediaRecorder && mediaRecorder.state === 'recording') {
+    try { mediaRecorder.stop(); } catch { /* ignore */ }
+    setStatus('Mic closed while Yujin speaks (half-duplex).');
+  }
+}
+
+async function _micToggleWebSpeech(button) {
+  const SR = window.SpeechRecognition || window.webkitSpeechRecognition;
+  recordingPanelButton = button;
+  const rec = new SR();
+  rec.continuous     = false;
+  rec.interimResults = true;
+  rec.lang           = _webSpeechLangFromDoc();
+  let finalText = '';
+  let interim = '';
+  /* 2026-05-31 -- Aggressive silence cutoff. Chrome's default
+     silence timeout for SpeechRecognition is ~3s; per Pablo
+     "cerrar el mic mas rapido". We piggyback on interimResults:
+     every time interim text changes we reset a timer; if the
+     timer fires (no interim activity for SILENCE_MS) we stop
+     the recogniser. */
+  const SILENCE_MS = 900;
+  let silenceTimer = null;
+  const resetSilenceTimer = () => {
+    if (silenceTimer) clearTimeout(silenceTimer);
+    silenceTimer = setTimeout(() => {
+      try { rec.stop(); } catch (_) {}
+    }, SILENCE_MS);
+  };
+  rec.onresult = (e) => {
+    interim = '';
+    for (let i = e.resultIndex; i < e.results.length; i += 1) {
+      const r = e.results[i];
+      if (r.isFinal) finalText += r[0].transcript;
+      else interim += r[0].transcript;
+    }
+    if (interim) setStatus('Listening... ' + interim);
+    /* Activity heard -> reset the silence countdown. */
+    resetSilenceTimer();
+  };
+  rec.onerror = (e) => {
+    const errKind = (e && e.error) ? String(e.error) : 'unknown';
+    if (errKind === 'no-speech' || errKind === 'aborted') {
+      setStatus('');
+    } else {
+      setStatus('Mic error: ' + errKind, true);
+    }
+  };
+  rec.onend = () => {
+    if (silenceTimer) { clearTimeout(silenceTimer); silenceTimer = null; }
+    _webSpeechRecognition = null;
+    setMicButtonsState('idle');
+    const text = (finalText || '').trim();
+    if (!text) {
+      if (!interim) setStatus('Did not catch that -- try again.', true);
+      return;
+    }
+    _lastInputWasVoice = true;
+    _lastVoiceButton = recordingPanelButton;
+    /* Inject + submit, same as the Google-STT path. */
+    const inputSel = state.mode === 'full' ? '#bar-full input' : '#bar-mini input';
+    const input = $(inputSel);
+    if (input) {
+      input.value = text;
+      send(text);
+      input.value = '';
+    }
+  };
+  try {
+    _webSpeechRecognition = rec;
+    rec.start();
+    setMicButtonsState('recording');
+    setStatus('Listening (web speech)...');
+    /* IMPORTANT (alpha.29 bugfix): DO NOT arm the silence timer
+       here. If we did, and the user takes >900ms to start
+       talking (typical when they click + think), the timer would
+       fire and rec.stop() before any audio arrived ->
+       'Did not catch that'. The timer is armed by onresult
+       once the FIRST interim/final result lands. */
+  } catch (err) {
+    _webSpeechRecognition = null;
+    setStatus('Could not start mic: ' + (err && err.message ? err.message : String(err)), true);
+  }
+}
+
 async function playTtsForText(text) {
+  text = cleanForTts(text);
   if (!ttsRepliesEnabled()) return;
   if (!text || text.trim() === '') return;
+  /* HALF-DUPLEX GATE: close mic before TTS starts. */
+  closeMicForTts();
+  const wasVoiceTurn = _lastInputWasVoice;
+  /* Reset so the next turn re-decides; e.g. user can switch
+     to keyboard mid-conversation and the auto-reopen stops. */
+  _lastInputWasVoice = false;
+  const reopenBtn = _lastVoiceButton;
   const chunks = splitIntoTtsChunks(text);
   if (chunks.length === 0) return;
-  if (chunks.length === 1) {
-    const url = await _fetchTtsChunk(chunks[0]);
-    if (url) await _playChunkUrl(url);
-    return;
-  }
-  /* Pipeline: prefetch chunk N+1 while chunk N plays. */
-  let nextFetch = _fetchTtsChunk(chunks[0]);
-  for (let i = 0; i < chunks.length; i += 1) {
-    const url = await nextFetch;
-    /* Kick off the next fetch BEFORE awaiting playback so the
-       network round-trip overlaps the audio. */
-    nextFetch = (i + 1 < chunks.length) ? _fetchTtsChunk(chunks[i + 1]) : Promise.resolve(null);
-    if (url) await _playChunkUrl(url);
+  try {
+    if (chunks.length === 1) {
+      const url = await _fetchTtsChunk(chunks[0]);
+      if (url) await _playChunkUrl(url);
+    } else {
+      /* Pipeline: prefetch chunk N+1 while chunk N plays. */
+      let nextFetch = _fetchTtsChunk(chunks[0]);
+      for (let i = 0; i < chunks.length; i += 1) {
+        const url = await nextFetch;
+        nextFetch = (i + 1 < chunks.length) ? _fetchTtsChunk(chunks[i + 1]) : Promise.resolve(null);
+        if (url) await _playChunkUrl(url);
+      }
+    }
+  } finally {
+    /* 2026-05-31 half-duplex auto-reopen. Only in 'auricular'
+       mode (manos libres). In 'mic' mode (push-to-talk) we
+       respect the user's explicit gesture and do NOT reopen.
+       Tiny pause (200ms) so the TTS audio tail does not feed
+       back into the next capture. */
+    if (wasVoiceTurn && reopenBtn && voiceMode() === 'auricular') {
+      setTimeout(() => {
+        if (mediaRecorder && mediaRecorder.state === 'recording') return;
+        try { micToggle(reopenBtn); } catch { /* ignore */ }
+      }, 200);
+    }
   }
 }
 
@@ -1360,7 +1895,124 @@ send = async function (text) {
   }
 };
 
+/* =========================================================================
+ * Support report collector (2026-05-31 -- F30 lite).
+ * Captures errors that Pablo / users would otherwise have to copy
+ * from DevTools. Flushes batches to /api/forge/support/report.
+ * ========================================================================= */
+const supportBuffer = [];
+const supportRequestTrail = [];
+let supportFlushTimer = null;
+const SUPPORT_BUFFER_MAX = 50;
+const SUPPORT_FLUSH_MS   = 30000;
+
+function supportPush(report) {
+  if (supportBuffer.length >= SUPPORT_BUFFER_MAX) return;
+  supportBuffer.push({
+    ...report,
+    client_ts: new Date().toISOString(),
+    view: typeof state !== 'undefined' && state.mode ? state.mode : 'unknown',
+    request_trail: supportRequestTrail.slice(-10),
+  });
+  scheduleSupportFlush();
+}
+
+function scheduleSupportFlush() {
+  if (supportFlushTimer) return;
+  supportFlushTimer = setTimeout(supportFlush, SUPPORT_FLUSH_MS);
+}
+
+async function supportFlush() {
+  supportFlushTimer = null;
+  if (supportBuffer.length === 0) return;
+  const batch = supportBuffer.splice(0, supportBuffer.length);
+  try {
+    await fetch('/api/forge/support/report', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(batch),
+      keepalive: true,  /* survives page unload */
+    });
+  } catch {
+    /* Network error -- drop the batch silently. Trying to
+       report errors via the same broken pipe just loops. */
+  }
+}
+
+function installSupportCollector() {
+  window.addEventListener('error', (ev) => {
+    supportPush({
+      level: 'error',
+      source: 'window.onerror',
+      message: ev.message || 'unknown error',
+      stack: ev.error && ev.error.stack ? ev.error.stack : undefined,
+      url:   ev.filename || undefined,
+      line:  typeof ev.lineno === 'number' ? ev.lineno : undefined,
+      col:   typeof ev.colno === 'number' ? ev.colno : undefined,
+    });
+  });
+  window.addEventListener('unhandledrejection', (ev) => {
+    let msg = 'unhandled promise rejection';
+    let stack;
+    if (ev.reason && typeof ev.reason === 'object') {
+      msg = ev.reason.message || String(ev.reason);
+      stack = ev.reason.stack;
+    } else if (ev.reason) {
+      msg = String(ev.reason);
+    }
+    supportPush({
+      level: 'error',
+      source: 'unhandled',
+      message: msg,
+      stack,
+    });
+  });
+  /* fetch interceptor -- record non-2xx + network failures. */
+  const originalFetch = window.fetch.bind(window);
+  window.fetch = async function patchedFetch(input, init) {
+    const url = typeof input === 'string' ? input
+              : (input && input.url) ? input.url : String(input);
+    const method = (init && init.method) || (input && input.method) || 'GET';
+    try {
+      const r = await originalFetch(input, init);
+      /* Track every call (last 10) so reports carry network context. */
+      supportRequestTrail.push({ method, url, status: r.status });
+      while (supportRequestTrail.length > 10) supportRequestTrail.shift();
+      if (r.status >= 500) {
+        supportPush({
+          level: 'error',
+          source: 'fetch',
+          message: 'fetch ' + method + ' ' + url + ' HTTP ' + r.status,
+        });
+      }
+      return r;
+    } catch (err) {
+      supportRequestTrail.push({ method, url });
+      while (supportRequestTrail.length > 10) supportRequestTrail.shift();
+      supportPush({
+        level: 'error',
+        source: 'fetch',
+        message: 'fetch ' + method + ' ' + url + ' threw: '
+          + (err && err.message ? err.message : String(err)),
+        stack: err && err.stack ? err.stack : undefined,
+      });
+      throw err;
+    }
+  };
+  /* Flush on unload using sendBeacon (more reliable than fetch
+     during navigation tear-down). */
+  window.addEventListener('pagehide', () => {
+    if (supportBuffer.length === 0) return;
+    const batch = supportBuffer.splice(0, supportBuffer.length);
+    try {
+      const blob = new Blob([JSON.stringify(batch)], { type: 'application/json' });
+      navigator.sendBeacon('/api/forge/support/report', blob);
+    } catch { /* ignore */ }
+  });
+}
+
 document.addEventListener('DOMContentLoaded', () => {
+  installSupportCollector();
   setProj();
   showMode(loadMode());
   $('#yf-globito').addEventListener('click', () => showMode('mini'));
@@ -1376,6 +2028,29 @@ document.addEventListener('DOMContentLoaded', () => {
   /* Voice controls. */
   $$('[data-mic-btn]').forEach((b) => b.addEventListener('click', () => micToggle(b)));
   $$('[data-tts-toggle]').forEach((b) => b.addEventListener('click', () => setTtsReplies(!ttsRepliesEnabled())));
+  $$('[data-voice-mode-btn]').forEach((b) => b.addEventListener('click', () => {
+    setVoiceMode(voiceMode() === 'auricular' ? 'mic' : 'auricular');
+  }));
+  updateVoiceModeButtons();
+  $$('[data-stt-provider-btn]').forEach((b) => b.addEventListener('click', cycleSttProvider));
+  updateSttProviderButtons();
+  /* alpha.29 -- settings dropdown toggle + keys status. */
+  const settingsPanel = $('#yf-settings');
+  $$('[data-settings-toggle]').forEach((b) => b.addEventListener('click', () => {
+    if (!settingsPanel) return;
+    settingsPanel.classList.toggle('hidden');
+    if (!settingsPanel.classList.contains('hidden')) refreshKeysStatus();
+  }));
+  /* Click outside closes. */
+  document.addEventListener('click', (e) => {
+    if (!settingsPanel || settingsPanel.classList.contains('hidden')) return;
+    if (settingsPanel.contains(e.target)) return;
+    if (e.target.closest('[data-settings-toggle]')) return;
+    settingsPanel.classList.add('hidden');
+  });
+  /* TTS voice cycle. */
+  $$('[data-tts-voice-btn]').forEach((b) => b.addEventListener('click', cycleTtsVoice));
+  updateTtsVoiceButtons();
   setMicButtonsState('idle');
   updateTtsToggleButtons();