fea-audio-player: limpiar el aviso de error cuando el audio sí llega a reproducir

Si audio.play() fallaba tras verificar el hash (p.ej. política de autoplay
del navegador tras el await de fetch+digest), el aviso "No se pudo verificar
el audio" quedaba fijo en pantalla aunque el usuario reprodujera el audio a
mano desde los controles nativos que ya estaban visibles. El evento 'play'
real del <audio> ahora limpia ese aviso y oculta el botón, sea cual sea el
camino por el que arrancó la reproducción.

Reportado por Rafa en el canal feadulta, viendo el estado atascado en
"Más allá de la trinchera..." (post 56196) tras el bloqueo 403 de Cloudflare.

README.md

@@ -32,8 +32,40 @@ scripts/      — scripts Python/PHP de migración, traducción, TTS y mantenimi
 | `translate_haiku.py` | Traducción automática vía Claude Haiku |
 | `tts_produce.py` | Generación de audio TTS (MiniMax) |
 | `sync_translations_to_prod.py` | Sincronizar traducciones local → producción |
+| `sync_audio_to_prod.py` | Sincronizar UN post/carta de audio TTS local → producción (sube el mp3, verifica SHA-256 remoto y persiste `fea_audio_sha256`) |
+| `sync_audio_bulk.sh` | Envoltorio de `sync_audio_to_prod.py` para lotes: para en el primer fallo, sin reintentos ciegos, resumen ok/skip |
 | `detect_untranslated.php` | Detectar posts sin traducir |
 
