Despliegue desde GitHub

VERSION

@@ -0,0 +1 @@
+2026.10.30-796f5a7

app.py

@@ -13,9 +13,13 @@ except ImportError:  # versión de escritorio
 
 import os
 import shutil
+import subprocess
 import tempfile
+import threading
 import time
+import urllib.request
 import zipfile
+from collections import OrderedDict
 from pathlib import Path
 
 import gradio as gr
@@ -26,6 +30,7 @@ import metrics
 import pipeline
 import profiles
 import report
+import spectro
 import ui_html
 from audio_io import AUDIO_EXTENSIONS, fmt_duration, read_audio, read_meta
 from denoise_core import gpu_available
@@ -47,6 +52,46 @@ DESKTOP_REPO = "Azuredraco/limpieza-de-voz-windows"
 DESKTOP_URL = f"https://huggingface.co/{DESKTOP_REPO}/resolve/main/Instalar-Limpieza-de-voz.exe"
 DESKTOP_ZIP_URL = f"https://huggingface.co/{DESKTOP_REPO}/resolve/main/Limpieza-de-voz-portable.zip"
 
+def _read_version() -> str:
+    """Versión: fichero VERSION (lo escriben los despliegues) o, en desarrollo, el commit de git."""
+    f = Path(__file__).with_name("VERSION")
+    if f.is_file():
+        return f.read_text(encoding="utf-8-sig").strip()
+    try:
+        out = subprocess.run(["git", "log", "-1", "--format=%cd-%h", "--date=format:%Y.%m.%d"],
+                             cwd=Path(__file__).parent, capture_output=True, text=True, timeout=3)
+        return (out.stdout.strip() + "-dev") if out.returncode == 0 and out.stdout.strip() else "dev"
+    except Exception:
+        return "dev"
+
+
+VERSION = _read_version()
+VERSION_URL = f"https://huggingface.co/{DESKTOP_REPO}/resolve/main/version.txt"
+_latest = {"v": None}
+
+
+def _check_update():
+    """En la versión de escritorio, mira (en segundo plano) si hay una versión nueva publicada."""
+    try:
+        req = urllib.request.Request(VERSION_URL, headers={"User-Agent": "audio-denoise"})
+        with urllib.request.urlopen(req, timeout=8) as r:
+            _latest["v"] = r.read().decode("utf-8").strip() or None
+    except Exception:
+        pass
+
+
+if not ON_SPACE and VERSION != "dev" and not VERSION.endswith("-dev"):
+    threading.Thread(target=_check_update, daemon=True).start()
+
+
+def _update_banner() -> str:
+    v = _latest["v"]
+    if not v or v == VERSION or ON_SPACE:
+        return ""
+    return (f"<div class='ad-update'>🆕 Hay una versión nueva ({v}). <a href='{DESKTOP_URL}'>Descárgala aquí</a> "
+            "e instálala encima: tus ajustes se conservan.</div>")
+
+
 QUALITY_LABEL = "⭐ Nota de calidad (antes y después)"
 QUALITY_INFO = ("Puntúa de 1 a 5 cómo suena cada audio antes y después, como lo valoraría un oyente. "
                 "Hace que cada audio tarde más: desmárcala solo si tienes prisa.")
