fix(pipeline): stop reporting success over broken harvest stages

The weekly harvest reported "COMPLETED SUCCESSFULLY" while transcription had
been producing nothing for weeks: 8 of the 12 recorded runs transcribed zero
videos, and 15 of 16 runs printed the success banner anyway.

- transcribe: return attempted/processed/failed counts and exit 1 when work
was attempted but nothing was produced, so a total failure is visible.
- transcribe: the configured endpoint pointed at homelab:8086, where nothing
listens; Whisper is served via Caddy at /api/v1/whisper/v1/audio/
transcriptions, and requires the multipart part to be named "file".
- transcribe: select the real downloaded media file. The old check accepted
any non-".part" file, which matched yt-dlp's ".ytdl" metadata JSON and made
Whisper answer HTTP 500 "Invalid data".
- transcribe: drop --impersonate (combined with browser cookies it removes
audio-only formats, so the fallback downloaded a 475 MB 1080p video) and
normalize everything to 16 kHz mono WAV with ffmpeg.
- transcribe: enforce max_duration_sec, which was a dead parameter, so
hour-long clips were downloaded in full.
- pipeline: add set -o pipefail. Every stage pipes into tee, so a failing
stage was invisible to set -e. Treat a transcription outage as a loud
non-fatal warning, and add a freshness health check that exits non-zero
when the corpus, transcripts, or digests are stale or missing.
- setup_crontab: invoke the shell script with bash. Cron ran it through
python3, which crashed with SyntaxError on every run.

moldovan-qwen/scripts/run_automated_pipeline.sh

@@ -8,6 +8,10 @@
 # 4. Generates new viral short-form video scripts (TikTok/Reels)
 
 set -e
+# A failing left-hand command in a pipeline is invisible to `set -e` without
+# pipefail: every stage below pipes into `tee`, so a broken stage used to leave
+# the pipeline reporting "COMPLETED SUCCESSFULLY" anyway.
+set -o pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 BASE_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
@@ -39,7 +43,13 @@ fi
 
 # Step 2: Transcribe new videos via homelab Whisper
 echo "[2/6] Transcribing new videos via homelab Whisper..." | tee -a "$LOG_FILE"
-python3 "${SCRIPT_DIR}/transcribe_moldovan_videos.py" --limit 3 --corpus "${BASE_DIR}/data/youtube_corpus/moldovan_youtube_corpus.jsonl" --output-dir "${BASE_DIR}/data/transcripts" | tee -a "$LOG_FILE"
+# Transcription depends on an external service (Whisper on the homelab). Its
+# outage must NOT abort the other five stages, but it must be loud: this stage
+# previously printed "Transcribed 0 videos" and exit 0, which hid a long outage.
+if ! python3 "${SCRIPT_DIR}/transcribe_moldovan_videos.py" --limit 3 --corpus "${BASE_DIR}/data/youtube_corpus/moldovan_youtube_corpus.jsonl" --output-dir "${BASE_DIR}/data/transcripts" 2>&1 | tee -a "$LOG_FILE"; then
+    echo "[!] WARNING: transcription stage failed (Whisper unreachable or downloads blocked)." | tee -a "$LOG_FILE"
+    echo "[!] Continuing with remaining stages; corpus/transcripts may be stale." | tee -a "$LOG_FILE"
+fi
 
 # Step 3: Synthesize SFT Dataset
 echo "[3/6] Synthesizing SFT training dataset..." | tee -a "$LOG_FILE"
@@ -57,6 +67,40 @@ python3 "${SCRIPT_DIR}/generate_moldovan_video_scripts.py" --output-dir "${BASE_
 echo "[6/6] Synthesizing Daily News Digest with Edge-TTS ro-RO Voiceover..." | tee -a "$LOG_FILE"
 python3 "${BASE_DIR}/engine/synthesize_daily_news.py" | tee -a "$LOG_FILE"
 