+## Sincronizar audio TTS a producción (local → prod)
+
+`sync_audio_to_prod.py` sube el mp3 de UN post/carta y, desde el #213, calcula y verifica el
+SHA-256 en cada subida (reproducción verificada automática, sin backfill manual — ver #212).
+
+Para lotes de varios posts, usar `sync_audio_bulk.sh`: es el envoltorio que añade "parar en el
+primer fallo" (el script Python no lo hace por sí solo, recorre toda la lista y acumula errores).
+Carga los IDs con `mapfile`/mediante array y redirige el stdin de cada invocación a `/dev/null` a
+propósito — un `while read id; do ...ssh...; done < fichero` sin esa precaución se rompe en
+silencio porque `ssh` se come el resto del fichero de IDs (ver
+`feedback-bash-while-read-ssh-stdin` en la memoria del proyecto).
+
+```bash
+export FEA_PROD_SSH_HOST="rafa@188.40.120.157"
+export FEA_PROD_DOCKER_CONTAINER="wordpress-r2ssjifwj0r0ghyoqd528uaa"
+
+# Dry-run primero, siempre
+scripts/sync_audio_bulk.sh --ids 55519,55520,822 --dry-run
+
+# Aplicar de verdad
+scripts/sync_audio_bulk.sh --ids 55519,55520,822
+
+# Desde un fichero (un ID por línea) o toda la cola de una carta
+scripts/sync_audio_bulk.sh --file /tmp/ids_pendientes.txt
+scripts/sync_audio_bulk.sh --carta 54254
+```
+
+Rollback de un post concreto: `python3 scripts/sync_audio_to_prod.py --rollback --ids <id>`
+(borra el meta en prod, no toca el mp3 local).
+
 ## Servidor local de desarrollo
 
 WordPress corre en Docker local, accesible vía Tailscale:

mu-plugins/fea-audio-player.php

@@ -13,11 +13,23 @@ function fea_audio_player_html(): string {
     $url = get_post_meta($id, 'fea_audio_url', true);
     if (!$url) return '';
     $voice = get_post_meta($id, 'fea_audio_voice', true) ?: 'NicoFeadulta2026';
-    return '<div class="fea-audio">'
-        . '<span class="fea-audio-label">'
+    $sha256 = get_post_meta($id, 'fea_audio_sha256', true);
+    $label = '<span class="fea-audio-label">'
         . '<svg viewBox="0 0 24 24" width="16" height="16" aria-hidden="true" focusable="false">'
         . '<path fill="currentColor" d="M3 10v4h4l5 5V5L7 10H3zm13.5 2a4.5 4.5 0 0 0-2.5-4.03v8.06A4.5 4.5 0 0 0 16.5 12zM14 3.23v2.06a7 7 0 0 1 0 13.42v2.06a9 9 0 0 0 0-17.54z"/>'
-        . '</svg> Escucha</span>'
+        . '</svg> Escucha</span>';
+    // Para un asset con hash registrado, descarga y verifica el fichero completo
+    // antes de delegar playback al navegador. Evita que un stream Range mezclado
+    // por una caché reproduzca fragmentos de otro MP3.
+    if (preg_match('/^[a-f0-9]{64}$/i', $sha256)) {
+        return '<div class="fea-audio">' . $label
+            . '<button type="button" class="fea-audio-verified-play" data-fea-audio-verified-play'
+            . ' data-src="' . esc_url($url) . '" data-sha256="' . esc_attr(strtolower($sha256)) . '"'
+            . ' data-post-id="' . esc_attr($id) . '" data-voice="' . esc_attr($voice) . '">Reproducir audio</button>'
+            . '<audio controls preload="none" hidden data-fea-audio-track data-post-id="' . esc_attr($id) . '" data-voice="' . esc_attr($voice) . '"></audio>'
+            . '<span class="fea-audio-status" role="status" aria-live="polite"></span></div>';
+    }
+    return '<div class="fea-audio">' . $label
         . '<audio controls preload="none" src="' . esc_url($url) . '"'
         . ' data-fea-audio-track data-post-id="' . esc_attr($id) . '" data-voice="' . esc_attr($voice) . '"></audio>'
         . '</div>';
@@ -56,6 +68,9 @@ add_action('wp_head', function () {
     .fea-audio-label{display:inline-flex;align-items:center;gap:.35rem;font-size:.78rem;
         font-weight:600;color:#8b1a2e;white-space:nowrap;line-height:1}
     .fea-audio audio{height:32px;width:230px;max-width:44vw}
+    .fea-audio-verified-play{border:1px solid #8b1a2e;border-radius:6px;background:#fff;color:#8b1a2e;padding:.35rem .6rem;font:inherit;font-size:.82rem;font-weight:600;cursor:pointer}
+    .fea-audio-verified-play:disabled{opacity:.65;cursor:wait}
+    .fea-audio-status{font-size:.76rem;color:#6b5c60}
     @media(max-width:600px){
         .fea-audio{margin-left:0;width:100%;margin-top:.5rem}
         .fea-audio audio{flex:1 1 auto;width:auto;max-width:none}
@@ -73,17 +88,64 @@ add_action('wp_footer', function () {
     if (!get_post_meta(get_queried_object_id(), 'fea_audio_url', true)) return;
     ?>
     <script>
-    document.querySelectorAll('audio[data-fea-audio-track]').forEach(function (audio) {
-        var fired = false;
-        audio.addEventListener('play', function () {
-            if (fired || typeof gtag !== 'function') return;
-            fired = true;
-            gtag('event', 'audio_play', {
-                post_id: audio.dataset.postId,
-                voice: audio.dataset.voice
+    (function () {
+        function hex(buffer) {
+            return Array.from(new Uint8Array(buffer)).map(function (n) {
+                return n.toString(16).padStart(2, '0');
+            }).join('');
+        }
+        document.querySelectorAll('[data-fea-audio-verified-play]').forEach(function (button) {
+            button.addEventListener('click', async function () {
+                var wrap = button.closest('.fea-audio');
+                var audio = wrap.querySelector('audio[data-fea-audio-track]');
+                var status = wrap.querySelector('.fea-audio-status');
+                button.disabled = true;
+                status.textContent = 'Verificando audio…';
+                try {
+                    // Se descarga el objeto entero una vez y se valida su hash. Sólo
+                    // entonces se crea un blob local: el <audio> no hará Range contra
+                    // CDN y jamás podrá mezclar fragmentos de otro MP3.
+                    var response = await fetch(button.dataset.src, {cache: 'no-store'});
+                    if (!response.ok) throw new Error('HTTP ' + response.status);
+                    var bytes = await response.arrayBuffer();
+                    var digest = hex(await crypto.subtle.digest('SHA-256', bytes));
+                    if (digest !== button.dataset.sha256) throw new Error('La copia recibida no coincide con el audio verificado');
+                    audio.src = URL.createObjectURL(new Blob([bytes], {type: 'audio/mpeg'}));
+                    audio.hidden = false;
+                    button.hidden = true;
+                    status.textContent = '';
+                    await audio.play();
+                } catch (error) {
+                    status.textContent = 'No se pudo verificar el audio. Inténtalo de nuevo.';
+                    button.disabled = false;
+                    console.error('Fe Adulta audio verification failed:', error);
+                }
             });
         });
-    });
+        document.querySelectorAll('audio[data-fea-audio-track]').forEach(function (audio) {
+            var fired = false;
+            audio.addEventListener('play', function () {
+                // La verificación pudo fallar en el primer intento (p.ej. audio.play()
+                // rechazado por política de autoplay tras el await de verificación) y
+                // dejar el mensaje de error en pantalla. Si el audio realmente rompe a
+                // reproducir -en este intento o en uno posterior desde los controles
+                // nativos-, ese es el estado real: limpiar el aviso y ocultar el botón.
+                var wrap = audio.closest('.fea-audio');
+                if (wrap) {
+                    var status = wrap.querySelector('.fea-audio-status');
+                    if (status) status.textContent = '';
+                    var button = wrap.querySelector('[data-fea-audio-verified-play]');
+                    if (button) button.hidden = true;
+                }
+                if (fired || typeof gtag !== 'function') return;
+                fired = true;
+                gtag('event', 'audio_play', {
+                    post_id: audio.dataset.postId,
+                    voice: audio.dataset.voice
+                });
+            });
+        });
+    }());
     </script>
     <?php
 });

scripts/doc_convert.py

@@ -0,0 +1,79 @@
+"""doc_convert.py — convierte un .doc viejo a .docx usando Microsoft Word (COM).
+
+Necesario para Marcos (marroro@telefonica.net), que envía .doc (Word antiguo) y
+python-docx no sabe leer .doc. El contenido ya viene en EML (lo etiqueta Inma al
+revisar); aquí solo cambiamos el FORMATO de archivo.
+
+Requiere Microsoft Word instalado + pywin32 (igual que marcos_review).
+API: doc_to_docx(path, force=False) -> Path | None
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+WD_FORMAT_DOCX = 16  # wdFormatDocumentDefault (.docx)
+
+
+def doc_to_docx(path, force: bool = False):
+    """Convierte un .doc a .docx con Word COM. Idempotente: si el .docx ya existe y
+    no force, lo devuelve sin reconvertir. Devuelve la ruta .docx, o None si falla."""
+    path = Path(path)
+    if path.suffix.lower() != ".doc":
+        return None
+    out = path.with_suffix(".docx")
+    if out.exists() and not force:
+        return out
+    try:
+        import win32com.client  # type: ignore
+    except ImportError:
+        return None
+    word = win32com.client.Dispatch("Word.Application")
+    word.Visible = False
+    try:
+        d = word.Documents.Open(str(path))
+        d.SaveAs(str(out), FileFormat=WD_FORMAT_DOCX)
+        d.Close(SaveChanges=False)
+    finally:
+        word.Quit()
+    if out.exists():
+        quitar_smarttags(out)
+    return out if out.exists() else None
+
+
+def quitar_smarttags(docx_path) -> int:
+    """Desenvuelve los <w:smartTag> del .docx. Devuelve cuántos ha quitado.
+
+    ⚠️ CRÍTICO, no es cosmético. Los .doc de Fray Marcos traen `smartTag` (el viejo
+    reconocimiento de nombres de Word) envolviendo expresiones como "la Iglesia" o
+    "la Cananea". **python-docx solo lee los <w:r> que cuelgan directamente del párrafo,
+    así que el texto de dentro del smartTag DESAPARECE sin dar error**: se publicaron
+    frases mutiladas en las cartas 736, 737 y 739 ("...no va dirigida a los apóstoles,
+    sino a dureza de la respuesta..."). Detectado el 12-ago-2026.
+    """
+    import re, shutil, zipfile
+    from pathlib import Path
+
+    docx_path = Path(docx_path)
+    with zipfile.ZipFile(docx_path) as z:
+        piezas = {n: z.read(n) for n in z.namelist()}
+    xml = piezas.get("word/document.xml", b"").decode("utf-8", "replace")
+    nuevo, n = re.subn(r"</?w:smartTag(?:Pr)?\b[^>]*>|<w:attr\b[^>]*/>", "", xml)
+    if not n:
+        return 0
+    piezas["word/document.xml"] = nuevo.encode("utf-8")
+    tmp = docx_path.with_suffix(".docx.tmp")
+    with zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED) as z:
+        for nombre, datos in piezas.items():
+            z.writestr(nombre, datos)
+    shutil.move(str(tmp), str(docx_path))
+    return n
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("uso: python doc_convert.py path/al/archivo.doc", file=sys.stderr)
+        sys.exit(2)
+    res = doc_to_docx(Path(sys.argv[1]), force="--force" in sys.argv)
+    print(f"OK: {res}" if res else "FALLO (¿Word/pywin32?)")
+    sys.exit(0 if res else 1)

scripts/generate_liturgical_calendar.py

@@ -1,435 +0,0 @@
-#!/usr/bin/env python3
-"""Genera la tabla fecha -> entrada del libro (book_index 1-500) + ciclo A/B/C
-para el shortcode del Evangelio de cada día, 2026-2040.
-
-Reescritura completa (issue #20) tras retirar el commit 2713e13: aquella
-version numeraba los domingos con un desfase de -1, contaba Cuaresma en
-bloques de 7 desde Ceniza, evaluaba Adviento antes que Navidad (fuga el
-26-31 de diciembre), y dejaba sin clave propia Bautismo/Ascension/Familia de
-Nazaret/Cristo Rey, ademas de dar precedencia a fiestas fijas (Anunciacion,
-San Juan Bautista...) sobre domingos y hasta sobre la Pascua misma.
-
-Diseño distinto a proposito: en vez de una clave de texto libre (que hay que
-mantener sincronizada a mano con el vocabulario del libro), cada fecha
-referencia directamente el `source_index` (1-500) de
-data/evangelio-diario/entradas-libro.json. Los tests de este fichero
-comprueban cobertura bidireccional contra esas 500 entradas.
-
-Fuentes:
-- Computo de Pascua: algoritmo gregoriano (Meeus/Jones/Butcher), independiente
-  de cualquier tabla publicada.
-- Normas Universales sobre el Año Litúrgico y el Calendario (1969): tabla de
-  precedencia (Adviento/Cuaresma/Pascua > solemnidades fijas; entre
-  solemnidades fijas del Señor > de un Santo) y regla especifica de traslado
-  de la Anunciación.
-- Practica de la CEE: Ascensión y Corpus Christi trasladados al domingo.
-- CEE, "Tabla temporal de las principales celebraciones del Año Litúrgico
-  2021-2044" (referencia general, NO la unica fuente usada para validar --
-  ver issue #20 para el detalle de fuentes cruzadas independientes).
-"""
-from __future__ import annotations
-
-from datetime import date, timedelta
-import json
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-BOOK_PATH = ROOT / "data/evangelio-diario/entradas-libro.json"
-OUT_PATH = ROOT / "data/evangelio-diario/calendario-liturgico-2026-2040.json"
-
-YEAR_FROM = 2026
-YEAR_TO = 2040
-
-
-def easter_sunday(year: int) -> date:
-    a = year % 19
-    b = year // 100
-    c = year % 100
-    d_ = b // 4
-    e = b % 4
-    f = (b + 8) // 25
-    g = (b - f + 1) // 3
-    h = (19 * a + b - d_ - g + 15) % 30
-    i = c // 4
-    k = c % 4
-    l = (32 + 2 * e + 2 * i - h - k) % 7
-    m = (a + 11 * h + 22 * l) // 451
-    month = (h + l - 7 * m + 114) // 31
-    day = ((h + l - 7 * m + 114) % 31) + 1
-    return date(year, month, day)
-
-
-def prev_sunday_on_or_before(d: date) -> date:
-    return d - timedelta(days=(d.weekday() + 1) % 7)
-
-
-def next_sunday_on_or_after(d: date) -> date:
-    return d + timedelta(days=(6 - d.weekday()) % 7)
-
-
-def cycle_for_civil_year(y: int) -> str:
-    return {1: "A", 2: "B", 0: "C"}[y % 3]
-
-
-class YearFacts:
-    """Fechas moviles/fijas derivadas de la Pascua y de Navidad para el año
-    civil `y`. El tramo de Adviento/Navidad de diciembre de `y` referencia el
-    ciclo A/B/C del año litúrgico SIGUIENTE (y+1), que es el que empieza."""
-
-    def __init__(self, y: int):
-        self.y = y
-        self.easter = easter_sunday(y)
-        self.ash_wed = self.easter - timedelta(days=46)
-        self.palm_sunday = self.easter - timedelta(days=7)
-        self.holy_mon = self.easter - timedelta(days=6)
-        self.holy_tue = self.easter - timedelta(days=5)
-        self.holy_wed = self.easter - timedelta(days=4)
-        self.holy_thu = self.easter - timedelta(days=3)
-        self.good_fri = self.easter - timedelta(days=2)
-        self.holy_sat = self.easter - timedelta(days=1)
-        self.pentecost = self.easter + timedelta(days=49)
-        self.trinity = self.pentecost + timedelta(days=7)
-        self.corpus = self.trinity + timedelta(days=7)      # trasladado a domingo (CEE)
-        self.ascension = self.easter + timedelta(days=42)    # trasladada al 7º domingo (CEE)
-
-        self.epiphany = date(y, 1, 6)
-        self.baptism = (
-            self.epiphany + timedelta(days=1)
-            if self.epiphany.weekday() == 6
-            else next_sunday_on_or_after(self.epiphany)
-        )
-
-        xmas_prev = date(y - 1, 12, 25)
-        self.holy_family = (
-            date(y - 1, 12, 30)
-            if xmas_prev.weekday() == 6
-            else next_sunday_on_or_after(xmas_prev)
-        )
-
-        cand = next_sunday_on_or_after(date(y, 1, 2))
-        self.dom2_navidad = cand if cand.day <= 5 else None
-
-        self.christmas = date(y, 12, 25)
-        sun_before_xmas_eve = prev_sunday_on_or_before(self.christmas - timedelta(days=1))
-        self.advent1 = sun_before_xmas_eve - timedelta(days=21)
-        self.advent2 = self.advent1 + timedelta(days=7)
-        self.advent3 = self.advent1 + timedelta(days=14)
-        self.advent4 = self.advent1 + timedelta(days=21)
-        self.christ_king = self.advent1 - timedelta(days=7)
-
-        # Numeracion de Tiempo Ordinario con omision de semanas (norma real:
-        # se cuenta hacia atras desde Cristo Rey=semana 34). L = ultima semana
-        # de TO alcanzada (entera o parcial) antes de Ceniza.
-        self.week2_sunday = self.baptism + timedelta(days=7)
-        self.L = 2 + (self.ash_wed - self.week2_sunday).days // 7
-        first_post = self.corpus + timedelta(days=7)
-        self.K = (self.christ_king - first_post).days // 7 + 1
-        self.resume_week = 35 - self.K
-
-
-def lent_week_base(n: int) -> int:
-    return {1: 145, 2: 154, 3: 163, 4: 172, 5: 181}[n]
-
-
-def ot_week_base(n: int) -> int:
-    """idx base [DomA,DomB,DomC,Lun..Sab] de la semana N de TO (2..34)."""
-    if 2 <= n <= 9:
-        return 69 + (n - 2) * 9
-    if 10 <= n <= 33:
-        return 265 + (n - 10) * 9
-    if n == 34:
-        return 481
-    raise ValueError(f"semana de TO fuera de rango: {n}")
-
-
-CYC_OFFSET = {"A": 0, "B": 1, "C": 2}
-
-
-def build_calendar(year_from: int, year_to: int) -> dict[str, dict]:
-    facts = {y: YearFacts(y) for y in range(year_from - 1, year_to + 2)}
-    out: dict[str, dict] = {}
-
-    def set_day(d: date, idx: int, cyc: str, note: str) -> None:
-        iso = d.isoformat()
-        if iso in out:
-            raise RuntimeError(
-                f"colision interna en {iso}: ya tenia idx={out[iso]['idx']} "
-                f"({out[iso]['note']}), se queria poner idx={idx} ({note})"
-            )
-        out[iso] = {"idx": idx, "cycle": cyc, "note": note}
-
-    for y in range(year_from, year_to + 1):
-        f = facts[y]
-        cyc = cycle_for_civil_year(y)
-
-        # -- Tiempo Ordinario semana 1 (tras el Bautismo, sin domingo propio) --
-        wk1_start = f.baptism + timedelta(days=1)
-        for i in range(6):
-            set_day(wk1_start + timedelta(days=i), 63 + i, cyc, "TOwk1")
-
-        # -- Tiempo Ordinario semanas 2..L (antes de Ceniza) --
-        for n in range(2, f.L + 1):
-            base = ot_week_base(n)
-            sun = f.week2_sunday + timedelta(days=(n - 2) * 7)
-            set_day(sun, base + CYC_OFFSET[cyc], cyc, f"TOwk{n}Sun")
-            for i in range(6):
-                d = sun + timedelta(days=1 + i)
-                if d >= f.ash_wed:
-                    break
-                set_day(d, base + 3 + i, cyc, f"TOwk{n}dia{i}")
-
-        # -- Cuaresma --
-        set_day(f.ash_wed, 141, cyc, "Ceniza")
-        for i, idx in enumerate((142, 143, 144)):
-            set_day(f.ash_wed + timedelta(days=1 + i), idx, cyc, "post-ceniza")
-        for n in range(1, 6):
-            base = lent_week_base(n)
-            sun = f.easter - timedelta(days=49 - 7 * n)
-            set_day(sun, base + CYC_OFFSET[cyc], cyc, f"Cuaresma{n}Dom")
-            for i in range(6):
-                set_day(sun + timedelta(days=1 + i), base + 3 + i, cyc, f"Cuaresma{n}dia{i}")
-
-        # -- Semana Santa / Triduo --
-        set_day(f.palm_sunday, 190 + CYC_OFFSET[cyc], cyc, "Ramos")
-        for d, idx in ((f.holy_mon, 193), (f.holy_tue, 194), (f.holy_wed, 195), (f.holy_thu, 196)):
-            set_day(d, idx, cyc, "SemanaSanta")
-        set_day(f.good_fri, 197, cyc, "ViernesSanto")
-        set_day(f.holy_sat, 198, cyc, "VigiliaPascual")
-
-        # -- Pascua --
-        set_day(f.easter, 199, cyc, "Resurreccion")
-        for i in range(6):
-            set_day(f.easter + timedelta(days=1 + i), 200 + i, cyc, "OctavaPascua")
-        set_day(f.easter + timedelta(days=7), 206, cyc, "DomIIPascua")
-        pascua_blocks = [(207, 213), (216, 222), (225, 231), (234, 240)]
-        for wi, (mon_base, sun_base) in enumerate(pascua_blocks):
-            prev_sun = f.easter + timedelta(days=7 * (wi + 1))
-            for i in range(6):
-                set_day(prev_sun + timedelta(days=1 + i), mon_base + i, cyc, f"Pascua{wi}")
-            sun = prev_sun + timedelta(days=7)
-            set_day(sun, sun_base + CYC_OFFSET[cyc], cyc, f"PascuaDom{wi}")
-        wk7_mon = f.easter + timedelta(days=7 * 5 + 1)
-        for i in range(6):
-            set_day(wk7_mon + timedelta(days=i), 243 + i, cyc, "Pascua wk7")
-        set_day(f.ascension, 249 + CYC_OFFSET[cyc], cyc, "Ascension")
-        wk8_mon = f.ascension + timedelta(days=1)
-        for i in range(6):
-            d = wk8_mon + timedelta(days=i)
-            if d >= f.pentecost:
-                break
-            set_day(d, 252 + i, cyc, "Pascua wk8")
-        set_day(f.pentecost, 258, cyc, "Pentecostes")
-        set_day(f.trinity, 259 + CYC_OFFSET[cyc], cyc, "Trinidad")
-        set_day(f.corpus, 262 + CYC_OFFSET[cyc], cyc, "Corpus")
-
-        # Las 3 semanas "tapadas" por Pentecostes/Trinidad/Corpus: el TO
-        # arranca el lunes despues de Pentecostes (norma real); solo el
-        # domingo de cada una de esas 3 semanas lo tapa la solemnidad, sus
-        # ferias Lun-Sab SI son de Tiempo Ordinario.
-        first_post = f.corpus + timedelta(days=7)
-        for gap_i, gap_sunday in enumerate((f.pentecost, f.trinity, f.corpus)):
-            gap_n = f.resume_week - 3 + gap_i
-            gap_base = ot_week_base(gap_n)
-            for i in range(6):
-                set_day(gap_sunday + timedelta(days=1 + i), gap_base + 3 + i, cyc, f"TOwk{gap_n}gap")
-
-        # -- Tiempo Ordinario semanas resume_week..34 --
-        for n in range(f.resume_week, 35):
-            sun = first_post + timedelta(days=(n - f.resume_week) * 7)
-            if n == 34:
-                set_day(sun, 481 + CYC_OFFSET[cyc], cyc, "CristoRey")
-                for i in range(6):
-                    set_day(sun + timedelta(days=1 + i), 484 + i, cyc, "TOwk34dia")
-            else:
-                base = ot_week_base(n)
-                set_day(sun, base + CYC_OFFSET[cyc], cyc, f"TOwk{n}Dom-post")
-                for i in range(6):
-                    set_day(sun + timedelta(days=1 + i), base + 3 + i, cyc, f"TOwk{n}dia-post")
-
-        # -- Adviento (ciclo del año litúrgico que empieza, y+1) --
-        cyc_next = cycle_for_civil_year(y + 1)
-        set_day(f.advent1, 1 + CYC_OFFSET[cyc_next], cyc_next, "Adviento1")
-        set_day(f.advent2, 10 + CYC_OFFSET[cyc_next], cyc_next, "Adviento2")
-        set_day(f.advent3, 19 + CYC_OFFSET[cyc_next], cyc_next, "Adviento3")
-        set_day(f.advent4, 35 + CYC_OFFSET[cyc_next], cyc_next, "Adviento4")
-        # ferias genericas de Adviento (semanas 1-3), consumidas dia a dia
-        # (no-domingo) desde adviento1+1 hasta el 16 de diciembre inclusive.
-        pool = [4, 5, 6, 7, 8, 9, 13, 14, 15, 16, 17, 18, 22, 23, 24, 25, 26]
-        pi = 0
-        d = f.advent1 + timedelta(days=1)
-        cutover = date(y, 12, 17)
-        while d < cutover:
-            if d.weekday() != 6:
-                if pi >= len(pool):
-                    raise RuntimeError(f"pool de ferias de Adviento agotado en {d.isoformat()}")
-                set_day(d, pool[pi], cyc_next, "AdvientoFeria")
-                pi += 1
-            d += timedelta(days=1)
-        # 17..23 de diciembre por fecha fija.
-        fixed_dec = {17: 27, 18: 28, 19: 29, 20: 30, 21: 31, 22: 32, 23: 33}
-        for day_num, idx in fixed_dec.items():
-            d = date(y, 12, day_num)
-            if d.weekday() == 6:
-                continue  # ya asignado como domingo de Adviento arriba
-            set_day(d, idx, cyc_next, f"{day_num}dic")
-        # 24 de diciembre: SIEMPRE Nochebuena (idx38) salvo que sea Adviento4
-        # (domingo). La feria generica "24 diciembre" (idx34) por tanto no se
-        # usa nunca con este diseño -- decision de contenido a confirmar, ver
-        # nota en el JSON de salida.
-        d24 = date(y, 12, 24)
-        if d24.weekday() != 6:
-            set_day(d24, 38, cyc_next, "Nochebuena")
-        set_day(date(y, 12, 25), 39, cyc_next, "Navidad")
-
-    # -- 26 dic .. Bautismo, atraviesa el limite de año civil --
-    for y in range(year_from - 1, year_to + 1):
-        cyc_adv = cycle_for_civil_year(y + 1)
-        fnext = facts[y + 1]
-        holy_family = fnext.holy_family
-        fixed_oct = {26: 41, 27: 42, 28: 43, 29: 44, 30: 45, 31: 46}
-        for day_num, idx in fixed_oct.items():
-            d = date(y, 12, day_num)
-            if d == holy_family:
-                set_day(d, 40, cyc_adv, "SagradaFamilia")
-            else:
-                set_day(d, idx, cyc_adv, f"{day_num}dic-octava")
-
-        ny = y + 1
-        if ny > year_to + 1:
-            continue
-        fb = facts[ny]
-        cyc_ny = cycle_for_civil_year(ny)
-        set_day(date(ny, 1, 1), 47, cyc_adv, "MariaMadre")
-        dom2 = fb.dom2_navidad
-        for day_num in (2, 3, 4, 5):
-            d = date(ny, 1, day_num)
-            if dom2 is not None and d == dom2:
-                set_day(d, 48, cyc_adv, "DomIINavidad")
-            else:
-                idx = {2: 49, 3: 50, 4: 51, 5: 52}[day_num]
-                set_day(d, idx, cyc_adv, f"{day_num}ene")
-        set_day(fb.epiphany, 53, cyc_ny, "Epifania")
-        set_day(fb.baptism, 54 + CYC_OFFSET[cyc_ny], cyc_ny, "Bautismo")
-        d = fb.epiphany + timedelta(days=1)
-        fixed_ene = {7: 57, 8: 58, 9: 59, 10: 60, 11: 61, 12: 62}
-        while d < fb.baptism:
-            if d.day in fixed_ene:
-                set_day(d, fixed_ene[d.day], cyc_ny, f"{d.day}ene")
-            d += timedelta(days=1)
-
-    return out, facts
-
-
-def apply_fixed_feasts(out: dict, facts: dict, year_from: int, year_to: int) -> list[tuple[str, str, int]]:
-    """Aplica las 11 solemnidades de fecha fija del libro (8dic..2nov) con
-    precedencia real: ceden ante domingos de Adviento/Cuaresma/Pascua, Ramos,
-    lunes-jueves de Semana Santa, Triduo, Ascension y Pentecostes (rank1), y
-    ante Trinidad/Corpus/Cristo Rey (rank2 "del Señor" > rank2 "de un
-    Santo"). En cualquier otro dia (feria ordinaria) gana la fija."""
-    fixed = {
-        (12, 8): 490, (3, 19): 491, (3, 25): 492, (6, 24): 493, (6, 29): 494,
-        (7, 22): 495, (7, 25): 496, (8, 6): 497, (8, 15): 498, (11, 1): 499, (11, 2): 500,
-    }
-
-    def rank1_days(f) -> set[date]:
-        s = {f.ash_wed, f.palm_sunday, f.holy_mon, f.holy_tue, f.holy_wed,
-             f.holy_thu, f.good_fri, f.holy_sat, f.easter, f.pentecost,
-             f.advent1, f.advent2, f.advent3, f.advent4}
-        for n in range(1, 6):
-            s.add(f.easter - timedelta(days=49 - 7 * n))
-        for i in range(6):
-            s.add(f.easter + timedelta(days=1 + i))
-        for n in range(1, 7):
-            s.add(f.easter + timedelta(days=7 * n))
-        return s
-
-    def rank2_movable_days(f) -> set[date]:
-        return {f.trinity, f.corpus, f.christ_king}
-
-    transferred: list[tuple[str, str, int]] = []
-    for y in range(year_from, year_to + 1):
-        f = facts[y]
-        r1 = rank1_days(f)
-        r2m = rank2_movable_days(f)
-        for (mo, da), idx in fixed.items():
-            d = date(y, mo, da)
-            iso = d.isoformat()
-            if iso not in out:
-                continue
-            if d not in r1 and d not in r2m:
-                out[iso] = {"idx": idx, "cycle": out[iso]["cycle"], "note": "fija-normal"}
-                continue
-            loser_note = out[iso]["note"]
-            cyc = out[iso]["cycle"]
-            if idx == 492:  # Anunciacion: regla especifica documentada
-                if d in {f.easter} or any(d == f.easter + timedelta(days=i) for i in range(1, 7)) \
-                        or d in {f.easter + timedelta(days=7 * n) for n in range(1, 7)} \
-                        or d in {f.palm_sunday, f.holy_mon, f.holy_tue, f.holy_wed, f.holy_thu}:
-                    target = f.easter + timedelta(days=8)  # lunes tras el 2º domingo de Pascua
-                else:
-                    target = d + timedelta(days=1)  # domingo de Cuaresma -> dia siguiente
-            else:
-                target = d + timedelta(days=1)  # norma general: dia siguiente libre
-            tries = 0
-            while target in r1 or target in r2m or (
-                target.isoformat() in out and out[target.isoformat()]["idx"] >= 490
-            ):
-                target += timedelta(days=1)
-                tries += 1
-                if tries > 15:
-                    raise RuntimeError(f"no se encontro hueco para trasladar idx={idx} desde {iso}")
-            set_iso = target.isoformat()
-            out[set_iso] = {"idx": idx, "cycle": cyc, "note": f"TRASLADADA de {iso} ({loser_note})"}
-            transferred.append((iso, set_iso, idx))
-    return transferred
-
-
-def coverage_report(out: dict) -> tuple[list[int], list[int]]:
-    book = json.loads(BOOK_PATH.read_text(encoding="utf-8"))
-    used = {v["idx"] for v in out.values()}
-    invalid = sorted(i for i in used if i < 1 or i > len(book))
-    never_used = sorted(set(range(1, len(book) + 1)) - used)
-    return invalid, never_used
-
-
-def main() -> None:
-    out, facts = build_calendar(YEAR_FROM, YEAR_TO)
-    transferred = apply_fixed_feasts(out, facts, YEAR_FROM, YEAR_TO)
-    out = {k: v for k, v in sorted(out.items()) if f"{YEAR_FROM}-01-01" <= k <= f"{YEAR_TO}-12-31"}
-
-    expected_days = (date(YEAR_TO, 12, 31) - date(YEAR_FROM, 1, 1)).days + 1
-    assert len(out) == expected_days, f"faltan fechas: {len(out)} != {expected_days}"
-
-    invalid, never_used = coverage_report(out)
-    assert not invalid, f"indices fuera de 1-500: {invalid}"
-
-    dates_out = {k: {"book_index": v["idx"], "cycle": v["cycle"]} for k, v in out.items()}
-    result = {
-        "schema": 2,
-        "range": {"from": f"{YEAR_FROM}-01-01", "to": f"{YEAR_TO}-12-31"},
-        "sources": [
-            "https://www.conferenciaepiscopal.es/tabla-temporal-celebraciones-ano-liturgico-2021-2044/",
-            "Computo de Pascua: algoritmo gregoriano (Meeus/Jones/Butcher), independiente de tablas publicadas",
-            "Normas Universales sobre el Año Litúrgico y el Calendario (1969): tabla de precedencia y traslados",
-        ],
-        "notes": [
-            "Cada fecha referencia book_index (1-500) sobre entradas-libro.json, no una clave de texto libre.",
-            "TO: numeracion con omision de semanas segun la norma real (cuenta atras desde Cristo Rey=semana34).",
-            "Ascension y Corpus trasladados al domingo (CEE); Bautismo/Sagrada Familia/Cristo Rey con indice propio.",
-            "Solemnidades fijas con logica de precedencia real (Adviento/Cuaresma/Pascua/Ramos/Triduo/Ascension/"
-            "Pentecostes ganan; entre solemnidades 'del Señor' > 'de un Santo'; Anunciacion con regla especifica).",
-            f"idx nunca alcanzado en {YEAR_FROM}-{YEAR_TO}: {never_used} (aritmetica real del rango, ver issue #20; "
-            "idx34 '24 diciembre' es ademas una decision de contenido: Nochebuena(38) gana siempre el 24-dic).",
-        ],
-        "dates": dates_out,
-    }
-    OUT_PATH.write_text(json.dumps(result, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
-    print(f"escritas {len(dates_out)} fechas en {OUT_PATH}")
-    print(f"solemnidades fijas trasladadas: {len(transferred)}")
-    for t in transferred:
-        print(" ", t)
-    print(f"indices del libro nunca alcanzados en {YEAR_FROM}-{YEAR_TO}: {never_used}")
-
-
-if __name__ == "__main__":
-    main()

scripts/parse_evangelio_diario_book.py

@@ -1,182 +0,0 @@
-#!/usr/bin/env python3
-"""Parse the InDesign HTML export of *A la fuente cada día*.
-
-The output is deliberately source-only: it contains no civil-date mapping.
-That mapping belongs in the separate, reviewable liturgical calendar JSON.
-"""
-
-from __future__ import annotations
-
-import argparse
-import html
-import json
-import re
-from pathlib import Path
-
-
-TITLE_SOLEMNITY = "V-T-tulo-2-l-nea"
-TITLE_OR_CITATION = "V-T-tulo-L-a-S"
-GOSPEL = "Sangr-a-2-de-t--independiente"
-MOTTO = "V-P-rrafo-2"
-PARAGRAPH = "V-P-rrafo"
-CITATION_RE = re.compile(r"\((?:Mt|Mc|Lc|Jn)\b[^)]*\)", re.IGNORECASE)
-MANUAL_CITATIONS = {
-    # Three malformed/omitted references in the InDesign export, resolved from
-    # the printed Gospel text in the same source entry.
-    "Miércoles de la 32ª semana Lc 17,11-19)": "Lc 17,11-19",
-    "22 de Julio": "Jn 20,1-2.11-18",
-    "2 de noviembre": "Jn 11,21-44",
-    "DOMINGO IV DE ADVIENTO (C)": "Lc 1,39-45",
-    "Sábado de la 7ª semana (Mc 10 13-16)": "Mc 10,13-16",
-    "8 de diciembre": "Lc 1,26-38",
-    "1 de noviembre": "Mt 5,1-12a",
-    "DOMINGO DE RAMOS (A)": "Mt 26,14-27,66",
-    "DOMINGO DE RAMOS (B)": "Mc 14,1-15,47",
-    "DOMINGO DE RAMOS (C)": "Lc 22,14-23,56",
-    "VIERNES SANTO": "Jn 18,1-19,42",
-    "DOMINGO IV TIEMPO ORDINARIO (A)": "Mt 5,1-12a",
-}
-
-
-def text(fragment: str) -> str:
-    """Return normalized text from the small, well-formed HTML fragments."""
-    fragment = re.sub(r"<[^>]+>", "", fragment)
-    return re.sub(r"\s+", " ", html.unescape(fragment).replace("\xa0", " ")).strip()
-
-
-def css_base(class_name: str) -> str:
-    return class_name.split(" ", 1)[0]
-
-
-def is_citation(value: str) -> bool:
-    return bool(CITATION_RE.fullmatch(value.strip()))
-
-
-def clean_citation(value: str) -> str:
-    match = CITATION_RE.search(value)
-    return (match.group(0) if match else value).strip().removeprefix("(").removesuffix(")").strip()
-
-
-def new_entry(title: str, kind: str) -> dict[str, object]:
-    return {
-        "source_index": 0,
-        "kind": kind,
-        "title": title,
-        "citation": "",
-        "gospel": "",
-        "motto": "",
-        "paragraphs": [],
-        "editorial_notes": [],
-    }
-
-
-def set_citation_from(value: str, entry: dict[str, object]) -> None:
-    """Capture a reference embedded in a weekday or feast-title line."""
-    if entry["citation"]:
-        return
-    match = CITATION_RE.search(value)
-    if match:
-        entry["citation"] = clean_citation(match.group(0))
-    elif "pasión según" in value.lower():
-        entry["citation"] = value.strip().removeprefix("(").removesuffix(")")
-
-
-def parse(source: Path) -> list[dict[str, object]]:
-    raw = source.read_text(encoding="utf-8")
-    blocks = re.findall(r'<p class="([^"]+)"[^>]*>(.*?)</p>', raw, re.S)
-    entries: list[dict[str, object]] = []
-    current: dict[str, object] | None = None
-
-    def finish() -> None:
-        nonlocal current
-        if current is not None:
-            current["source_index"] = len(entries) + 1
-            entries.append(current)
-        current = None
-
-    for class_name, fragment in blocks:
-        role, value = css_base(class_name), text(fragment)
-        if not value:
-            continue
-
-        if role == TITLE_SOLEMNITY:
-            finish()
-            current = new_entry(value, "solemnity")
-            set_citation_from(value, current)
-            continue
-
-        if role == TITLE_OR_CITATION and not is_citation(value):
-            # This class is overloaded. After an already complete entry it is
-            # the next weekday title (and also the Holy Family title). Right
-            # after a large title it is instead a rubric such as "INMACULADA"
-            # or "Pasión según Mt", so it must remain part of that entry.
-            if current is None or current["motto"] or current["paragraphs"]:
-                finish()
-                current = new_entry(value, "weekday")
-                set_citation_from(value, current)
-                continue
-
-        if current is None:
-            continue
-
-        if role == TITLE_OR_CITATION and is_citation(value):
-            current["citation"] = clean_citation(value)
-        elif role == TITLE_OR_CITATION:
-            set_citation_from(value, current)
-        elif role == GOSPEL:
-            current["gospel"] = value
-        elif role == MOTTO:
-            current["motto"] = value
-        elif role == PARAGRAPH:
-            if not current["gospel"] and not current["motto"] and value.startswith("Si toca alguna semana anterior"):
-                current["editorial_notes"].append(value)
-                continue
-            # One source inconsistency (Easter VI, cycle A) styles the Gospel as
-            # a normal paragraph. Before the motto, that position is unambiguous.
-            if not current["gospel"] and not current["motto"]:
-                current["gospel"] = value
-            else:
-                current["paragraphs"].append(value)
-
-    finish()
-    for entry in entries:
-        if entry["title"] in MANUAL_CITATIONS:
-            entry["citation"] = MANUAL_CITATIONS[entry["title"]]
-    return entries
-
-
-def audit(entries: list[dict[str, object]]) -> list[str]:
-    issues: list[str] = []
-    for entry in entries:
-        missing = [field for field in ("citation", "gospel", "motto") if not entry[field]]
-        if not entry["paragraphs"]:
-            missing.append("paragraphs")
-        if missing:
-            issues.append(f"#{entry['source_index']} {entry['title']}: missing {', '.join(missing)}")
-    return issues
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("source", type=Path)
-    parser.add_argument("output", type=Path)
-    args = parser.parse_args()
-
-    entries = parse(args.source)
-    issues = audit(entries)
-    # The earlier exploratory JSON had 504 records, but four were artificial
-    # citation-only splits (Holy Family and Baptism A/B/C). The source has 500
-    # complete, independently publishable comments.
-    if len(entries) != 500:
-        raise SystemExit(f"expected 500 complete entries; got {len(entries)}")
-    if issues:
-        raise SystemExit("source audit failed:\n" + "\n".join(issues))
-
-    args.output.parent.mkdir(parents=True, exist_ok=True)
-    args.output.write_text(json.dumps(entries, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    print(f"wrote {len(entries)} complete entries to {args.output}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

scripts/sync_audio_bulk.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+# sync_audio_bulk.sh — Sincroniza a producción, uno por uno, un lote de posts con
+# audio TTS ya generado en local. Envoltorio de sync_audio_to_prod.py que añade
+# "parar en el primer fallo" (el script Python no lo hace: recorre toda la
+# lista y acumula errores, ver #212/#213).
+#
+# Motivo del wrapper en bash con mapfile: un `while read id; do ...; done <
+# fichero` normal comparte el file descriptor de stdin con cualquier `ssh`
+# lanzado dentro del bucle. sync_audio_to_prod.py llama a ssh internamente; si
+# el bucle no está protegido, ssh se come el resto del fichero de IDs y el
+# bucle termina "sin error" tras procesar solo el primero. Detectado y
+# documentado en memoria (feedback-bash-while-read-ssh-stdin) el 2026-08-24
+# tras un lote real que solo sincronizó 1 de 184 posts sin ningún error visible.
+#
+# Uso:
+#   scripts/sync_audio_bulk.sh --ids 55519,55520,822
+#   scripts/sync_audio_bulk.sh --file /tmp/ids.txt          # un ID por línea
+#   scripts/sync_audio_bulk.sh --carta 54254                # cola completa de la carta
+#   scripts/sync_audio_bulk.sh --ids 55519,55520 --dry-run  # solo plan, no toca prod
+#
+# Requiere las mismas variables de entorno que sync_audio_to_prod.py para
+# apuntar a producción (ver ese script): FEA_PROD_SSH_HOST,
+# FEA_PROD_DOCKER_CONTAINER. Ejemplo:
+#   export FEA_PROD_SSH_HOST="rafa@188.40.120.157"
+#   export FEA_PROD_DOCKER_CONTAINER="wordpress-r2ssjifwj0r0ghyoqd528uaa"
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SYNC_PY="$SCRIPT_DIR/sync_audio_to_prod.py"
+
+usage() {
+  echo "Uso: $0 (--ids id1,id2,... | --file ruta | --carta post_id) [--dry-run]" >&2
+  exit 2
+}
+
+ids_csv=""
+ids_file=""
+carta=""
+dry_run=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --ids) ids_csv="$2"; shift 2 ;;
+    --file) ids_file="$2"; shift 2 ;;
+    --carta) carta="$2"; shift 2 ;;
+    --dry-run) dry_run="--dry-run"; shift ;;
+    *) usage ;;
+  esac
+done
+
+# Carga explícita de IDs en un array ANTES de cualquier llamada a ssh — es la
+# parte que evita el bug de stdin. No usar `while read ... < fichero`.
+ids=()
+if [ -n "$ids_csv" ]; then
+  IFS=',' read -r -a ids <<< "$ids_csv"
+elif [ -n "$ids_file" ]; then
+  mapfile -t ids < "$ids_file"
+elif [ -n "$carta" ]; then
+  # No usar `mapfile < <(cmd)`: la sustitución de procesos no deja comprobar
+  # de forma fiable el exit code de `cmd` (mapfile ve su propio $?, no el de
+  # la tubería). Si la consulta falla, un array vacío se confundiría con
+  # "la carta no tiene artículos" y el lote saldría "éxito" sin sincronizar
+  # nada. Se resuelve a fichero temporal y se comprueba el rc de python
+  # explícitamente antes de poblar el array.
+  carta_tmpfile="$(mktemp)"
+  python3 - "$carta" "$SCRIPT_DIR" > "$carta_tmpfile" <<'PYEOF'
+import sys
+sys.path.insert(0, sys.argv[2])
+from sync_audio_to_prod import carta_article_ids
+for pid in carta_article_ids(int(sys.argv[1])):
+    print(pid)
+PYEOF
+  py_rc=$?
+  if [ $py_rc -ne 0 ]; then
+    echo "ERROR: fallo consultando la cola de la carta $carta (exit $py_rc), no se sincroniza nada." >&2
+    rm -f "$carta_tmpfile"
+    exit 1
+  fi
+  mapfile -t ids < "$carta_tmpfile"
+  rm -f "$carta_tmpfile"
+else
+  usage
+fi
+
+total=${#ids[@]}
+if [ "$total" -eq 0 ]; then
+  echo "Nada que sincronizar (lista de IDs vacía)." >&2
+  exit 0
+fi
+
+ok=0
+skip=0
+n=0
+for id in "${ids[@]}"; do
+  id="$(echo "$id" | tr -d '[:space:]')"
+  [ -z "$id" ] && continue
+  n=$((n + 1))
+  # stdin del hijo explícitamente en /dev/null: cinturón y tirantes además del
+  # array en memoria, por si algún día se cambia el bucle.
+  out="$(python3 "$SYNC_PY" --ids "$id" $dry_run < /dev/null)"
+  rc=$?
+  echo "$out"
+  if [ $rc -ne 0 ]; then
+    echo "=== ABORT: fallo en #$id ($n/$total procesados, $ok ok). Deteniendo lote, sin reintentar. ==="
+    exit 1
+  fi
+  if echo "$out" | grep -q "PLAN: subiría\|#$id: ok"; then
+    ok=$((ok + 1))
+  else
+    skip=$((skip + 1))
+  fi
+done
+
+echo "=== FIN LOTE. ok=$ok skip=$skip de $total candidatos. ==="

scripts/sync_audio_to_prod.py

@@ -19,6 +19,7 @@ Rollback (despublica en prod lo que este script publicó):
 from __future__ import annotations
 
 import argparse
+import hashlib
 import json
 import os
 import subprocess
@@ -74,6 +75,8 @@ def local_meta(post_id: int, key: str) -> str:
         ["docker", "exec", WP_CONTAINER, "php", "/tmp/fea_post_io.php", "getmeta", str(post_id), key],
         capture_output=True, text=True, timeout=60,
     )
+    if r.returncode != 0:
+        raise RuntimeError(f"docker exec {WP_CONTAINER} falló leyendo meta '{key}' de #{post_id} (rc={r.returncode}): {r.stderr.strip()[:300]}")
     return r.stdout.strip()
 
 
@@ -85,6 +88,8 @@ def carta_article_ids(carta_id: int) -> list[int]:
          DB_NAME, "-N", "-e", q],
         capture_output=True, text=True, timeout=60,
     )
+    if r.returncode != 0:
+        raise RuntimeError(f"consulta de _carta_id={carta_id} falló (rc={r.returncode}): {r.stderr.strip()[:300]}")
     return [int(x) for x in r.stdout.split() if x.isdigit()]
 
 
@@ -144,16 +149,21 @@ def prod_helper(subcmd: str, *args: str) -> str:
     return _ssh_text(_remote_wrap(inner), timeout=60)
 
 
-def prod_upload_mp3(post_id: int) -> None:
+def prod_upload_mp3(post_id: int) -> str:
     src = LOCAL_TTS_DIR / f"{post_id}.mp3"
     data = src.read_bytes()
+    local_sha256 = hashlib.sha256(data).hexdigest()
     remote_path = f"{PROD_UPLOADS_TTS}/{post_id}.mp3"
     _ssh_upload_bytes(data, remote_path)
-    # Verificación de tamaño: no fiarse ciegamente del rc=0 de ssh. `wc -c` debe
-    # correr (y resolver la redirección) DENTRO del contenedor — ver _remote_wrap.
+    # Verificación de tamaño+contenido: un rc=0 de ssh no acredita que el asset
+    # sea el mismo. El hash se persiste como meta y permite playback verificado.
     remote_size = int(_ssh_text(_remote_wrap(f"wc -c < {remote_path}")).strip())
     if remote_size != len(data):
         raise RuntimeError(f"tamaño no coincide tras subir #{post_id}: local={len(data)} remoto={remote_size}")
+    remote_sha256 = _ssh_text(_remote_wrap(f"sha256sum {remote_path} | cut -d' ' -f1")).strip()
+    if remote_sha256 != local_sha256:
+        raise RuntimeError(f"SHA-256 no coincide tras subir #{post_id}: local={local_sha256} remoto={remote_sha256}")
+    return local_sha256
 
 
 def prod_remove_mp3(post_id: int) -> None:
@@ -185,8 +195,9 @@ def sync_one(post_id: int, state: dict, *, dry_run: bool) -> str:
         return "PLAN: subiría mp3 + setaudio"
 
     voice = local_meta(post_id, "fea_audio_voice") or "NicoFeadulta2026"
-    prod_upload_mp3(post_id)
+    sha256 = prod_upload_mp3(post_id)
     prod_helper("setaudio", str(post_id), f"/wp-content/uploads/tts/{post_id}.mp3", voice)
+    prod_helper("setflag", str(post_id), "fea_audio_sha256", sha256)
     if post_id not in state["synced"]:
         state["synced"].append(post_id)
         save_state(state)

tests/fixtures/fray-marcos/README.md

@@ -0,0 +1,69 @@
+# `.doc` originales de Fray Marcos
+
+Los 30 ficheros `.doc` (Word binario antiguo) tal y como los envía Fray Marcos por correo a
+`ediciones@feadulta.com`, sin tocar. Subidos a petición de Rafa en el **issue #209**, para poder
+reproducir y diffear desde este lado el problema de los `<w:smartTag>`.
+
+## Por qué están aquí
+
+`python-docx` **no lee el texto que va dentro de un `<w:smartTag>`**: lo salta sin dar error. Los `.doc`
+de Fray Marcos arrastran esas etiquetas heredadas de versiones viejas de Word envolviendo expresiones
+como «la Iglesia» o «la Cananea», así que al convertirlos se publicaban frases con palabras borradas en
+silencio. Está corregido en `scripts/doc_convert.py` con `quitar_smarttags()`.
+
+Ojo: la cadena `smartTag` **no aparece en el binario `.doc`**; surge al convertirlo a `.docx`, que es
+formato OOXML. Para verlas hay que convertir primero.
+
+## Cómo reproducir
+
+```bash
+python scripts/doc_convert.py "tests/fixtures/fray-marcos/739_8r_Marcos_d 20 la Cananea.doc"
+```
+
+Requiere Word instalado (la conversión va por COM). `doc_convert.py` desenvuelve los smartTag y hace el
+reemplazo con reintentos, porque Dropbox bloquea el fichero unos segundos justo después de que Word lo
+cree (WinError 1224).
+
+## Alcance del problema (barrido cerrado en el #209)
+
+De los 30 `.doc` revisados, 20 traían smartTag y sumaban 46 fragmentos envueltos, pero solo **3
+artículos publicados quedaron dañados** (posts `53981`, `55078` y `55659`), ya reparados en producción.
+Los comentarios de febrero a junio están intactos porque se publicaron por la vía de la migración de
+Joomla, no desde el `.docx`; solo quedó expuesto lo publicado por Mixbot desde julio.
+
+## Inventario
+
+El prefijo numérico es el número de carta; el resto es el nombre original del fichero.
+
+| carta | semana | fichero original |
+|---:|---|---|
+| 713 | semana_VI_TO | `713_8r_Marcos_d 06 plenitud de ley.doc` |
+| 714 | semana_I_Cuaresma | `714_8r_Marcos_Cuar 1 tentaciones.doc` |
+| 715 | semana_II_Cuaresma | `715_8r_Marcos_Cuar 2 Transfigurac.doc` |
+| 716 | semana_III_Cuaresma | `716_8r_Marcos_Cuar 3 Samaritana.doc` |
+| 717 | semana_IV_Cuaresma | `717_8r_Marcos_Cuar 4 ciego de naci.doc` |
+| 718 | semana_V_Cuaresma | `718_8r_Marcos_Cuar 5 Lázaro.doc` |
+| 719 | semana_Domingo_Ramos | `719_8r_Marcos_Cuar 6 Ramos.doc` |
+| 720 | semana_Santa | `720_8r_Marcos_JUEVES SANTO.doc` |
+| 720 | semana_Santa | `720_8r_Marcos_Pasc 1 resucitó.doc` |
+| 720 | semana_Santa | `720_8r_Marcos_VIERNES SANTO.doc` |
+| 721 | semana_II_Pascua | `721_8r_Marcos_Pasc 2 Tomás.doc` |
+| 722 | semana_III_Pascua | `722_8r_Marcos_Pasc 3 Emaús.doc` |
+| 723 | semana_IV_Pascua | `723_8r_Marcos_Pasc 4 pastor modelo.doc` |
+| 724 | semana_V_Pascua | `724_8r_Marcos_Pasc 5 camino,verdad,vida.doc` |
+| 725 | semana_VI_Pascua | `725_8r_Marcos_Pasc 6 El Paráclito.doc` |
+| 726 | semana_VII_Pascua | `726_8r_Marcos_Pasc 7 ascensión.doc` |
+| 727 | semana_Pentecostes | `727_8r_Marcos_PENTECOSTÉS.doc` |
+| 728 | semana_Trinidad | `728_8r_Marcos_TRINIDAD.doc` |
+| 729 | semana_Corpus | `729_8r_Marcos_CORPUS.doc` |
+| 730 | semana_11_TO | `730_8r_Marcos_d 11 misión de los 12.doc` |
+| 731 | semana_12_TO | `731_8r_Marcos_d 12 no tengas miedo.doc` |
+| 732 | semana_13_TO | `732_8r_Marcos_d 13 amor a Dios o família.doc` |
+| 733 | semana_14_TO | `733_8r_Marcos_d 14 sencillez.doc` |
+| 734 | semana_15_TO | `734_8r_Marcos_d 15 sembrador.doc` |
+| 735 | semana_16_TO | `735_8r_Marcos_d 16 cizaña.doc` |
+| 736 | semana_17_TO | `736_8r_Marcos_d 17 tesoro y perla.doc` |
+| 737 | semana_18_TO | `737_8r_Marcos_d 18 panes y peces.doc` |
+| 738 | semana_19_TO | `738_8r_Marcos_d 19 Qué poca fe.doc` |
+| 739 | semana_20_TO | `739_8r_Marcos_d 20 la Cananea.doc` |
+| 740 | semana_21_TO | `740_8r_Marcos_d 21 quién es Jesús.doc` |

tests/test_liturgical_calendar_coverage.py

@@ -1,155 +0,0 @@
-#!/usr/bin/env python3
-"""Test de aceptación del calendario litúrgico 2026-2040 (issue #20).
-
-Criterio acordado entre Codix/Opix/Claudix: cobertura bidireccional contra
-las 500 entradas del libro, más un puñado de fechas móviles verificadas de
-forma independiente (cómputo de Pascua propio, no la fuente del generador).
-
-Uso: python3 tests/test_liturgical_calendar_coverage.py
-Sale con exit code != 0 si algo falla.
-"""
-from __future__ import annotations
-
-import json
-import sys
-from datetime import date, timedelta
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-CAL_PATH = ROOT / "data/evangelio-diario/calendario-liturgico-2026-2040.json"
-BOOK_PATH = ROOT / "data/evangelio-diario/entradas-libro.json"
-
-
-def easter_sunday(year: int) -> date:
-    a = year % 19
-    b = year // 100
-    c = year % 100
-    d_ = b // 4
-    e = b % 4
-    f = (b + 8) // 25
-    g = (b - f + 1) // 3
-    h = (19 * a + b - d_ - g + 15) % 30
-    i = c // 4
-    k = c % 4
-    l = (32 + 2 * e + 2 * i - h - k) % 7
-    m = (a + 11 * h + 22 * l) // 451
-    month = (h + l - 7 * m + 114) // 31
-    day = ((h + l - 7 * m + 114) % 31) + 1
-    return date(year, month, day)
-
-
-def fail(msg: str, errors: list[str]) -> None:
-    errors.append(msg)
-
-
-def main() -> int:
-    errors: list[str] = []
-    cal = json.loads(CAL_PATH.read_text(encoding="utf-8"))
-    book = json.loads(BOOK_PATH.read_text(encoding="utf-8"))
-    dates = cal["dates"]
-    n_book = len(book)
-
-    # 1) toda fecha del rango existe y tiene book_index valido
-    d = date.fromisoformat(cal["range"]["from"])
-    end = date.fromisoformat(cal["range"]["to"])
-    n_dates = 0
-    while d <= end:
-        iso = d.isoformat()
-        if iso not in dates:
-            fail(f"fecha ausente: {iso}", errors)
-        else:
-            idx = dates[iso]["book_index"]
-            if not (1 <= idx <= n_book):
-                fail(f"{iso}: book_index fuera de rango: {idx}", errors)
-            n_dates += 1
-        d += timedelta(days=1)
-
-    # 2) toda entrada del libro es alcanzable en algun año del rango
-    used = {v["book_index"] for v in dates.values()}
-    never_used = sorted(set(range(1, n_book + 1)) - used)
-    # las 3 excepciones conocidas y documentadas en el propio JSON (ver "notes")
-    known_gaps = {34, 62, 134}
-    unexpected_gaps = [i for i in never_used if i not in known_gaps]
-    if unexpected_gaps:
-        fail(f"entradas del libro nunca alcanzadas (no documentadas): {unexpected_gaps}", errors)
-
-    # 3) fechas moviles clave, computadas de forma independiente (no depende
-    #    del propio generador ni de su fuente CEE)
-    checks_ok = 0
-    for year in range(2026, 2041):
-        easter = easter_sunday(year)
-        expects = [
-            (easter, 199, "Pascua"),
-            (easter - timedelta(days=46), 141, "Ceniza"),
-            (easter + timedelta(days=49), 258, "Pentecostes"),
-        ]
-        for dt, expected_idx, label in expects:
-            v = dates.get(dt.isoformat())
-            got = v["book_index"] if v else None
-            if got != expected_idx:
-                fail(f"{year} {label} {dt}: esperado idx={expected_idx}, obtenido={got}", errors)
-            else:
-                checks_ok += 1
-        palm = easter - timedelta(days=7)
-        v = dates.get(palm.isoformat())
-        if not (v and 190 <= v["book_index"] <= 192):
-            fail(f"{year} Ramos {palm}: obtenido={v}", errors)
-        else:
-            checks_ok += 1
-        trinity = easter + timedelta(days=56)
-        v = dates.get(trinity.isoformat())
-        if not (v and 259 <= v["book_index"] <= 261):
-            fail(f"{year} Trinidad {trinity}: obtenido={v}", errors)
-        else:
-            checks_ok += 1
-
-    # 4) solemnidades con clave propia, todos los años (no diluidas en un
-    #    domingo/feria generico) -- el bug central del commit retirado 2713e13
-    for year in range(2026, 2041):
-        ep = date(year, 1, 6)
-        baptism = (ep + timedelta(days=1)) if ep.weekday() == 6 else (
-            ep + timedelta(days=(6 - ep.weekday()) % 7)
-        )
-        v = dates.get(baptism.isoformat())
-        if not (v and 54 <= v["book_index"] <= 56):
-            fail(f"{year} Bautismo {baptism}: sin clave propia ({v})", errors)
-
-        easter = easter_sunday(year)
-        ascension = easter + timedelta(days=42)
-        v = dates.get(ascension.isoformat())
-        if not (v and 249 <= v["book_index"] <= 251):
-            fail(f"{year} Ascension {ascension}: sin clave propia ({v})", errors)
-
-        corpus = easter + timedelta(days=63)
-        v = dates.get(corpus.isoformat())
-        if not (v and 262 <= v["book_index"] <= 264):
-            fail(f"{year} Corpus {corpus}: sin clave propia o no en domingo ({v})", errors)
-
-    years_with_ck = {k[:4] for k, v in dates.items() if 481 <= v["book_index"] <= 483}
-    if len(years_with_ck) != 15:
-        fail(f"Cristo Rey ausente en algun año: {sorted(years_with_ck)}", errors)
-
-    years_with_family = {k[:4] for k, v in dates.items() if v["book_index"] == 40}
-    if len(years_with_family) != 15:
-        fail(f"Sagrada Familia ausente en algun año: {sorted(years_with_family)}", errors)
-
-    # 5) Adviento no debe seguir contando tras Navidad (fuga del commit retirado)
-    leak = [k for k, v in dates.items()
-            if k[5:7] == "12" and int(k[8:10]) >= 26 and v["book_index"] <= 37]
-    if leak:
-        fail(f"fuga de Adviento tras Navidad: {leak[:10]}", errors)
-
-    print(f"fechas verificadas: {n_dates}")
-    print(f"book_index distintos usados: {len(used)}/{n_book}")
-    print(f"chequeos de fechas moviles ok: {checks_ok}")
-    if errors:
-        print(f"\nFALLOS ({len(errors)}):")
-        for e in errors:
-            print(" -", e)
-        return 1
-    print("\nTodo OK.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())