feat(youtube): la visibilidad se comprueba desde fuera, no se le cree a la API

`/upload_short` contaba lo que la respuesta de la subida decía del vídeo. Eso
es la palabra de la API sobre sí misma, y todo el flujo de revisión descansa en
ella: el informe de fundamento se lee ANTES de publicar sólo si subir no
publica. El 2026-08-12, mirando un vídeo recién subido, la respuesta decía
`privacyStatus: private` y el vídeo se veía sin sesión — resultó ser un clic
humano en Studio y no un fallo, pero el episodio dejó claro que no había forma
de distinguir un caso del otro.

Ahora se contrasta: oEmbed contesta 200 a un vídeo que se ve sin sesión y 404 a
uno que no. Sin credenciales, sin tocar el scope — `youtube.upload` no puede
preguntar por el estado de un vídeo, y ampliarlo a uno que sí pueda significa
darle a un token de subida permiso para vaciar el canal.

Dos decisiones que van con esto:

- **Sólo el 200 es una prueba.** Un 404 no demuestra que el vídeo sea privado:
  también lo devuelve uno que YouTube aún no ha indexado. Por eso el negativo
  se mira dos veces y, si sigue negativo, se cuenta como "no se ve desde
  fuera", no como "es privado".
- **No haber podido comprobar no es haber comprobado que no.** Un fallo de red
  deja `reachable=None` y el parte lo dice, en vez de heredar la garantía que
  no tiene.

Cuando la API dice privado y el vídeo se ve, el aviso va en la PRIMERA línea
del mensaje de Telegram: enterarse tiene que costar cero atención.

Verificado contra la realidad — el mismo vídeo daba True antes de ocultarlo y
False después; un vídeo borrado y uno privado dan False, y uno público True.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/test_youtube.py