-echo "============================================================" | tee -a "$LOG_FILE"
-echo "🎉 PIPELINE CYCLE COMPLETED SUCCESSFULLY: $(date -u)" | tee -a "$LOG_FILE"
-echo "============================================================" | tee -a "$LOG_FILE"
+# ─── Freshness health check ───────────────────────────────────────────────────
+# The weekly job previously reported success even when stages produced nothing,
+# so staleness went unnoticed for weeks (transcripts had been empty since
+# mid-August). Surface the age of every key artifact, and fail loudly if the
+# corpus or the news digest did not advance in this run.
+echo "[health] Artifact freshness:" | tee -a "$LOG_FILE"
+HEALTH_FAIL=0
+_report_age() {
+    local label="$1" path="$2" max_days="$3"
+    if [ ! -e "$path" ]; then
+        echo "  [!] ${label}: MISSING (${path})" | tee -a "$LOG_FILE"
+        HEALTH_FAIL=1
+        return
+    fi
+    local age_days
+    age_days=$(( ( $(date +%s) - $(stat -f %m "$path" 2>/dev/null || stat -c %Y "$path") ) / 86400 ))
+    if [ "$age_days" -gt "$max_days" ]; then
+        echo "  [!] ${label}: STALE (${age_days}d > ${max_days}d)" | tee -a "$LOG_FILE"
+        HEALTH_FAIL=1
+    else
+        echo "  [✓] ${label}: ${age_days}d old" | tee -a "$LOG_FILE"
+    fi
+}
+_report_age "youtube corpus" "${BASE_DIR}/data/youtube_corpus/moldovan_youtube_corpus.jsonl" 10
+_report_age "transcripts dir" "${BASE_DIR}/data/transcripts" 10
+_report_age "news digest dir" "${BASE_DIR}/data/generated_digests" 3
+
+if [ "$HEALTH_FAIL" -eq 0 ]; then
+    echo "============================================================" | tee -a "$LOG_FILE"
+    echo "🎉 PIPELINE CYCLE COMPLETED SUCCESSFULLY: $(date -u)" | tee -a "$LOG_FILE"
+    echo "============================================================" | tee -a "$LOG_FILE"
+else
+    echo "============================================================" | tee -a "$LOG_FILE"
+    echo "⚠️  PIPELINE COMPLETED WITH STALE/MISSING ARTIFACTS: $(date -u)" | tee -a "$LOG_FILE"
+    echo "============================================================" | tee -a "$LOG_FILE"
+    exit 1
+fi

moldovan-qwen/scripts/setup_crontab.sh

@@ -20,7 +20,7 @@ export HF_TOKEN="${HF_TOKEN:-$(printenv HF_TOKEN)}"
 ALBUM_SCHEDULE="0 3 * * * /usr/bin/python3 ${ALBUM_SCRIPT} >> ${LOG_DIR}/daily_album_cron.log 2>&1"
 
 # 2. General pipeline harvesting & datasets (Every Sunday at 02:00 AM)
-PIPELINE_SCHEDULE="0 2 * * 0 ${PIPELINE_SCRIPT} >> ${LOG_DIR}/cron_pipeline.log 2>&1"
+PIPELINE_SCHEDULE="0 2 * * 0 . \$HOME/.flow_cron_env && /bin/bash ${PIPELINE_SCRIPT} >> ${LOG_DIR}/cron_pipeline.log 2>&1"
 
 echo "============================================================"
 echo "🇲🇩 MOLDOVAN AI AUTOMATED SCHEDULER SETUP"

moldovan-qwen/scripts/transcribe_moldovan_videos.py

@@ -8,10 +8,11 @@ using the Whisper STT service on the homelab (now accessible via Tailscale).
 Pipeline:
   1. Read video IDs from the YouTube corpus (moldovan_youtube_corpus.jsonl)
   2. Download audio with yt-dlp (works even though subtitles are bot-walled)
-  3. Transcribe with Whisper at http://homelab:8086/v1/transcribe
+  3. Transcribe with Whisper via the homelab Caddy proxy
   4. Save transcripts to data/transcripts/
 