@@ -58,6 +103,10 @@ MODE_CHOICES = {
 MODE_INFO = ("Solo formato: bits, canales y frecuencia; el sonido no cambia. · Permitido: además volumen, picos y "
              "silencios del principio y del final. · Ninja: además quita ruido de fondo y retumbes de forma sutil "
              "(pulido automático: solo se queda si suena mejor).")
+AUTO_LABEL = "🤖 AUTOMÁTICO · la app lo hace todo"
+AUTO_INFO = ("Sube los audios y te los devuelve listos: los revisa, arregla solo lo que haga falta (lo mínimo) y te "
+             "enseña qué ha cambiado. Si ya cumplen, no se tocan. Desmárcalo para elegir tú cómo procesar.")
+AUTO_MODE = "auto"
 EVENTS_LABEL = "🔇 Quitar ruidos sueltos en las pausas"
 EVENTS_INFO = ("Cláxones, golpes, puertas… que suenan mientras nadie habla se cambian por el silencio de la sala; "
                "la voz no se toca. En cada audio verás en qué minuto estaba cada uno. Ojo con risas, llantos o "
@@ -87,7 +136,7 @@ def _preset_label(db) -> str:
 
 def _settings(prof, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mono=None, mode=None,
               events=False) -> pipeline.Settings:
-    modo = MODE_CHOICES.get(mode, pipeline.default_mode(prof))
+    modo = mode if mode == AUTO_MODE else MODE_CHOICES.get(mode, pipeline.default_mode(prof))
     return pipeline.Settings.from_profile(
         prof, reduccion_db=PRESETS[preset], paso_alto_hz=float(hp) or None,
         conservar_ultrasonidos=ultra, escalar_reduccion=escalate, dnsmos=use_dnsmos, usar_gpu=use_gpu,
@@ -119,6 +168,32 @@ def _profile_info(pid: str):
     )
 
 
+# ── Cachés: no repetir el análisis ni la corrección de un audio que no ha cambiado ─────
+
+_CACHE: "OrderedDict[tuple, object]" = OrderedDict()
+CACHE_MAX = 64
+
+
+def _file_key(path: str) -> tuple:
+    st = os.stat(path)
+    return path, st.st_size, st.st_mtime_ns
+
+
+def _cached(key: tuple, make):
+    if key in _CACHE:
+        _CACHE.move_to_end(key)
+        return _CACHE[key]
+    val = make()
+    _CACHE[key] = val
+    while len(_CACHE) > CACHE_MAX:
+        _CACHE.popitem(last=False)
+    return val
+
+
+def _analyze(path: str, prof: dict, pid: str):
+    return _cached(("an", *_file_key(path), pid, prof.get("_pausa_max_s")), lambda: pipeline.analyze(path, prof))
+
+
 # ── Comprobar ───────────────────────────────────────────────────────��────────
 
 def _prof(pid: str, pause_max: float) -> dict:
@@ -131,12 +206,12 @@ def cb_analyze(files, pid, pause_max, progress=gr.Progress()):
         yield ui_html.empty("Primero sube uno o varios audios (paso 2)."), ""
         return
     prof = _prof(pid, pause_max)
-    cards, durs = [], []
+    cards, durs, all_rows = [], [], []
     n_ok = n_fix = n_err = n_pauses = 0
     yield ui_html.banner("info", f"⏳ Revisando {len(paths)} audio(s)…"), ""
     for i, p in enumerate(paths):
         progress(i / len(paths), desc=f"Analizando {Path(p).name}")
-        a = pipeline.analyze(p, prof)
+        a = _analyze(p, prof, pid)
         name = Path(p).name
         if a.error:
             n_err += 1
@@ -146,11 +221,16 @@ def cb_analyze(files, pid, pause_max, progress=gr.Progress()):
             if a.ok:
                 n_ok += 1
                 badge = ("ok", "✓ CUMPLE")
+                vd = ui_html.verdict("ok", "✅ Cumple: listo para enviar tal cual")
             else:
                 n_fix += 1
                 badge = ("fix", "⚡ HAY QUE CORREGIR")
+                vd = ui_html.verdict("fix", f"⚠️ No cumple: {', '.join(profiles.failed(a.rows))}",
+                                     "Pulsa «✨ Corregir y descargar» (o activa 🤖 Automático) para arreglarlo.")
             n_pauses += bool(profiles.long_pauses(a.m, prof))
-            cards.append(ui_html.card(name, a.meta.describe(), badge, a.rows, m_before=a.m))
+            all_rows += a.rows
+            cards.append(ui_html.card(name, a.meta.describe(), badge, a.rows, m_before=a.m, verdict_html=vd,
+                                      original=_file_url(p)))
         extra = ""
         if n_pauses and i == len(paths) - 1:
             extra = ui_html.banner("info", f"✂️ Además, {n_pauses} audio(s) tienen pausas de más de {pause_max:.1f} s. "
@@ -158,18 +238,18 @@ def cb_analyze(files, pid, pause_max, progress=gr.Progress()):
         if i == len(paths) - 1:
             extra += _pairs_html(prof, [p for p in paths])
         summary = _summary(prof, len(paths), n_ok, n_fix, n_err, durs, "Por corregir", extra=extra)
-        yield summary, "".join(reversed(cards))
+        yield summary, ui_html.glossary_all(all_rows) + "".join(reversed(cards))
     progress(1.0)
 
 
-def _summary(prof, total, n_ok, n_fix, n_err, durs, fix_label, final=False, extra: str = "") -> str:
+def _summary(prof, total, n_ok, n_fix, n_err, durs, fix_label, final=False, extra: str = "", left: str = "") -> str:
     target = (prof.get("entregables") or {}).get("objetivo_total_s")
     out = ui_html.stats(total, n_ok, n_fix, n_err, sum(d for _, d in durs), target, fix_label)
     done = final or (n_ok + n_fix + n_err) == total
     reviewing = fix_label == "Por corregir"
     if not done:
         out = ui_html.banner("info", f"⏳ {'Revisando' if reviewing else 'Corrigiendo'}… "
-                                     f"{n_ok + n_fix + n_err} de {total} audio(s) terminados") + out
+                                     f"{n_ok + n_fix + n_err} de {total} audio(s) terminados{left}") + out
     elif n_err:
         out = ui_html.banner("bad", "❌ Algún audio no se ha podido leer o sigue sin cumplir. "
                                     "Mira su tarjeta, aquí debajo, antes de entregar.") + out
@@ -221,6 +301,32 @@ def _file_url(path: str) -> str:
     return "/gradio_api/file=" + Path(path).as_posix()
 
 
+def _eta(seconds: float) -> str:
+    if seconds < 60:
+        return "menos de 1 min"
+    return f"~{round(seconds / 60)} min"
+
+
+def _correction_verdict(r, ok: bool, untouched: bool, modo: str) -> str:
+    """Veredicto de una línea: ¿se puede mandar? ¿qué se ha cambiado?"""
+    stuck = profiles.failed(r.after.rows) if r.after else []
+    if not ok:
+        fixable = [f for f in stuck if pipeline.FIX_FOR.get(f)]
+        detail = ("Con el nivel elegido no se toca; con 🤖 Automático o 🥷 Ninja se intentaría arreglar."
+                  if fixable and modo in ("formato", "permitido") else
+                  "Esto no tiene arreglo automático: conviene volver a grabarlo.")
+        return ui_html.verdict("bad", f"❌ No queda bien: {', '.join(stuck)}", detail)
+    if untouched:
+        return ui_html.verdict("ok", "✅ Listo para enviar · ya cumplía, no se ha tocado",
+                               "El fichero descargado es idéntico a tu original.")
+    words = list(dict.fromkeys(pipeline.FIX_WORDS.get(f, f) for f in sorted(r.fixes)))
+    lv = pipeline.level_used(r.fixes)
+    detail = f"Nivel que ha hecho falta: {pipeline.MODE_LABEL.get(lv, lv)}" if lv else ""
+    if r.pulido:
+        detail += (" · " if detail else "") + "con pulido automático (suena mejor)"
+    return ui_html.verdict("ok", f"✅ Listo para enviar · se ha cambiado: {', '.join(words) or 'formato'}", detail)
+
+
 def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mode, mono,
                cut_pauses, pause_max, events=False, progress=gr.Progress()):
     hidden = gr.update(visible=False)
@@ -231,26 +337,42 @@ def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mod
     prof = _prof(pid, pause_max)
     settings = _settings(prof, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mono, mode, events)
     settings.acortar_pausas = bool(cut_pauses)
+    skey = repr(settings)
+    modo = settings.modo
     yield ui_html.banner("info", f"⏳ Corrigiendo {len(paths)} audio(s)…"), "", hidden, hidden
     job = _new_job_dir()
     out_dir = job / "corregidos"
-    cards, durs, items, outputs = [], [], [], []
+    cards, durs, items, outputs, all_rows = [], [], [], [], []
     n_ok = n_fixed = n_err = 0
+    # Tiempo estimado: segundos de proceso por segundo de audio, medido con los audios ya hechos
+    lens = [(m.duration if (m := pipeline.quick_meta(p)) else 0.0) for p in paths]
+    t0, done_audio = time.time(), 0.0
 
     for i, p in enumerate(paths):
         name = Path(p).name
+        rate = (time.time() - t0) / done_audio if done_audio > 0 else None
+        left = f" · quedan {_eta(rate * sum(lens[i:]))}" if rate else ""
 
-        def prog(f, desc, i=i, name=name):
-            progress((i + f) / len(paths), desc=f"{name} · {desc}")
+        def prog(f, desc, i=i, name=name, left=left):
+            progress((i + f) / len(paths), desc=f"{name} · {desc}{left}")
 
-        progress(i / len(paths), desc=f"{name} · revisando")
-        pre = pipeline.analyze(p, prof)
+        progress(i / len(paths), desc=f"{name} · revisando{left}")
+        pre = _analyze(p, prof, pid)
         if pre.error:
             n_err += 1
             cards.append(ui_html.card(name, "", ("bad", "✗ ERROR"), [], error=pre.error))
             items.append({"nombre": name, "estado_inicial": "ERROR", "estado_final": "ERROR", "notas": [pre.error]})
         else:
-            r = pipeline.correct(p, prof, settings, out_dir, progress=prog, before=pre)
+            key = ("co", *_file_key(p), pid, float(pause_max), skey)
+            r = _CACHE.get(key)
+            if r is None or not (r.out_path and Path(r.out_path).is_file()):
+                r = pipeline.correct(p, prof, settings, out_dir, progress=prog, before=pre)
+                r.spec = None
+                if not r.error and r.after is not None and r.after is not r.before and lens[i] <= 3600:
+                    prog(0.97, "dibujando espectrogramas")
+                    r.spec = spectro.make_png(p, r.out_path, job / f"espectro-{i + 1}.png")
+                _CACHE[key] = r
+                _cached(key, lambda: r)  # recorta la caché si se ha pasado del máximo
             if r.error or r.after is None or r.after.error:
                 n_err += 1
                 err = r.error or (r.after.error if r.after else "error desconocido")
@@ -270,13 +392,18 @@ def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mod
                 else:
                     n_err += 1
                     badge = ("bad", "✗ NO SE HA PODIDO DEJAR BIEN")
+                all_rows += r.before.rows
                 cards.append(ui_html.card(name, r.before.meta.describe() if untouched else
                                           f"{r.before.meta.describe()}  →  {r.after.meta.describe()}", badge,
                                           r.before.rows, None if untouched else r.after.rows, notes=r.notes,
                                           download=_file_url(r.out_path), m_before=r.before.m,
                                           m_after=None if untouched else r.after.m,
                                           meta_before=r.before.meta, meta_after=r.after.meta,
-                                          pause_max=profiles.pause_max(prof)))
+                                          pause_max=profiles.pause_max(prof),
+                                          verdict_html=_correction_verdict(r, ok, untouched, modo),
+                                          original=_file_url(p), events=r.eventos,
+                                          spec_url=_file_url(r.spec) if getattr(r, "spec", None) else None))
+                lv = pipeline.level_used(r.fixes) if not untouched else None
                 items.append({
                     "nombre": Path(r.out_path).name, "duracion_s": r.after.meta.duration,
                     "estado_inicial": "CUMPLÍA" if r.before.ok else "NO CUMPLÍA",
@@ -284,10 +411,16 @@ def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mod
                     else "SIGUE SIN CUMPLIR",
                     "formato": r.before.meta.describe(), "antes": r.before.m, "despues": r.after.m,
                     "fallos": profiles.failed(r.before.rows), "notas": r.notes,
+                    "nivel": pipeline.MODE_LABEL.get(lv, "sin tocar") if lv else "sin tocar",
+                    "cambios": list(dict.fromkeys(pipeline.FIX_WORDS.get(f, f) for f in sorted(r.fixes)))
+                    if not untouched else [],
                 })