@@ -6,6 +6,7 @@ sube un vídeo a un canal de verdad, y eso no es algo que deba pasar por teclear
 """
 import json
 
+import aiohttp
 import pytest
 
 from src.generator import youtube as yt
@@ -75,6 +76,9 @@ class FakeSession:
     def put(self, url, **kw):
         return self._next("PUT", url)
 
+    def get(self, url, **kw):
+        return self._next("GET", url)
+
 
 @pytest.fixture(autouse=True)
 def clean_token_cache():
@@ -83,14 +87,33 @@ def clean_token_cache():
     yt._token_cache.clear()
 
 
+@pytest.fixture(autouse=True)
+def no_recheck_delay(monkeypatch):
+    """La segunda pasada de la comprobación espera 3 s en producción, que es lo
+    que tarda YouTube en indexar. Aquí no se espera a nada."""
+    monkeypatch.setattr(yt, "_VISIBILITY_RECHECK_DELAY", 0)
+
+
 @pytest.fixture
 def uploader():
     return YouTubeUploader(client_id="cid", client_secret="secret",
                            refresh_token="refresh")
 
 
+#: Lo que oEmbed contesta de un vídeo que no se ve sin sesión.
+OEMBED_HIDDEN = FakeResp(404, body="Not Found")
+#: Y de uno que sí.
+OEMBED_VISIBLE = FakeResp(200, {"title": "JAL 1628", "type": "video"})
+
+
 def patch(client, routes):
-    session = FakeSession(routes)
+    """El servidor falso, con la comprobación de visibilidad ya enrutada.
+
+    `upload()` la hace siempre, así que todo test que suba pasa por oEmbed. Por
+    defecto contesta "no se ve", que es lo que se espera de un vídeo privado; el
+    test que quiera el caso malo pone su propia ruta `/oembed`.
+    """
+    session = FakeSession({"/oembed": OEMBED_HIDDEN, **routes})
     client._session = lambda total: session
     return session
 
@@ -170,8 +193,10 @@ async def test_upload_does_metadata_then_bytes(uploader, video):
     assert result.video_id == "abc123"
     assert result.watch_url == "https://youtube.com/shorts/abc123"
     assert result.studio_url.endswith("/abc123/edit")
-    assert [c[0] for c in session.calls] == ["POST", "POST", "PUT"]
-    assert len(seen) == 3, "cada etapa avisa: autenticar, abrir, subir"
+    # Token, metadatos, bytes, y la comprobación de visibilidad — que se
+    # reintenta porque el primer 404 puede ser YouTube todavía indexando.
+    assert [c[0] for c in session.calls] == ["POST", "POST", "PUT", "GET", "GET"]
+    assert len(seen) == 4, "cada etapa avisa: autenticar, abrir, subir, comprobar"
 
 
 @pytest.mark.asyncio
@@ -339,3 +364,84 @@ def test_uploaded_video_urls():
     video = UploadedVideo(video_id="xyz", title="t", privacy_status="private")
     assert video.watch_url == "https://youtube.com/shorts/xyz"
     assert video.studio_url == "https://studio.youtube.com/video/xyz/edit"
+
+
+# --- la visibilidad, comprobada en vez de creída ----------------------------
+
+@pytest.mark.asyncio
+async def test_a_video_anyone_can_watch_is_detected(uploader, video):
+    """El caso que existe para pillar: la API dice privado y el vídeo se ve.
+
+    Todo el flujo de revisión — informe de fundamento primero, publicar después
+    — descansa en que subir NO publique. Si eso deja de ser cierto hay que
+    enterarse por el parte de la subida, no por una visita al canal.
+    """
+    patch(uploader, {
+        "/token": TOKEN_OK,
+        "/upload/youtube": FakeResp(200, {}, headers={"Location": "https://up/x"}),
+        "https://up/x": FakeResp(200, VIDEO_OK),
+        "/oembed": OEMBED_VISIBLE,
+    })
+
+    result = await uploader.upload(video, build_metadata(SPEC, "x"))
+
+    assert result.privacy_status == "private", "la API sigue diciendo privado"
+    assert result.reachable is True
+    assert result.visibility_contradiction
+
+
+@pytest.mark.asyncio
+async def test_a_private_video_reports_no_contradiction(uploader, video):
+    patch(uploader, {
+        "/token": TOKEN_OK,
+        "/upload/youtube": FakeResp(200, {}, headers={"Location": "https://up/x"}),
+        "https://up/x": FakeResp(200, VIDEO_OK),
+    })
+
+    result = await uploader.upload(video, build_metadata(SPEC, "x"))
+
+    assert result.reachable is False
+    assert not result.visibility_contradiction
+
+
+@pytest.mark.asyncio
+async def test_a_video_visible_only_on_the_second_look_still_counts(uploader):
+    """Segundos después de subirlo, oEmbed devuelve 404 de un vídeo que sí se
+    ve: aún no está indexado. Un solo vistazo daría por privado justo el vídeo
+    que hay que gritar."""
+    session = patch(uploader, {"/oembed": [OEMBED_HIDDEN, OEMBED_VISIBLE]})
+
+    assert await uploader.reachable("abc123") is True
+    assert len(session.calls) == 2
+
+
+@pytest.mark.asyncio
+async def test_two_hidden_looks_are_enough_to_stop_asking(uploader):
+    session = patch(uploader, {"/oembed": OEMBED_HIDDEN})
+
+    assert await uploader.reachable("abc123") is False
+    assert len(session.calls) == 2
+
+
+@pytest.mark.asyncio
+async def test_a_network_failure_is_not_knowing_rather_than_privacy(uploader):
+    """No se pudo comprobar NO es lo mismo que no se ve. Devolver False aquí
+    sería inventarse una garantía a partir de un fallo de red."""
+    class Broken:
+        async def __aenter__(self): return self
+        async def __aexit__(self, *a): return False
+
+        def get(self, url, **kw):
+            raise aiohttp.ClientError("sin red")
+
+    uploader._session = lambda total: Broken()
+
+    assert await uploader.reachable("abc123") is None
+
+
+@pytest.mark.asyncio
+async def test_an_upload_without_an_id_is_not_checked(uploader):
+    session = patch(uploader, {"/oembed": OEMBED_VISIBLE})
+
+    assert await uploader.reachable("") is None
+    assert session.calls == []