-Whisper endpoint: POST http://homelab:8086/v1/transcribe (multipart audio file)
+Whisper endpoint: POST http://homelab/api/v1/whisper/v1/audio/transcriptions
+(proxied by Caddy, which strips /api/v1/whisper; multipart field must be "file")
 """
 
 import os
@@ -23,7 +24,16 @@ import urllib.request
 import urllib.error
 from typing import List, Dict, Optional
 
-WHISPER_URL = os.environ.get("WHISPER_URL", "http://homelab:8086/v1/transcribe")
+# Whisper is exposed through the homelab Caddy reverse proxy at
+# /api/v1/whisper/* (prefix stripped, forwarded to faster-whisper:8000). The
+# faster-whisper server implements the OpenAI-compatible route
+# /v1/audio/transcriptions and requires the multipart field to be named "file".
+# The previous value (http://homelab:8086/v1/transcribe) pointed at a port that
+# nothing listens on, which is why transcription silently produced nothing.
+WHISPER_URL = os.environ.get(
+    "WHISPER_URL",
+    "http://homelab/api/v1/whisper/v1/audio/transcriptions",
+)
 CORPUS_PATH = "moldovan-qwen/data/youtube_corpus/moldovan_youtube_corpus.jsonl"
 TRANSCRIPT_DIR = "moldovan-qwen/data/transcripts"
 
@@ -51,33 +61,113 @@ def get_existing_transcripts(transcript_dir: str) -> set:
             existing.add(fname[:-5])
     return existing
 
-def download_audio(video_id: str, work_dir: str) -> Optional[str]:
-    """Download audio for a video using yt-dlp. Returns path to audio file."""
-    out_template = os.path.join(work_dir, f"{video_id}.%(ext)s")
+def _normalize_audio(src: str) -> Optional[str]:
+    """Downmix any media file to 16 kHz mono WAV for Whisper.
+
+    yt-dlp cannot always supply an audio-only stream (availability of the
+    audio renditions fluctuates per request and per video), so it sometimes
+    returns a full video container. Sending that to Whisper wastes bandwidth and
+    GPU memory and, on a busy GPU, fails with CUDA out of memory. Extracting a
+    small mono track locally keeps uploads tiny and transcription reliable.
+    Returns the original path if ffmpeg is unavailable or extraction fails.
+    """
+    out_path = os.path.splitext(src)[0] + ".16k.wav"
     cmd = [
+        "ffmpeg", "-nostdin", "-y", "-loglevel", "error",
+        "-i", src,
+        "-vn", "-ac", "1", "-ar", "16000", "-f", "wav",
+        out_path,
+    ]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+        if result.returncode == 0 and os.path.isfile(out_path) \
+                and os.path.getsize(out_path) > 0:
+            return out_path
+        print(f"    [!] ffmpeg normalize failed: {result.stderr[-160:]}")
+    except FileNotFoundError:
+        print("    [!] ffmpeg not found; sending original media to Whisper")
+    except subprocess.TimeoutExpired:
+        print("    [!] ffmpeg normalize timed out")
+    except Exception as e:
+        print(f"    [!] ffmpeg normalize error: {e}")
+    return src
+
+
+def _run_ytdlp(video_id: str, out_template: str, fmt: str,
+               max_duration_sec: int) -> bool:
+    """Run one yt-dlp attempt with a specific format selector."""
+    cmd = [
+        # NOTE: do NOT combine --impersonate with --cookies-from-browser. That
+        # combination makes audio-only formats disappear from yt-dlp's listing
+        # for some videos; the fallback then downloads a full 1080p VIDEO
+        # (measured: 475 MB for a 35-minute clip) which Whisper then fails on
+        # with CUDA out of memory. Cookies alone are sufficient.
         "yt-dlp",
-        "--impersonate", "chrome",
         "--cookies-from-browser", "chrome",
-        "-f", "bestaudio[ext=m4a]/bestaudio",
+        "-f", fmt,
+        "--no-playlist",
+        # Do not download clips longer than the caller's limit.
+        "--match-filter", f"duration < {max_duration_sec}",
         "-o", out_template,
         f"https://www.youtube.com/watch?v={video_id}",
     ]
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
         if result.returncode != 0:
-            print(f"    [!] yt-dlp failed for {video_id}: {result.stderr[-200:]}")
-            return None
-        # Find the downloaded file
-        for fname in os.listdir(work_dir):
-            if fname.startswith(video_id) and not fname.endswith(".part"):
-                return os.path.join(work_dir, fname)
-        return None
+            tail = (result.stderr or result.stdout or "").strip()[-160:]
+            print(f"    [!] yt-dlp failed ({fmt}): {tail}")
+            return False
+        return True
     except subprocess.TimeoutExpired:
         print(f"    [!] yt-dlp timed out for {video_id}")
-        return None
+        return False
     except Exception as e:
         print(f"    [!] yt-dlp error for {video_id}: {e}")
+        return False
+
+
+def download_audio(video_id: str, work_dir: str,
+                   max_duration_sec: int = 600) -> Optional[str]:
+    """Download audio for a video using yt-dlp, normalized to 16 kHz mono WAV.
+
+    Format availability on YouTube is not stable: `bestaudio` can report
+    "Requested format is not available" for a video on one request and succeed
+    on the next, and `bestaudio/best` silently degrades to a full video stream.
+    So we try progressively permissive selectors, then normalize whatever we get
+    to a small mono WAV. Returns None only if every attempt fails.
+    """
+    out_template = os.path.join(work_dir, f"{video_id}.%(ext)s")
+
+    # Ordered from most to least specific. `best` is last because it may include
+    # video; normalization below makes that acceptable rather than fatal.
+    for fmt in ("bestaudio", "bestaudio/best", "best"):
+        if _run_ytdlp(video_id, out_template, fmt, max_duration_sec):
+            media = _pick_downloaded_media(video_id, work_dir)
+            if media:
+                return _normalize_audio(media)
+            print(f"    [!] yt-dlp reported success but no media found ({fmt})")
+    return None
+
+
+def _pick_downloaded_media(video_id: str, work_dir: str) -> Optional[str]:
+    """Pick the real downloaded media file, never a sidecar or partial."""
+    media_exts = {".m4a", ".webm", ".mp4", ".opus", ".mp3", ".wav", ".aac",
+                  ".ogg", ".mkv", ".flac"}
+    candidates = []
+    for fname in os.listdir(work_dir):
+        if not fname.startswith(video_id):
+            continue
+        if ".part" in fname or fname.endswith(".ytdl"):
+            continue
+        if os.path.splitext(fname)[1].lower() not in media_exts:
+            continue
+        full = os.path.join(work_dir, fname)
+        if os.path.isfile(full) and os.path.getsize(full) > 0:
+            candidates.append(full)
+    if not candidates:
         return None
+    return max(candidates, key=lambda p: os.path.getmtime(p))
+
 
 def transcribe_audio(audio_path: str, timeout: int = 600) -> Optional[Dict]:
     """Send audio to homelab Whisper for transcription."""
@@ -87,10 +177,12 @@ def transcribe_audio(audio_path: str, timeout: int = 600) -> Optional[Dict]:
     with open(audio_path, "rb") as f:
         audio_data = f.read()
     
-    # Build multipart body
+    # Build multipart body. The faster-whisper server requires the file part to
+    # be named "file" (OpenAI-compatible schema); it was previously sent as
+    # "audio", which the server rejected.
     body = b""
     body += f"--{boundary}\r\n".encode()
-    body += b'Content-Disposition: form-data; name="audio"; filename="audio.wav"\r\n'
+    body += b'Content-Disposition: form-data; name="file"; filename="audio.wav"\r\n'
     body += b"Content-Type: audio/wav\r\n\r\n"
     body += audio_data
     body += f"\r\n--{boundary}--\r\n".encode()
@@ -114,8 +206,14 @@ def transcribe_audio(audio_path: str, timeout: int = 600) -> Optional[Dict]:
 
 def transcribe_videos(limit: int = 5, max_duration_sec: int = 600,
                       corpus_path: str = CORPUS_PATH,
-                      transcript_dir: str = TRANSCRIPT_DIR):
-    """Transcribe a batch of videos from the corpus."""
+                      transcript_dir: str = TRANSCRIPT_DIR) -> dict:
+    """Transcribe a batch of videos from the corpus.
+
+    Returns a summary dict ``{attempted, processed, failed}`` so callers (and the
+    weekly pipeline) can tell a healthy no-op from a total failure. Previously
+    the function printed "Done! Transcribed 0 videos." and exited 0 even when
+    every download failed, which made a fully broken harvest look like success.
+    """
     os.makedirs(transcript_dir, exist_ok=True)
     os.makedirs("/tmp/moldovan_audio", exist_ok=True)
 
@@ -128,7 +226,7 @@ def transcribe_videos(limit: int = 5, max_duration_sec: int = 600,
 
     if not pending:
         print("[✓] All videos already transcribed!")
-        return
+        return {"attempted": 0, "processed": 0, "failed": 0}
 
     # PRIORITIZE SPOKEN CONTENT over music:
     # Podcasts, news, interviews, satire, vlogs, diaspora = spoken (transcribe first)
@@ -137,31 +235,41 @@ def transcribe_videos(limit: int = 5, max_duration_sec: int = 600,
     spoken = [v for v in pending if v.get("category") in SPOKEN_CATEGORIES]
     music = [v for v in pending if v.get("category") not in SPOKEN_CATEGORIES]
 
-    # Sort spoken content by views (most popular first), then fall back to music
-    spoken.sort(key=lambda v: v.get("view_count", 0), reverse=True)
-    music.sort(key=lambda v: v.get("view_count", 0), reverse=True)
+    # Sort spoken content by recency first (freshest news/interviews feed the
+    # current topical corpus), using views only to break ties within a day.
+    # Ranking by all-time views transcribed decade-old viral clips instead of
+    # this week's content.
+    spoken.sort(key=lambda v: (v.get("published_at", ""), v.get("view_count", 0)),
+                reverse=True)
+    music.sort(key=lambda v: (v.get("published_at", ""), v.get("view_count", 0)),
+               reverse=True)
     pending = spoken + music
 
     print(f"[*] Prioritizing spoken content: {len(spoken)} spoken + {len(music)} music candidates.")
 
     processed = 0
+    failed = 0
+    attempted = 0
     for video in pending[:limit]:
         vid = video["video_id"]
         title = video.get("title", "")[:60]
         cat = video.get("category", "general")
         print(f"\n[{processed+1}/{min(limit, len(pending))}] Transcribing [{cat.upper()}]: {title}")
         print(f"    Video: {vid} | Views: {video.get('view_count', 0)}")
+        attempted += 1
 
         # Download audio
-        audio_path = download_audio(vid, "/tmp/moldovan_audio")
+        audio_path = download_audio(vid, "/tmp/moldovan_audio", max_duration_sec)
         if not audio_path:
             print("    [!] Could not download audio. Skipping.")
+            failed += 1
             continue
 
         # Transcribe
         result = transcribe_audio(audio_path)
         if not result:
             print("    [!] Transcription failed. Skipping.")
+            failed += 1
             continue
 
         detected_lang = result.get("language", "unknown")
@@ -172,6 +280,7 @@ def transcribe_videos(limit: int = 5, max_duration_sec: int = 600,
         expected_langs = {"ro", "ru", "mo", "en"}
         if detected_lang not in expected_langs:
             print(f"    [!] Skipping — detected language '{detected_lang}' (likely music/audio, not spoken content).")
+            failed += 1
             try:
                 os.remove(audio_path)
             except Exception:
@@ -206,16 +315,32 @@ def transcribe_videos(limit: int = 5, max_duration_sec: int = 600,
 
         time.sleep(1)  # Gentle delay
 
-    print(f"\n[✓] Done! Transcribed {processed} videos.")
+    print(f"\n[✓] Done! Transcribed {processed}/{attempted} videos (failed: {failed}).")
+    return {"attempted": attempted, "processed": processed, "failed": failed}
 
 def main():
     parser = argparse.ArgumentParser(description="Transcribe Moldovan YouTube videos via homelab Whisper")
     parser.add_argument("--limit", type=int, default=5, help="Max videos to transcribe")
     parser.add_argument("--corpus", default=CORPUS_PATH, help="Path to corpus JSONL")
     parser.add_argument("--output-dir", default=TRANSCRIPT_DIR, help="Transcript output dir")
+    parser.add_argument("--allow-zero", action="store_true",
+                        help="Exit 0 even if nothing was transcribed (e.g. nothing pending)")
     args = parser.parse_args()
 
-    transcribe_videos(limit=args.limit, corpus_path=args.corpus, transcript_dir=args.output_dir)
+    summary = transcribe_videos(limit=args.limit, corpus_path=args.corpus,
+                                transcript_dir=args.output_dir)
+    if not summary:
+        return 0
+
+    # A total failure of the batch must surface as a non-zero exit so the weekly
+    # pipeline stops reporting "COMPLETED SUCCESSFULLY" while transcription is
+    # silently broken (that masking hid a long-running Whisper outage).
+    if summary["attempted"] > 0 and summary["processed"] == 0 and not args.allow_zero:
+        print("[!] ERROR: attempted transcription but produced no transcripts.")
+        print("[!] Check yt-dlp downloads and the Whisper endpoint (WHISPER_URL).")
+        return 1
+    return 0
+
 
 if __name__ == "__main__":
-    main()
+    raise SystemExit(main())

tests/unit/test_pipeline_failure_honesty.py

@@ -0,0 +1,257 @@
+"""Regression contracts for the weekly harvesting pipeline's failure honesty.
+
+Two silent-failure bugs made a fully broken harvest look healthy:
+
+1. ``transcribe_moldovan_videos.py`` printed "Done! Transcribed 0 videos." and
+   exited 0 when every download or transcription failed. The weekly pipeline
+   therefore reported "COMPLETED SUCCESSFULLY" while transcription had been
+   producing nothing (measured: 8 of 12 recorded runs transcribed 0 videos).
+
+2. ``run_automated_pipeline.sh`` used ``set -e`` without ``pipefail``, and every
+   stage pipes into ``tee``. A failing stage on the left of a pipe was invisible
+   to ``set -e``, so any broken stage still ended in a success banner.
+
+3. The yt-dlp format selector ``bestaudio[ext=m4a]/bestaudio`` failed with
+   "Requested format is not available" whenever the only audio-only streams were
+   webm/opus, silently yielding 0 downloads.
+
+All tests are offline: network calls are stubbed, nothing is downloaded.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+TRANSCRIBE = REPO_ROOT / "moldovan-qwen" / "scripts" / "transcribe_moldovan_videos.py"
+PIPELINE = REPO_ROOT / "moldovan-qwen" / "scripts" / "run_automated_pipeline.sh"
+
+
+def _load_transcribe():
+    spec = importlib.util.spec_from_file_location("transcribe_mod", TRANSCRIBE)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _run_main(mod, argv):
+    old = sys.argv
+    sys.argv = ["transcribe_moldovan_videos.py", *argv]
+    try:
+        return mod.main()
+    finally:
+        sys.argv = old
+
+
+def test_total_failure_exits_nonzero(monkeypatch):
+    """Attempting work and producing nothing must fail loudly, not exit 0."""
+    mod = _load_transcribe()
+    monkeypatch.setattr(
+        mod, "transcribe_videos",
+        lambda **kwargs: {"attempted": 3, "processed": 0, "failed": 3},
+    )
+
+    assert _run_main(mod, ["--limit", "3"]) == 1
+
+
+def test_partial_success_exits_zero(monkeypatch):
+    """One good transcript means the batch is not a total failure."""
+    mod = _load_transcribe()
+    monkeypatch.setattr(
+        mod, "transcribe_videos",
+        lambda **kwargs: {"attempted": 3, "processed": 1, "failed": 2},
+    )
+
+    assert _run_main(mod, ["--limit", "3"]) == 0
+
+
+def test_nothing_pending_is_a_healthy_noop(monkeypatch):
+    """Zero attempts is not a failure: nothing needed transcribing."""
+    mod = _load_transcribe()
+    monkeypatch.setattr(
+        mod, "transcribe_videos",
+        lambda **kwargs: {"attempted": 0, "processed": 0, "failed": 0},
+    )
+
+    assert _run_main(mod, ["--limit", "3"]) == 0
+
+
+def test_allow_zero_override_keeps_exit_zero(monkeypatch):
+    """An explicit override must still be able to tolerate a total failure."""
+    mod = _load_transcribe()
+    monkeypatch.setattr(
+        mod, "transcribe_videos",
+        lambda **kwargs: {"attempted": 2, "processed": 0, "failed": 2},
+    )
+
+    assert _run_main(mod, ["--allow-zero"]) == 0
+
+
+def test_transcribe_videos_returns_a_counts_summary(tmp_path, monkeypatch):
+    """The summary contract callers depend on: attempted/processed/failed."""
+    mod = _load_transcribe()
+    monkeypatch.setattr(mod, "CORPUS_PATH", str(tmp_path / "none.jsonl"))
+    monkeypatch.setattr(mod, "TRANSCRIPT_DIR", str(tmp_path / "out"))
+
+    summary = mod.transcribe_videos(
+        limit=1,
+        corpus_path=str(tmp_path / "none.jsonl"),
+        transcript_dir=str(tmp_path / "out"),
+    )
+
+    assert summary == {"attempted": 0, "processed": 0, "failed": 0}
+
+
+def test_download_audio_uses_a_fallback_chain_not_a_strict_selector(tmp_path, monkeypatch):
+    """Format availability fluctuates, so a single strict selector is unsafe.
+
+    `bestaudio[ext=m4a]/bestaudio` failed with "Requested format is not
+    available" on webm/opus-only audio, and plain `bestaudio` was observed to
+    fail intermittently on the same video. The download path must try several
+    selectors and must not require an m4a container.
+    """
+    mod = _load_transcribe()
+    attempts = []
+
+    class _Result:
+        returncode = 0
+        stderr = ""
+
+    def fake_run(cmd, **kwargs):
+        attempts.append(cmd)
+        return _Result()
+
+    monkeypatch.setattr(mod.subprocess, "run", fake_run)
+    # The normalized WAV is what download_audio should end up returning.
+    (tmp_path / "vid123.16k.wav").write_bytes(b"wav")
+
+    mod.download_audio("vid123", str(tmp_path))
+
+    fmts = [c[c.index("-f") + 1] for c in attempts if "-f" in c]
+    assert fmts, "no yt-dlp format selector was used"
+    assert not any("[ext=m4a]" in f for f in fmts), (
+        "strict m4a-only selector reintroduced"
+    )
+    assert "bestaudio" in fmts[0], f"first attempt should prefer audio: {fmts}"
+
+
+def test_download_audio_normalizes_to_small_mono_wav(tmp_path, monkeypatch):
+    """A video container from yt-dlp must be downmixed before it reaches Whisper.
+
+    yt-dlp sometimes has no audio-only rendition available and returns a full
+    video; uploading that wasted bandwidth and blew up the GPU (CUDA OOM on a
+    475 MB 1080p file). ffmpeg normalizes to 16 kHz mono first.
+    """
+    mod = _load_transcribe()
+    calls = []
+
+    class _Result:
+        returncode = 0
+        stderr = ""
+
+    def fake_run(cmd, **kwargs):
+        calls.append(cmd)
+        # Materialize the normalized output so the helper sees a real file.
+        if cmd and cmd[0] == "ffmpeg":
+            open(cmd[-1], "wb").write(b"RIFF")
+        return _Result()
+
+    monkeypatch.setattr(mod.subprocess, "run", fake_run)
+    (tmp_path / "vidABC.mp4").write_bytes(b"\x00" * 2048)
+
+    out = mod.download_audio("vidABC", str(tmp_path))
+
+    ffmpeg_calls = [c for c in calls if c and c[0] == "ffmpeg"]
+    assert ffmpeg_calls, "no ffmpeg normalization step ran"
+    ff = ffmpeg_calls[0]
+    assert "-vn" in ff, "video stream must be dropped"
+    assert "16000" in ff, "must resample to 16 kHz"
+    assert "1" in ff, "must downmix to mono"
+    assert out is not None and out.endswith(".16k.wav"), out
+
+
+def test_pipeline_enables_pipefail():
+    """`set -e` alone cannot see a failure on the left of a pipe into `tee`."""
+    text = PIPELINE.read_text(encoding="utf-8")
+    assert "set -e" in text
+    assert "set -o pipefail" in text or "set -euo pipefail" in text, (
+        "pipeline lacks pipefail: a broken stage would still report success"
+    )
+
+
+def test_pipeline_treats_transcription_outage_as_nonfatal_but_loud():
+    """Whisper is external, so its outage must warn, not abort all stages."""
+    text = PIPELINE.read_text(encoding="utf-8")
+    marker = "transcribe_moldovan_videos.py"
+    assert marker in text
+    # The transcribe stage must be wrapped so its failure is handled explicitly.
+    assert "WARNING: transcription stage failed" in text, (
+        "transcription failure is not surfaced as a warning"
+    )
+
+
+# ─── Whisper endpoint wiring (found broken in audit 3) ──────────────────────
+# The configured endpoint pointed at http://homelab:8086/v1/transcribe, a port
+# nothing listens on, and the multipart part was named "audio" while the server
+# requires "file". Both made every transcription attempt fail. The correct route
+# is the homelab Caddy proxy: /api/v1/whisper/v1/audio/transcriptions.
+
+def test_whisper_url_points_at_a_real_route():
+    """The default endpoint must be the verified Caddy-proxied route."""
+    mod = _load_transcribe()
+    url = mod.WHISPER_URL
+
+    assert ":8086" not in url, (
+        "stale endpoint: nothing listens on homelab:8086 (verified curl 000)"
+    )
+    assert "/v1/transcribe" not in url, (
+        "stale route: faster-whisper serves /v1/audio/transcriptions"
+    )
+    assert url.endswith("/v1/audio/transcriptions"), url
+
+
+def test_whisper_multipart_field_is_named_file():
+    """faster-whisper requires the file part to be named 'file'."""
+    src = TRANSCRIBE.read_text(encoding="utf-8")
+    assert 'name="file"' in src, (
+        "multipart part must be named 'file'; 'audio' is rejected by the server"
+    )
+    assert 'name="audio"' not in src, "stale multipart field name reintroduced"
+
+
+def test_whisper_url_is_overridable_by_env(monkeypatch):
+    """Deployments must be able to point at another Whisper instance."""
+    monkeypatch.setenv("WHISPER_URL", "http://example.test/v1/audio/transcriptions")
+    mod = _load_transcribe()
+    assert mod.WHISPER_URL == "http://example.test/v1/audio/transcriptions"
+
+
+def test_pipeline_has_a_freshness_health_check():
+    """Success must depend on artifacts actually advancing.
+
+    Transcripts had been empty since mid-August while the weekly job still
+    printed a success banner, so staleness went unnoticed for weeks. The
+    pipeline must inspect artifact age and refuse to claim success when material
+    is stale or missing.
+    """
+    text = PIPELINE.read_text(encoding="utf-8")
+
+    assert "[health]" in text, "no freshness health section"
+    assert "STALE" in text, "staleness is never reported"
+    assert "PIPELINE COMPLETED WITH STALE/MISSING ARTIFACTS" in text, (
+        "pipeline can still claim success with stale artifacts"
+    )
+    # Every key artifact the farm consumes must be covered.
+    for artifact in ("youtube_corpus", "transcripts", "generated_digests"):
+        assert artifact in text, f"{artifact} not covered by the health check"
+
+
+def test_pipeline_fails_when_health_check_fails():
+    """The staleness verdict must change the exit code, not just the message."""
+    text = PIPELINE.read_text(encoding="utf-8")
+    assert "HEALTH_FAIL" in text
+    assert "exit 1" in text, "no non-zero exit for a stale/missing artifact"