+        done_audio += lens[i]
         files_update = gr.update(value=list(outputs), visible=bool(outputs)) if outputs else hidden
-        yield (_summary(prof, len(paths), n_ok, n_fixed, n_err, durs, "Corregidos", final=False),
-               "".join(reversed(cards)), hidden, files_update)
+        rate = (time.time() - t0) / done_audio if done_audio > 0 else None
+        left = f" · quedan {_eta(rate * sum(lens[i + 1:]))}" if rate and i + 1 < len(paths) else ""
+        yield (_summary(prof, len(paths), n_ok, n_fixed, n_err, durs, "Corregidos", final=False, left=left),
+               ui_html.glossary_all(all_rows) + "".join(reversed(cards)), hidden, files_update)
 
     # Informe + ZIP
     progress(0.99, desc="Preparando la descarga")
@@ -306,7 +439,7 @@ def cb_correct(files, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mod
         z.write(csvf, csvf.name)
     yield (_summary(prof, len(paths), n_ok, n_fixed, n_err, durs, "Corregidos", final=True,
                     extra=_pairs_html(prof, outputs) + ui_html.report_table(items)),
-           "".join(reversed(cards)),
+           ui_html.glossary_all(all_rows) + "".join(reversed(cards)),
            gr.update(value=str(zip_path), visible=True),
            gr.update(value=outputs + [str(xlsx), str(csvf)], visible=True))
 
@@ -398,6 +531,46 @@ def cb_preview(path, start, length, preset, hp, ultra, use_dnsmos, use_gpu, prog
     return str(orig_p), str(proc_p), png, card
 
 
+# ── Flujo automático, ajustes guardados ───────────────────────────────────────
+
+def cb_upload(files, auto, pid, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mode, mono, cut_pauses, pause_max,
+              events, progress=gr.Progress()):
+    """Al subir audios (o cambiar de proyecto): en Automático, todo de una vez; si no, solo la revisión."""
+    hidden = gr.update(visible=False)
+    if not _paths(files):
+        yield ui_html.empty("Aquí aparecerán los resultados."), "", hidden, hidden
+        return
+    if auto:
+        yield from cb_correct(files, pid, preset, hp, ultra, escalate, True, use_gpu, AUTO_MODE, mono, False,
+                              pause_max, False, progress=progress)
+    else:
+        for summ, res in cb_analyze(files, pid, pause_max, progress=progress):
+            yield summ, res, hidden, hidden
+
+
+def _auto_view(auto: bool):
+    on = bool(auto)
+    return (gr.update(visible=not on), gr.update(visible=not on), gr.update(visible=on),
+            STEPS_AUTO if on else STEPS)
+
+
+SETTINGS_DEFAULT = {"perfil": DEFAULT_PROFILE, "auto": True, "dnsmos": True, "pausa": 2.0, "cortar": False,
+                    "eventos": False}
+
+
+def _restore(st):
+    st = {**SETTINGS_DEFAULT, **(st or {})}
+    pid = st["perfil"] if st["perfil"] in PROFILES else DEFAULT_PROFILE
+    return (gr.update(value=pid), gr.update(value=bool(st["auto"])), gr.update(value=bool(st["dnsmos"])),
+            gr.update(value=float(st["pausa"])), gr.update(value=bool(st["cortar"])),
+            gr.update(value=bool(st["eventos"])), *_auto_view(st["auto"]), *_profile_info(pid), _update_banner())
+
+
+def _save(pid, auto, dnsmos_on, pausa, cortar, eventos):
+    return {"perfil": pid, "auto": bool(auto), "dnsmos": bool(dnsmos_on), "pausa": float(pausa),
+            "cortar": bool(cortar), "eventos": bool(eventos)}
+
+
 # ── Interfaz ─────────────────────────────────────────────────────────────────
 
 STEPS = """
@@ -408,6 +581,13 @@ STEPS = """
   <div><b>4</b> Pulsa <i>Corregir y descargar</i></div>
 </div>
 """
+STEPS_AUTO = """
+<div class="ad-steps">
+  <div><b>1</b> Elige el proyecto</div>
+  <div><b>2</b> Sube los audios</div>
+  <div><b>3</b> ¡Listo! Mira el resultado y descarga</div>
+</div>
+"""
 
 DESKTOP_HELP = f"""
 ## 💻 Versión para Windows
@@ -426,20 +606,21 @@ LOGIN_HELP = ("**Antes de empezar:** entra con tu cuenta de Hugging Face (botón
               "Si no entras también funciona, pero puede ir más despacio.\n\n")
 
 HELP = """
-## Paso a paso
+## Paso a paso (modo 🤖 Automático, el normal)
 
 {login}1. **Elige el proyecto** en el desplegable de arriba. Debajo verás qué pide ese cliente.
 2. **Sube los audios** en la pestaña *✅ Corregir*: arrástralos o pulsa para buscarlos. Puedes subir varios a la vez.
-3. Pulsa **🔍 Revisar**. Cada audio aparece en una tarjeta:
-   - 🟢 **CUMPLE**: está listo para entregar.
-   - 🟠 **HAY QUE CORREGIR**: la tabla te dice qué falla, en las filas marcadas con **Falla**.
-   - 🔴 **ERROR**: el fichero no se puede abrir. Vuelve a exportarlo desde Audacity.
-4. Pulsa **✨ Corregir y descargar**. Cuando termine aparece **Descarga**:
-   - El **ZIP** lo contiene todo: los audios corregidos, **con el mismo nombre que tenían**, y un informe en Excel.
-   - Para cumplir los requisitos, **solo se corrige lo que no cumple**: si un audio solo tiene mal el volumen, solo se ajusta el volumen. Cuánto se puede tocar lo eliges con el **nivel de procesado** (más abajo te lo explico).
-5. **Entrega los audios del ZIP.**
+3. **Ya está.** La app los revisa y arregla **solo lo que haga falta** (lo mínimo). Cada audio aparece en una tarjeta con una frase arriba:
+   - ✅ **Listo para enviar · ya cumplía, no se ha tocado**: el fichero es idéntico a tu original.
+   - ✅ **Listo para enviar · se ha cambiado: …**: te dice qué se ha tocado y qué nivel ha hecho falta.
+   - ❌ **No queda bien: …**: lo que falla y si tiene arreglo.
+4. Escúchalo en la propia tarjeta (**🎧 Original** y **✨ Corregido**; el botón **⇄** cambia de uno a otro en el mismo punto) y descárgalo: botón de cada tarjeta o **⬇️ Descargar todo** (ZIP con los audios, **con el mismo nombre que tenían**, y un informe en Excel).
 
-Revisar no cambia nada; es solo para mirar. Puedes pasar directamente al paso 4: también revisa antes de corregir.
+Si cambias de proyecto con los audios ya subidos, se vuelven a procesar solos. **🔄 Volver a procesar** repite todo.
+
+**¿Quieres decidir tú?** Desmarca **🤖 Automático**: aparecen el nivel de procesado, las demás opciones y los botones **🔍 Revisar** y **✨ Corregir y descargar**. Al subir audios, entonces solo se revisan (no se cambia nada hasta que pulses Corregir).
+
+La app recuerda el proyecto y tus ajustes para la próxima vez.
 
 ## Cómo se leen las tarjetas
 
@@ -457,9 +638,9 @@ Cada fila es una comprobación. Las columnas son **Antes** (tu audio), **Despué
 
 Debajo de cada tarjeta, **«Qué se ha hecho»** resume los arreglos aplicados a ese audio. El botón **⬇️ Descargar este audio** de cada tarjeta descarga ese audio suelto; el botón grande **⬇️ Descargar todo** baja el ZIP completo cuando terminan todos.
 
-## Nivel de procesado (📏 🎚️ 🥷)
+## Nivel de procesado (📏 🎚️ 🥷), con Automático desmarcado
 
-Tú eliges cuánto se toca el audio. Cada proyecto arranca con un nivel, pero puedes cambiarlo antes de pulsar «Corregir».
+Tú eliges cuánto se toca el audio. Cada proyecto arranca con un nivel, pero puedes cambiarlo antes de pulsar «Corregir». **🤖 Automático** equivale a usar el nivel más bajo que lo arregle, sin pulido.
 
 - **📏 Solo formato:** bits, canales y frecuencia. **El sonido no cambia.**
 - **🎚️ Permitido:** lo anterior y, además, el volumen, los picos y los silencios del principio y del final.
@@ -475,6 +656,10 @@ Para cláxones, golpes, puertas… que suenan **mientras nadie habla**. Un detec
 - **No lo uses con risas, llantos o muletillas** («mmm», «eh»): el detector no los considera voz y los quitaría.
 - Si el ruido suena **a la vez que la voz**, esto no lo quita (en «Ninja» se atenúa con la limpieza de ruido).
 
+## Espectrogramas (🔬)
+
+En cada audio corregido, **«🔬 Espectrogramas»** enseña cómo era el sonido antes, cómo ha quedado y la diferencia (azul = lo que se ha quitado, rojo = lo que se ha añadido). Es para curiosos: no hace falta mirarlo.
+
 ## Nota de calidad (⭐)
 
 Viene **marcada**. Cada tarjeta muestra una nota de 1 a 5 **antes** y **después**: cómo valoraría el audio una persona escuchándolo (por encima de 3,5 suena muy bien). Se separa en **voz** (¿suena natural, sin distorsión?) y **fondo** (¿se oye ruido?). Hace que cada audio tarde más; desmárcala si tienes prisa.
@@ -520,7 +705,8 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
                 "<p>Quita el ruido de tus grabaciones y comprueba que cumplen lo que pide el cliente.</p></div>")
         theme_btn = gr.Button("🌓", elem_id="tema-btn", scale=0, min_width=52, variant="secondary")
     theme_btn.click(None, js=ui_html.TOGGLE_JS)
-    gr.HTML(STEPS)
+    update_html = gr.HTML()
+    steps = gr.HTML(STEPS_AUTO)
     if ON_SPACE:
         gr.HTML(f"<div class='ad-desktop'>💻 ¿Lo usas a menudo? <a href='{DESKTOP_URL}'>Descarga la versión para Windows</a>: "
                 "va en tu ordenador, sin esperas ni límites y sin subir los audios a internet.</div>")
@@ -528,8 +714,12 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
     with gr.Row():
         profile_dd = gr.Dropdown(PROFILE_CHOICES, value=DEFAULT_PROFILE, label="1 · Proyecto", scale=3)
     profile_md = gr.Markdown(elem_classes="ad-profile")
+    auto = gr.Checkbox(value=True, label=AUTO_LABEL, info=AUTO_INFO, elem_id="auto-toggle")
+    settings_state = gr.BrowserState(SETTINGS_DEFAULT, storage_key="limpieza-voz-ajustes",
+                                     secret="limpieza-de-voz-ajustes-v1")
 
-    with gr.Accordion("⚙️ Opciones avanzadas (normalmente no hace falta tocarlas)", open=False):
+    with gr.Accordion("⚙️ Opciones avanzadas (normalmente no hace falta tocarlas)", open=False,
+                      visible=False) as adv:
         preset = gr.Radio(list(PRESETS), value=DEFAULT_PRESET, label="Cuánto ruido quitar",
                           info="Natural deja la voz limpia sin cambiar su timbre.")
         with gr.Row():
@@ -546,18 +736,20 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
         with gr.Tab("✅ Corregir"):
             files = gr.File(label="2 · Sube aquí los audios (puedes arrastrar varios a la vez)",
                             file_count="multiple", file_types=AUDIO_EXTENSIONS)
-            with gr.Row(elem_classes="ad-quality"):
+            rerun_btn = gr.Button("🔄 Volver a procesar", variant="secondary", size="sm")
+            with gr.Column(visible=False) as manual:
+              with gr.Row(elem_classes="ad-quality"):
                 mode = gr.Radio(list(MODE_CHOICES), value="🥷 Ninja", label="Nivel de procesado", info=MODE_INFO,
                                 scale=2)
                 use_dnsmos = gr.Checkbox(value=True, label=QUALITY_LABEL, info=QUALITY_INFO)
-            with gr.Row(elem_classes="ad-quality"):
+              with gr.Row(elem_classes="ad-quality"):
                 cut_pauses = gr.Checkbox(value=False, label="✂️ Acortar pausas largas", scale=2,
                                          info="Recorta las pausas entre frases que pasen de la duración máxima. "
                                               "Conserva el principio y el final de cada pausa para que suene natural.")
                 pause_max = gr.Slider(0.5, 5.0, value=2.0, step=0.1, label="Pausa máxima (segundos)", scale=1)
-            with gr.Row(elem_classes="ad-quality"):
+              with gr.Row(elem_classes="ad-quality"):
                 events = gr.Checkbox(value=False, label=EVENTS_LABEL, info=EVENTS_INFO)
-            with gr.Row():
+              with gr.Row():
                 analyze_btn = gr.Button("🔍 3 · Revisar", variant="secondary")
                 correct_btn = gr.Button("✨ 4 · Corregir y descargar", variant="primary")
             summary = gr.HTML(ui_html.empty("Aquí aparecerán los resultados."))
@@ -592,13 +784,27 @@ with gr.Blocks(title="Limpieza y control de voz", delete_cache=(3600, 86400)) as
             if ON_SPACE:
                 gr.Markdown(DESKTOP_HELP)
 
-    profile_dd.change(_profile_info, profile_dd, [profile_md, preset, hp, ultra, mode, mono])
-    app.load(_profile_info, profile_dd, [profile_md, preset, hp, ultra, mode, mono])
-    files.change(_clear, None, [summary, results, zip_btn, downloads])
+    gr.HTML(f"<div class='ad-version'>Versión {VERSION}</div>")
+
+    upload_inputs = [files, auto, profile_dd, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mode, mono, cut_pauses,
+                     pause_max, events]
+    run_outputs = [summary, results, zip_btn, downloads]
+    profile_dd.change(_profile_info, profile_dd, [profile_md, preset, hp, ultra, mode, mono]).then(
+        cb_upload, upload_inputs, run_outputs)
+    auto.change(_auto_view, auto, [manual, adv, rerun_btn, steps])
+    app.load(_restore, settings_state,
+             [profile_dd, auto, use_dnsmos, pause_max, cut_pauses, events, manual, adv, rerun_btn, steps,
+              profile_md, preset, hp, ultra, mode, mono, update_html])
+    gr.on([profile_dd.change, auto.change, use_dnsmos.change, pause_max.change, cut_pauses.change, events.change],
+          _save, [profile_dd, auto, use_dnsmos, pause_max, cut_pauses, events], settings_state)
+    files.change(_clear, None, run_outputs).then(cb_upload, upload_inputs, run_outputs)
+    rerun_btn.click(cb_upload, upload_inputs, run_outputs)
     analyze_btn.click(cb_analyze, [files, profile_dd, pause_max], [summary, results])
     correct_btn.click(cb_correct, [files, profile_dd, preset, hp, ultra, escalate, use_dnsmos, use_gpu, mode, mono,
-                       cut_pauses, pause_max, events],
-                      [summary, results, zip_btn, downloads])
+                       cut_pauses, pause_max, events], run_outputs)
+    if not ON_SPACE:
+        upd_timer = gr.Timer(8)
+        upd_timer.tick(lambda: (_update_banner(), gr.Timer(active=False)), None, [update_html, upd_timer])
     p_audio.change(cb_load_preview, p_audio, [p_overview, p_start, p_info])
     p_btn.click(cb_preview, [p_audio, p_start, p_len, preset, hp, ultra, p_dnsmos, use_gpu],
                 [p_orig, p_proc, p_spec, p_card])

dsp.py

@@ -441,3 +441,13 @@ def remove_events(x: np.ndarray, sr: int, speech_prob: np.ndarray, hop_s: float)
         y[s0:s1] = x[s0:s1] * (1 - w[:, None]) + tone[: s1 - s0] * w[:, None]
         out.append((s0 / sr, (s1 - s0) / sr, float(lvl[a:b].max() - floor)))
     return y.astype(np.float32), out
+
+
+def remove_hum(x: np.ndarray, sr: int, harmonics: list[float], q: float = 35.0) -> np.ndarray:
+    """Filtros de muesca muy estrechos (Q 35: ~1,5 Hz a 50 Hz) en cada armónico del zumbido, sin desfase."""
+    y = x.astype(np.float64)
+    for f0 in harmonics:
+        if f0 < sr / 2 - 50:
+            b, a = signal.iirnotch(f0, q, fs=sr)
+            y = signal.filtfilt(b, a, y, axis=0)
+    return y.astype(np.float32)

metrics.py

@@ -80,6 +80,50 @@ def bandwidth_hz(mono: np.ndarray, sr: int) -> float:
     return float(fb[last + 1]) if last > 0 else float(fb[-1])
 
 
+HUM_HARMONICS = 10        # se miran los 10 primeros armónicos (hasta 500/600 Hz)
+HUM_MIN_DB = 10.0         # un armónico «es zumbido» si destaca ≥ 10 dB sobre las frecuencias vecinas
+
+
+def hum(mono: np.ndarray, sr: int) -> dict | None:
+    """
+    Zumbido eléctrico de la red (50 Hz en Europa, 60 Hz en América) y sus armónicos.
+    Es un tono fijo: en un espectro de 1 Hz de resolución sobre todo el audio forma picos estrechos,
+    mientras que la voz (que cambia de tono continuamente) se reparte. Devuelve
+    {'base': 50|60, 'db': prominencia máxima, 'armonicos': [Hz con ≥ 6 dB]} o None.
+    """
+    from scipy import signal
+
+    n = len(mono)
+    if n < 2 * sr:
+        return None
+    seg = int(2 * sr)
+    if n > 120 * sr:
+        starts = np.linspace(0, n - seg, 60).astype(int)
+        x = np.concatenate([mono[a : a + seg] for a in starts])
+    else:
+        x = mono
+    f, pxx = signal.welch(x.astype(np.float64), sr, nperseg=seg)
+    pdb = 10 * np.log10(np.maximum(pxx, 1e-30))
+    df = f[1] - f[0]
+    best = None
+    for base in (50, 60):
+        prom = []
+        for k in range(1, HUM_HARMONICS + 1):
+            fk = base * k
+            i = int(round(fk / df))
+            if i + 12 >= len(pdb):
+                break
+            peak = pdb[max(0, i - 1) : i + 2].max()
+            neigh = np.concatenate([pdb[max(0, i - 12) : max(0, i - 3)], pdb[i + 4 : i + 13]])
+            prom.append((fk, float(peak - np.median(neigh))))
+        strong = [fk for fk, d in prom if d >= 6]
+        top = max((d for _, d in prom), default=0.0)
+        # hace falta un armónico claro y al menos otro: un solo pico aislado puede ser otra cosa
+        if top >= HUM_MIN_DB and len(strong) >= 2 and (best is None or top > best["db"]):
+            best = {"base": base, "db": top, "armonicos": strong}
+    return best
+
+
 def measure(data: np.ndarray, sr: int, with_lufs: bool = True, detector: str | None = None) -> dict:
     """data: (n, ch) float32. Devuelve un dict de métricas (floats en dB / segundos)."""
     mono = dsp.to_mono(data)[:, 0]
@@ -116,6 +160,7 @@ def measure(data: np.ndarray, sr: int, with_lufs: bool = True, detector: str | N
         "silencio_digital": bool(not live.any()) or bool(noise_frames.size == 0),
         "pico_voz_muestras": min(32767, int(round(float(np.abs(voice).max()) * 32767))) if voice.size else 0,
         "ancho_banda_hz": bandwidth_hz(mono, sr),
+        "zumbido": hum(mono, sr),
         "pausas_s": [(b - a) / sr for a, b in dsp.find_pauses(mono, sr, region)],
     }
     if with_lufs:

perfiles/asr_dialogo_dos_pistas.yaml

@@ -23,6 +23,7 @@ niveles:
 
 ruido:
   ruido_fondo_max_dbfs: -50   # «Background noise: no greater than −50 dB»
+  zumbido_max_db: 10          # «No … electrical noise»: zumbido de red (50/60 Hz) que destaque ≥ 10 dB
 
 silencios: null
 saturacion_max_muestras: 0    # «Clipping: not permitted»

perfiles/multiling_es-es_01.yaml

@@ -5,7 +5,7 @@ descripcion: "Reglas del analizador v4 + SNR ≥ 50 dB: WAV PCM 24 bits · 48 kH
 explicacion: |
   Encargo **MultiLing es-ES 01** (voz femenina, 40 minutos en total).
   - **Qué se comprueba:** lo que pide el cliente (WAV, 48 000 Hz, 24 bits, voz limpia: relación señal/ruido de 50 dB o más) **y las mismas reglas que el analizador v4**: mono, nada por encima de −3 dB, volumen medio de la voz entre −30 y −20 dB, ruido muy bajo y entre 0,5 y 0,7 s de silencio al principio y al final.
-  - **Qué hace la corrección:** arregla solo lo que no cumple y, con el pulido automático, deja el sonido lo más limpio posible si de verdad mejora.
+  - **Qué hace la corrección:** en 🤖 Automático, arregla solo lo que no cumple. En 🥷 Ninja, además, pule el sonido si de verdad mejora.
   - **Seguimiento del encargo (informativo):** la app reconoce por su nombre los 6 ficheros del encargo (nonverbal_laughter, nonverbal_crying y nonverbal_filler words, de 30 s cada uno, y full recording_part 1, 2 y 3) y te dice cuáles llevas y cuánto tiempo sumas. Puedes revisar y corregir cualquier otro audio, se llame como se llame.
 orden: 1
 deteccion_voz: analizador_v4   # mismo detector de voz que el HTML v4 (Gemma comprueba con él)

pipeline.py

@@ -35,7 +35,7 @@ FIX_FOR = {
     "Pico máximo": "picos", "Saturación": "picos", "RMS de voz": "volumen",
     "Ruido relativo (inicio/fin)": "ruido", "Relación señal/ruido (SNR)": "ruido",
     "Silencio inicial": "sil_ini", "Silencio final": "sil_fin",
-    "Amplitud de la voz": "amplitud", "Ruido de fondo": "ruido",
+    "Amplitud de la voz": "amplitud", "Ruido de fondo": "ruido", "Zumbido eléctrico": "zumbido",
 }
 
 
@@ -45,8 +45,28 @@ MODES = {
     "permitido": {"formato", "mono", "frecuencia", "volumen", "picos",  # + niveles y silencios
                   "amplitud", "sil_ini", "sil_fin"},
     "ninja": None,                                                      # todo, + pulido sutil
+    "auto": None,                                                       # lo mínimo que haga falta, sin pulido
 }
-MODE_LABEL = {"formato": "Solo formato", "permitido": "Permitido", "ninja": "Ninja"}
+MODE_LABEL = {"formato": "Solo formato", "permitido": "Permitido", "ninja": "Ninja", "auto": "Automático"}
+
+# Qué nivel hace falta para cada corrección (para decir «ha hecho falta: Permitido»)
+LEVEL_OF = {"formato": "formato", "mono": "formato", "frecuencia": "formato",
+            "volumen": "permitido", "picos": "permitido", "amplitud": "permitido", "sil_ini": "permitido",
+            "sil_fin": "permitido", "pausas": "permitido",
+            "ruido": "ninja", "eventos": "ninja", "zumbido": "ninja"}
+FIX_WORDS = {"formato": "formato", "mono": "canales (a mono)", "frecuencia": "frecuencia", "volumen": "volumen",
+             "picos": "picos", "amplitud": "volumen", "sil_ini": "silencio inicial", "sil_fin": "silencio final",
+             "pausas": "pausas largas", "ruido": "ruido de fondo", "eventos": "ruidos sueltos",
+             "zumbido": "zumbido eléctrico"}
+
+
+def level_used(fixes: set[str]) -> str | None:
+    """Nivel más alto que han necesitado las correcciones aplicadas (None = no se ha tocado)."""
+    levels = {LEVEL_OF.get(f) for f in fixes} - {None}
+    for lv in ("ninja", "permitido", "formato"):
+        if lv in levels:
+            return lv
+    return None
 
 
 def _fixes_for(rows, mode: str = "ninja") -> set[str]:
@@ -109,6 +129,9 @@ class Correction:
     out_path: str | None = None
     notes: list = field(default_factory=list)
     error: str | None = None
+    fixes: set = field(default_factory=set)   # correcciones aplicadas de verdad
+    pulido: bool = False                      # se ha conservado el pulido automático
+    eventos: list = field(default_factory=list)  # ruidos sueltos quitados: [(inicio_s, duración_s, dB)]
 
 
 def _needed_reduction(m: dict, prof: dict) -> float:
@@ -211,6 +234,12 @@ def _apply(data, sr, meta, prof, settings, fixes, att, expander, cache, progress
         x = dsp.resample(x, sr, fmt["frecuencia"])
         notes.append(f"Frecuencia de muestreo cambiada de {sr} a {fmt['frecuencia']} Hz")
         sr = fmt["frecuencia"]
+    if "zumbido" in fixes:
+        zb = metrics.hum(dsp.to_mono(data)[:, 0], meta.samplerate)
+        if zb:
+            x = dsp.remove_hum(x, sr, zb["armonicos"])
+            notes.append(f"Zumbido eléctrico de {zb['base']} Hz quitado (armónicos en "
+                         f"{', '.join(str(int(f)) for f in zb['armonicos'])} Hz); la voz no cambia")
     if "eventos" in fixes:
         if "eventos" not in cache:
             import vad
@@ -321,7 +350,7 @@ def _solve(data, sr, meta, prof, settings, fixes, container, subtype, before_m,
             notes.append(f"Seguía sin cumplir «{', '.join(noise_left)}»: se insiste con más reducción de ruido")
             continue
         break
-    return y, out_sr, rows, notes + step_notes
+    return y, out_sr, rows, notes + step_notes, fixes, (cache.get("eventos") or (None, []))[1]
 
 
 def correct(path: str, prof: dict, settings: Settings, out_dir: Path, progress=None,
@@ -351,13 +380,16 @@ def correct(path: str, prof: dict, settings: Settings, out_dir: Path, progress=N
 
         fixes = _fixes_for(before.rows, settings.modo)
         if settings.modo != "ninja":
-            settings.pulir = False
+            settings.pulir = False  # «auto» es lo mínimo que haga falta: sin pulido
         if settings.forzar_mono and meta.channels > 1:  # pedido expresamente aunque el perfil no lo exija
             fixes.add("mono")
         if settings.acortar_pausas and profiles.long_pauses(before.m, prof):
             fixes.add("pausas")
         if settings.quitar_eventos:
             fixes.add("eventos")
+        zb = before.m.get("zumbido")
+        if settings.modo == "ninja" and zb and zb["db"] >= metrics.HUM_MIN_DB:
+            fixes.add("zumbido")  # en Ninja el zumbido se quita siempre que se detecte
         failing = profiles.failed(before.rows)
         out_dir.mkdir(parents=True, exist_ok=True)
 
@@ -411,7 +443,8 @@ def correct(path: str, prof: dict, settings: Settings, out_dir: Path, progress=N
                          "No se ha tocado: lo que falla no se corrige con este nivel de procesado")
             return res
 
-        y, out_sr, _, step_notes = chosen
+        y, out_sr, _, step_notes, res.fixes, res.eventos = chosen
+        res.pulido = chosen is not base
         notes += step_notes
         out_path = out_dir / (Path(meta.name).stem + ext)
         write_audio(out_path, y, out_sr, container, subtype)

profiles.py

@@ -103,6 +103,13 @@ def check(meta: AudioMeta, m: dict, prof: dict) -> list[Check]:
         rows.append(Check("Espectro (agudos)", "—" if math.isnan(bw) else f"hasta {bw / 1000:.1f} kHz",
                           f"más allá de {fmt['ancho_banda_min_hz'] / 1000:.0f} kHz",
                           (not math.isnan(bw)) and bw >= fmt["ancho_banda_min_hz"]))
+    zb = m.get("zumbido")
+    ztxt = f"{zb['base']} Hz · destaca {zb['db']:.0f} dB" if zb else "no"
+    if nz.get("zumbido_max_db") is not None:
+        rows.append(Check("Zumbido eléctrico", ztxt, f"≤ {nz['zumbido_max_db']:.0f} dB (sin zumbido)",
+                          zb is None or zb["db"] <= nz["zumbido_max_db"]))
+    elif "zumbido" in m:
+        rows.append(Check("Zumbido eléctrico", ztxt, "informativo", None))
     if nz.get("ruido_relativo_max_db") is not None:
         rows.append(Check("Ruido relativo (inicio/fin)", fdb(m["ruido_relativo_db"], "dB"),
                           f"≤ {fdb(nz['ruido_relativo_max_db'], 'dB')} vs voz", m["ruido_relativo_db"] <= nz["ruido_relativo_max_db"]))

report.py

@@ -18,7 +18,9 @@ COLUMNS = [
     ("estado_inicial", "Estado inicial"),
     ("estado_final", "Estado final"),
     ("fallos", "Qué fallaba"),
-    ("notas", "Qué se ha hecho"),
+    ("nivel", "Nivel de procesado usado"),
+    ("cambios", "Qué se ha cambiado"),
+    ("notas", "Qué se ha hecho (detalle)"),
     ("formato", "Formato original"),
     ("pico_antes", "Pico antes (dBFS)"), ("pico_despues", "Pico después (dBFS)"),
     ("rms_antes", "RMS voz antes (dBFS)"), ("rms_despues", "RMS voz después (dBFS)"),
@@ -27,6 +29,9 @@ COLUMNS = [
     ("sil_ini_antes", "Silencio inicial antes (s)"), ("sil_ini_despues", "Silencio inicial después (s)"),
     ("sil_fin_antes", "Silencio final antes (s)"), ("sil_fin_despues", "Silencio final después (s)"),
     ("dnsmos_antes", "Nota de calidad antes"), ("dnsmos_despues", "Nota de calidad después"),
+    ("d_pico", "Δ Pico (dB)"), ("d_rms", "Δ RMS voz (dB)"), ("d_ruido", "Δ Ruido de fondo (dB)"),
+    ("d_snr", "Δ SNR (dB)"), ("d_dnsmos", "Δ Nota de calidad"),
+    ("ruidos_quitados", "Ruidos sueltos quitados"),
 ]
 
 
@@ -36,6 +41,11 @@ def _num(v, nd=2):
     return round(float(v), nd)
 
 
+def _delta(a, b):
+    a, b = _num(a), _num(b)
+    return None if a is None or b is None else round(b - a, 2)
+
+
 def build_rows(items: list[dict]) -> list[dict]:
     """items: [{'nombre','duracion_s','estado_inicial','estado_final','formato','antes':m,'despues':m,'fallos','notas'}]"""
     rows = []
@@ -57,6 +67,14 @@ def build_rows(items: list[dict]) -> list[dict]:
             row[f"{key}_despues"] = _num(d.get(mk))
         row["dnsmos_antes"] = _num((a.get("dnsmos") or {}).get("OVRL"))
         row["dnsmos_despues"] = _num((d.get("dnsmos") or {}).get("OVRL"))
+        for key, mk in (("d_pico", "pico_dbfs"), ("d_rms", "rms_voz_dbfs"), ("d_ruido", "ruido_fondo_dbfs"),
+                        ("d_snr", "snr_db")):
+            row[key] = _delta(a.get(mk), d.get(mk))
+        row["d_dnsmos"] = _delta(row["dnsmos_antes"], row["dnsmos_despues"])
+        row["nivel"] = it.get("nivel", "")
+        row["cambios"] = ", ".join(it.get("cambios") or [])
+        row["ruidos_quitados"] = next((n.split("—", 1)[-1].strip() for n in it.get("notas") or []
+                                       if n.startswith("Ruidos sueltos en las pausas sustituidos")), "")
         rows.append(row)
     return rows
 
@@ -85,7 +103,7 @@ def write_xlsx(path: Path, rows: list[dict], perfil: str, resumen: list[tuple[st
     ws.cell(ws.max_row, 1).font = Font(bold=True)
     ws.cell(ws.max_row, 2).number_format = "[h]:mm:ss"
     ws.cell(ws.max_row, 2).font = Font(bold=True)
-    widths = {1: 34, 2: 11, 3: 16, 4: 24, 5: 40, 6: 90, 7: 34}
+    widths = {1: 34, 2: 11, 3: 16, 4: 24, 5: 40, 6: 14, 7: 40, 8: 90, 9: 34}
     for i in range(1, len(COLUMNS) + 1):
         ws.column_dimensions[get_column_letter(i)].width = widths.get(i, 13)
     ws.freeze_panes = "B2"

spectro.py

@@ -0,0 +1,107 @@
+"""
+spectro.py — Espectrogramas de antes, después y su diferencia (para curiosos).
+
+Frecuencia lineal hasta la máxima del fichero, para que se vea bien lo que hay por encima de 20 kHz.
+Para que audios de media hora no cuesten nada, cada columna de la imagen es la media de unas pocas
+FFT repartidas por su tramo (como mucho ~1600 columnas por imagen).
+Diferencia: si los dos audios están alineados (misma frecuencia y misma duración) es «después − antes»
+en cada punto (azul = se ha quitado, rojo = se ha añadido); si no (se han recortado silencios o pausas,
+o se ha cambiado la frecuencia), se compara el espectro medio de los dos.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+
+import dsp
+from audio_io import read_audio
+
+NFFT = 2048
+MAX_COLS = 1600
+SUB = 4
+
+
+def _spec(mono: np.ndarray, sr: int) -> tuple[np.ndarray, np.ndarray, float]:
+    """Devuelve (dB [frecuencias × columnas], frecuencias, segundos por columna)."""
+    n = len(mono)
+    cols = int(min(MAX_COLS, max(1, (n - NFFT) // (NFFT // 2))))
+    hop = max(1, (n - NFFT) / cols) if n > NFFT else 1
+    win = np.hanning(NFFT).astype(np.float32)
+    out = np.empty((NFFT // 2 + 1, cols), dtype=np.float32)
+    x = np.pad(mono.astype(np.float32), (0, NFFT))
+    for c in range(cols):
+        starts = (c * hop + np.linspace(0, max(0.0, hop - NFFT), SUB)).astype(int) if hop > NFFT else [int(c * hop)]
+        p = np.mean([np.abs(np.fft.rfft(x[s : s + NFFT] * win)) ** 2 for s in starts], axis=0)
+        out[:, c] = 10 * np.log10(np.maximum(p / (NFFT * win.sum() / 2), 1e-20))
+    return out, np.fft.rfftfreq(NFFT, 1 / sr), hop / sr
+
+
+def make_png(before: str, after: str, png: Path) -> str | None:
+    try:
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+
+        da, sra, _ = read_audio(before)
+        db, srb, _ = read_audio(after)
+        ma, mb = dsp.to_mono(da)[:, 0], dsp.to_mono(db)[:, 0]
+        sa, fa, ta = _spec(ma, sra)
+        sb, fb, tb = _spec(mb, srb)
+        aligned = sra == srb and len(ma) == len(mb)
+        fig, axes = plt.subplots(3, 1, figsize=(11, 8.4), gridspec_kw={"height_ratios": [1, 1, 1]})
+        fig.patch.set_facecolor("#14141f")
+        vmax = float(max(np.percentile(sa, 99.9), np.percentile(sb, 99.9)))
+        for ax, S, f, t, title in ((axes[0], sa, fa, ta, "Antes"), (axes[1], sb, fb, tb, "Después")):
+            im = ax.imshow(S, origin="lower", aspect="auto", cmap="magma", vmin=vmax - 110, vmax=vmax,
+                           extent=[0, S.shape[1] * t, 0, f[-1] / 1000])
+            ax.set_title(title, color="white", fontsize=10, loc="left")
+            ax.set_ylabel("kHz", color="#ddd")
+            cb = fig.colorbar(im, ax=ax, pad=0.01)
+            cb.set_label("dB", color="#ddd")
+            cb.ax.tick_params(colors="#ddd", labelsize=8)
+        ax = axes[2]
+        if aligned:
+            d = np.clip(sb - sa, -30, 30)
+            im = ax.imshow(d, origin="lower", aspect="auto", cmap="RdBu_r", vmin=-30, vmax=30,
+                           extent=[0, d.shape[1] * ta, 0, fa[-1] / 1000])
+            ax.set_title("Diferencia (después − antes): azul = se ha quitado · rojo = se ha añadido",
+                         color="white", fontsize=10, loc="left")
+            ax.set_ylabel("kHz", color="#ddd")
+            cb = fig.colorbar(im, ax=ax, pad=0.01)
+            cb.set_label("dB", color="#ddd")
+            cb.ax.tick_params(colors="#ddd", labelsize=8)
+            ax.set_xlabel("Tiempo (s)", color="#ddd")
+        else:
+            la = 10 * np.log10(np.mean(10 ** (sa / 10), axis=1))
+            lb = 10 * np.log10(np.mean(10 ** (sb / 10), axis=1))
+            fmax = min(fa[-1], fb[-1])
+            grid = np.linspace(0, fmax, 1000)
+            ia, ib = np.interp(grid, fa, la), np.interp(grid, fb, lb)
+            ax.plot(grid / 1000, ia, color="#f0a050", lw=1, label="Antes")
+            ax.plot(grid / 1000, ib, color="#50c0f0", lw=1, label="Después")
+            ax2 = ax.twinx()
+            diff = np.convolve(ib - ia, np.ones(15) / 15, mode="same")  # suavizado para leer la tendencia
+            ax2.plot(grid / 1000, diff, color="#e05080", lw=1.2, alpha=.9, label="Diferencia")
+            ax2.axhline(0, color="#888", lw=.6)
+            ax2.set_ylabel("Diferencia (dB)", color="#e05080")
+            ax2.tick_params(colors="#ddd", labelsize=8)
+            ax.set_title("Espectro medio (la duración ha cambiado, así que se compara el promedio)",
+                         color="white", fontsize=10, loc="left")
+            ax.set_xlabel("kHz", color="#ddd")
+            ax.set_ylabel("dB", color="#ddd")
+            ax.legend(loc="upper right", fontsize=8)
+            ax.set_facecolor("#14141f")
+        for a in axes:
+            a.tick_params(colors="#ddd", labelsize=8)
+        axes[0].set_xlabel("")
+        axes[1].set_xlabel("Tiempo (s)", color="#ddd")
+        fig.tight_layout()
+        fig.savefig(png, dpi=100, facecolor=fig.get_facecolor())
+        plt.close(fig)
+        return str(png)
+    except Exception as e:  # una imagen nunca debe romper la corrección
+        print(f"[ESPECTRO] {e}")
+        return None

ui_html.py

@@ -93,6 +93,31 @@ CSS = """
 .ad-chg .d-same { opacity: .6; }
 .ad-chg tr.changed td:first-child { font-weight: 700; }
 .ad-chg-h { padding: .5rem .9rem .1rem; font-weight: 700; font-size: .92rem; }
+#auto-toggle { border: 2px solid var(--color-accent); border-radius: 1rem; padding: .7rem 1rem !important;
+               transition: background .2s, box-shadow .2s; }
+#auto-toggle:has(input:checked) { background: rgba(20, 184, 166, .14); box-shadow: 0 0 0 4px rgba(20, 184, 166, .22); }
+#auto-toggle label > span, #auto-toggle .label-text { font-size: 1.15rem; font-weight: 800; }
+#auto-toggle input[type=checkbox] { width: 1.5rem; height: 1.5rem; }
+#auto-toggle span { color: var(--body-text-color) !important; opacity: 1 !important; }
+.ad-card { overflow-x: auto; }
+.ad-version { text-align: center; font-size: .75rem; opacity: .55; padding: .6rem 0 .2rem; }
+.ad-update { padding: .6rem .9rem; border-radius: .7rem; background: rgba(230, 150, 30, .16); font-weight: 600; }
+.ad-verdict { padding: .65rem .9rem; font-weight: 700; font-size: 1.02rem; border-bottom: 1px solid var(--border-color-primary); }
+.ad-verdict.ok { background: rgba(26,158,85,.13); }
+.ad-verdict.bad { background: rgba(208,69,58,.13); }
+.ad-verdict.fix { background: rgba(230,150,30,.15); }
+.ad-verdict small { display: block; font-weight: 400; font-size: .85rem; opacity: .85; margin-top: .15rem; }
+.ad-ab { display: grid; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); gap: .4rem .8rem;
+         padding: .6rem .9rem; border-bottom: 1px solid var(--border-color-primary); align-items: center; }
+.ad-ab span { font-size: .78rem; font-weight: 700; opacity: .75; display: block; }
+.ad-ab audio { width: 100%; height: 36px; }
+.ad-ab button, .ad-ev button { cursor: pointer; border-radius: .5rem; border: 1px solid var(--border-color-primary);
+         background: var(--background-fill-secondary); padding: .3rem .7rem; font-size: .85rem; color: inherit; }
+.ad-ev { padding: .2rem .9rem .6rem; font-size: .85rem; border-bottom: 1px solid var(--border-color-primary); }
+.ad-ev button { margin: .15rem .2rem 0 0; padding: .15rem .5rem; font-variant-numeric: tabular-nums; }
+.ad-spec { padding: .5rem .9rem .8rem; border-top: 1px solid var(--border-color-primary); font-size: .86rem; }
+.ad-spec summary { cursor: pointer; font-weight: 700; }
+.ad-spec img { width: 100%; height: auto; margin-top: .5rem; border-radius: .4rem; }
 .ad-empty { opacity: .65; text-align: center; padding: 1.5rem; }
 @media (max-width: 640px) {
   .ad-table th.req, .ad-table td.req { display: none; }
@@ -120,6 +145,21 @@ HEAD = """
     if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', apply); else apply();
   } catch (e) {}
 })();
+// Reproductor antes/después: cambiar al otro en el mismo punto y saltar a un minuto
+window.adSwap = function (id) {
+  var a = document.getElementById(id + '-a'), b = document.getElementById(id + '-b');
+  if (!a || !b) return;
+  var from = (!b.paused || (a.paused && b.currentTime > 0 && b.dataset.last === '1')) ? b : a;
+  var to = from === a ? b : a;
+  var t = from.currentTime; from.pause(); a.dataset.last = b.dataset.last = '0';
+  to.currentTime = t; to.dataset.last = '1'; to.play();
+};
+window.adSeek = function (id, t) {
+  var a = document.getElementById(id + '-a'), b = document.getElementById(id + '-b');
+  var p = (b && !b.paused) ? b : a;
+  [a, b].forEach(function (x) { if (x) { x.pause(); x.currentTime = Math.max(0, t); } });
+  if (p) p.play();
+};
 </script>
 """
 
@@ -434,10 +474,55 @@ def changes_table(meta_b, meta_a, m_b: dict, m_a: dict, rows_b, rows_a, pause_ma
     return "".join(h)
 
 
+_uid = [0]
+
+
+def _player(original: str | None, corrected: str | None, events: list | None) -> str:
+    """Reproductor antes/después (y saltos a los ruidos quitados)."""
+    if not original and not corrected:
+        return ""
+    _uid[0] += 1
+    pid = f"ab{_uid[0]}"
+    h = ['<div class="ad-ab">']
+    if original:
+        h.append(f'<div><span>🎧 Original</span><audio id="{pid}-a" src="{escape(original)}" controls preload="none">'
+                 '</audio></div>')
+    if corrected:
+        h.append(f'<div><span>✨ Corregido</span><audio id="{pid}-b" src="{escape(corrected)}" controls '
+                 'preload="none"></audio></div>')
+    if original and corrected:
+        h.append(f'<div><button type="button" onclick="adSwap(\'{pid}\')">⇄ Cambiar al otro en el mismo punto'
+                 '</button></div>')
+    h.append("</div>")
+    if events:
+        btns = "".join(f'<button type="button" onclick="adSeek(\'{pid}\',{max(0.0, t - 1.5):.2f})">'
+                       f'{fmt_duration(t)}</button>' for t, _, _ in events[:40])
+        h.append(f'<div class="ad-ev">🔇 Ruidos sueltos quitados (pulsa para escuchar ese momento): {btns}</div>')
+    return "".join(h)
+
+
+def verdict(cls: str, text: str, detail: str = "") -> str:
+    small = f"<small>{escape(detail)}</small>" if detail else ""
+    return f'<div class="ad-verdict {cls}">{escape(text)}{small}</div>'
+
+
+def spectro(url: str | None) -> str:
+    if not url:
+        return ""
+    return ('<details class="ad-spec"><summary>🔬 Espectrogramas: antes, después y diferencia</summary>'
+            f'<img loading="lazy" src="{escape(url)}" alt="Espectrogramas"></details>')
+
+
+def glossary_all(rows) -> str:
+    """Glosario único para todas las tarjetas."""
+    return _glossary(rows).replace("¿Qué significa cada fila?", "¿Qué significa cada medida?")
+
+
 def card(name: str, meta_line: str, badge: tuple[str, str], rows_before, rows_after=None,
          notes: list[str] | None = None, error: str | None = None, download: str | None = None,
          m_before: dict | None = None, m_after: dict | None = None, meta_before=None, meta_after=None,
-         pause_max: float | None = None) -> str:
+         pause_max: float | None = None, verdict_html: str = "", original: str | None = None,
+         events: list | None = None, spec_url: str | None = None) -> str:
     cls, text = badge
     dl = ""
     if download:
@@ -449,6 +534,8 @@ def card(name: str, meta_line: str, badge: tuple[str, str], rows_before, rows_af
     if error:
         h.append(f'<div class="ad-notes">⚠️ {escape(error)}</div></div>')
         return "".join(h)
+    h.append(verdict_html)
+    h.append(_player(original, download if rows_after is not None else None, events))
     if rows_before:
         h.append(_summary_box(rows_before, rows_after, notes, m_before, m_after))
     if rows_after is not None and m_before and m_after and meta_before is not None and meta_after is not None:
@@ -457,7 +544,7 @@ def card(name: str, meta_line: str, badge: tuple[str, str], rows_before, rows_af
             h.append('<div class="ad-notes"><strong>Qué se ha hecho, paso a paso</strong><ul>')
             h += [f"<li>{escape(n)}</li>" for n in notes]
             h.append("</ul></div>")
-        h.append(_glossary(rows_before))
+        h.append(spectro(spec_url))
         h.append("</div>")
         return "".join(h)
     h.append('<table class="ad-table"><thead><tr><th>Parámetro</th>')
@@ -480,7 +567,6 @@ def card(name: str, meta_line: str, badge: tuple[str, str], rows_before, rows_af
         h.append('<div class="ad-notes"><strong>Qué se ha hecho, paso a paso</strong><ul>')
         h += [f"<li>{escape(n)}</li>" for n in notes]
         h.append("</ul></div>")
-    h.append(_glossary(rows_before))
     h.append("</div>")
     return "".join(h)