Cerrar el alta de cuentas y apagar la cola de muestras por defecto

Contención inmediata de ARCHITECTURE_REVIEW §2.2 y §2.1. Ninguna de las dos es
el arreglo estructural —ese es el scoping por tenant— pero ambas reducen hoy la
superficie sin tocar el modelo de datos.

ALTA CERRADA (§2.2). Cualquiera podía POSTear /api/auth/registro y alcanzar
/api/interpret, que gasta cuota de ZeroGPU compartida y, por la ruta Claude,
dinero real: `limite_interpret_usuario` era un techo sobre una identidad que
costaba una petición HTTP acuñar. Ahora `registro_abierto=False` +
`registro_allowlist`.

Dos detalles que no son cosméticos:
- La comprobación de allowlist va ANTES que la de existencia. Al revés, un email
no aprobado distinguiría 409 (existe) de 403 (no existe) y el alta sería un
oráculo de la base de usuarios. Fuera de la lista: 403 siempre.
- Es una lista de emails y no un booleano porque `instance/` es efímero (§3.4):
las cuentas desaparecen en cada reinicio, así que un alta cerrada sin lista
dejaría la instancia sin acceso posible. Se avisa al arrancar si la lista está
vacía.

COLA DE MUESTRAS APAGADA (§2.1). `GET /api/lab/pendientes` enumeraba las muestras
de TODAS las clínicas para cualquier sesión, y cada `muestra_id` abre en
/lab/resultados el panel completo más las pistas de paciente (nombre, raza,
sexo). Ahora 404 salvo `lab_pendientes_habilitado=true`; 404 y no 403 para que
apagada sea indistinguible de inexistente. El frontend retira el botón en vez de
dejarlo fallando.

Esto NO cierra §2.1 y el comentario lo dice: el `muestra_id` lo pone el
analizador y suele ser correlativo, así que /lab/resultados sigue siendo
enumerable a fuerza bruta. Lo que desaparece es el volcado en una petición.

PRUEBAS. La suite sigue describiendo el defecto (cerrado); las que sólo necesitan
sesión piden el fixture `alta_abierta`. `_limitador_limpio` (autouse) vacía el
contador de rate limiting entre pruebas: es de proceso y el TestClient sale
siempre de la misma IP, así que al añadir altas empezaron a saltar 429 según el
ORDEN de ejecución.

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

CLAUDE.md

@@ -108,6 +108,29 @@ cuesta el doble, exige retención de datos de 30 días (incompatible con el posi
 privacidad) y sus clasificadores pueden rechazar trabajo clínico legítimo con
 `stop_reason="refusal"` — ver el comentario en `backend/app/config.py`.
 
+### Admisión de cuentas y superficie de laboratorio
+
+Dos defectos que se cerraron y **no se vuelven a abrir sin sustituirlos por algo mejor**:
+
+- **El alta está CERRADA** (`registro_abierto=False` + `registro_allowlist`). Una cuenta llega
+  a `/api/interpret`, que gasta cuota de ZeroGPU compartida y dinero real por la ruta Claude:
+  con el alta abierta, `limite_interpret_usuario` protegía una identidad que costaba una
+  petición HTTP acuñar. La comprobación de allowlist va **antes** que la de existencia, si no
+  el alta se convierte en un oráculo de qué cuentas hay (403 siempre, nunca 409, fuera de la
+  lista). Es una **lista de emails y no un booleano** porque `instance/` es efímero: sin ella,
+  el primer reinicio deja la instancia sin cuentas y sin forma de crear ninguna.
+- **`GET /api/lab/pendientes` está apagado** (`lab_pendientes_habilitado=False` → 404). Enumera
+  las muestras de todas las clínicas y cada `muestra_id` abre el panel completo más las pistas
+  de paciente. **Apagarlo no cierra el agujero y no hay que documentarlo como si lo hiciera**:
+  el `muestra_id` lo pone el analizador y suele ser correlativo, así que `/api/lab/resultados`
+  sigue siendo enumerable. Lo que elimina es el volcado en una petición. El cierre real es atar
+  cada resultado a un tenant y filtrar por sesión (ARCHITECTURE_REVIEW §2.1).
+
+Las pruebas describen el defecto CERRADO; las que sólo necesitan sesión piden el fixture
+`alta_abierta`. El fixture `_limitador_limpio` (autouse) vacía el contador de rate limiting
+entre pruebas: es de proceso y el TestClient sale siempre de la misma IP, así que sin él los
+429 aparecían según el orden de ejecución.
+
 ### Pattern Detection Logic (`analisis.ts`)
 
 Severity thresholds are based on deviation from the reference range. Reference ranges are dynamically adjusted for:

backend/.env.example

@@ -11,6 +11,16 @@ MORPHOS_ENTORNO=dev            # dev | prod
 MORPHOS_SESSION_SECRET=
 MORPHOS_COOKIE_SECURE=false     # true en prod (HTTPS)
 
+# --- Alta de cuentas (CERRADA por defecto) ---
+# Una cuenta alcanza /api/interpret, que gasta cuota de ZeroGPU compartida y, por la ruta
+# Claude, dinero real: el alta abierta era una autorización de gasto para cualquiera.
+#
+# IMPORTANTE en un despliegue: si dejas las dos vacías, NADIE puede darse de alta. Con
+# `instance/` efímero (HF Spaces) las cuentas desaparecen en cada reinicio, así que sin
+# allowlist la instancia se queda sin acceso posible. Pon aquí los emails aprobados.
+# MORPHOS_REGISTRO_ALLOWLIST=vet1@clinica.com,vet2@clinica.com
+MORPHOS_REGISTRO_ABIERTO=false   # true SÓLO en desarrollo local
+
 # --- Base de datos de usuarios (SQLite fuera del webroot por defecto) ---
 # MORPHOS_DB_PATH=/ruta/fuera/webroot/morphos.db
 
@@ -66,6 +76,15 @@ MORPHOS_RAG_MAX_POR_LIBRO=2
 # umbral a ojo puede vaciar la recuperación). Calibrar con evals/run_retrieval_eval.py.
 # MORPHOS_RAG_SCORE_MINIMO=
 
+# --- Integración de analizadores de laboratorio ---
+# MORPHOS_LAB_API_KEYS=clave-del-puente-1,clave-del-puente-2
+# Cola de muestras recibidas (GET /api/lab/pendientes) y el botón "Resultados pendientes" de la
+# UI. DESACTIVADA por defecto: el almacén no está segmentado por clínica, así que enumera las
+# muestras de TODAS y cada ID abre el panel completo de analitos. Enciéndela sólo donde las
+# sesiones son de una única clínica. Apagarla NO cierra el agujero (el muestra_id lo pone el
+# analizador y suele ser correlativo): el cierre real es filtrar por tenant.
+MORPHOS_LAB_PENDIENTES_HABILITADO=false
+
 # --- Rate limiting ---
 MORPHOS_LIMITE_INTERPRET=10/minute
 MORPHOS_LIMITE_LOGIN=5/minute

backend/app/config.py

@@ -7,6 +7,7 @@ lo necesario para una función concreta.
 
 from __future__ import annotations
 
+import logging
 import os
 from functools import lru_cache
 from pathlib import Path
@@ -15,6 +16,8 @@ from typing import Annotated
 from pydantic import AliasChoices, Field, field_validator
 from pydantic_settings import BaseSettings, NoDecode, SettingsConfigDict
 
+log = logging.getLogger(__name__)
+
 # Raíz del repo (…/morphos). La BD y el índice RAG viven FUERA del directorio servido.
 RAIZ_REPO = Path(__file__).resolve().parents[2]
 
@@ -47,6 +50,21 @@ class Configuracion(BaseSettings):
     cookie_secure: bool = Field(default=False)  # True en prod (HTTPS)
     session_max_age_s: int = Field(default=60 * 60 * 8)
 
+    # --- Alta de cuentas ---
+    # El alta era ABIERTA: cualquiera podía POSTear /api/auth/registro y alcanzar
+    # /api/interpret, que gasta cuota de ZeroGPU compartida y, por la ruta Claude, dinero real.
+    # El techo por usuario (`limite_interpret_usuario`) protege una identidad que costaba una
+    # petición HTTP acuñar, así que no era un techo.
+    #
+    # Por defecto CERRADA con lista blanca de emails. La lista (y no un simple booleano) es
+    # deliberada: `instance/` es efímero en Spaces, así que las cuentas desaparecen en cada
+    # reinicio. Con `registro_abierto=False` y sin lista, tras un reinicio no habría forma de
+    # crear ninguna cuenta y la app quedaría inservible; con lista, los aprobados se vuelven a
+    # dar de alta solos. Cuando los usuarios vivan en almacenamiento persistente, la lista pasa
+    # a ser sólo el control de admisión.
+    registro_abierto: bool = Field(default=False)
+    registro_allowlist: Annotated[list[str], NoDecode] = Field(default_factory=list)
+
     # --- Base de datos (usuarios). Ruta fuera del webroot. ---
     db_path: Path = Field(default=RAIZ_REPO / "instance" / "morphos.db")
     mysql_dsn: str = Field(default="")  # si se define, se usa en vez de SQLite
@@ -232,8 +250,23 @@ class Configuracion(BaseSettings):
     lab_api_keys: Annotated[list[str], NoDecode] = Field(default_factory=list)
     # Persistencia opcional de resultados en SQLite (sólo útil con volumen persistente).
     lab_persistir: bool = Field(default=False)
+    # Cola de muestras recibidas (`GET /api/lab/pendientes`). DESACTIVADA por defecto: enumera
+    # TODAS las muestras del almacén —que no está segmentado por clínica ni por usuario— y cada
+    # `muestra_id` que devuelve abre `GET /api/lab/resultados`, o sea el panel completo de
+    # analitos más las pistas de paciente (nombre de la mascota, raza, sexo). Cualquier sesión
+    # la podía llamar.
+    #
+    # Apagarla NO cierra el agujero y no hay que venderlo así: el `muestra_id` lo pone el
+    # analizador (el puente sólo lo recorta) y suele ser un correlativo corto, así que
+    # `/api/lab/resultados` sigue siendo enumerable a fuerza bruta dentro de
+    # `limite_lab_consulta`. Lo que se elimina es el volcado en UNA petición. El cierre real es
+    # atar cada resultado a un tenant y filtrar por la sesión (ver ARCHITECTURE_REVIEW §2.1).
+    #
+    # Se enciende en despliegues de una sola clínica, donde el conjunto de sesiones es el
+    # personal invitado. El frontend oculta el botón si el endpoint responde 404.
+    lab_pendientes_habilitado: bool = Field(default=False)
 
-    @field_validator("lab_api_keys", "modelos_locales", mode="before")
+    @field_validator("lab_api_keys", "modelos_locales", "registro_allowlist", mode="before")
     @classmethod
     def _dividir_lista(cls, v):
         """Acepta lista JSON o cadena separada por comas.
@@ -270,6 +303,30 @@ class Configuracion(BaseSettings):
                 permitidos[nombre] = modo.strip().lower() == "prosa"
         return permitidos
 
+    def emails_registro_permitidos(self) -> set[str]:
+        """Allowlist normalizada (minúsculas, sin espacios) para comparar con el email entrante."""
+        return {e.strip().lower() for e in self.registro_allowlist if e.strip()}
+
+    def registro_permitido(self, email: str) -> bool:
+        """Si este email puede darse de alta."""
+        if self.registro_abierto:
+            return True
+        return email.strip().lower() in self.emails_registro_permitidos()
+
+    def avisar_de_configuracion(self) -> None:
+        """Avisos de arranque que no justifican fallar, pero sí que se vean en el log."""
+        if self.registro_abierto:
+            log.warning(
+                "MORPHOS_REGISTRO_ABIERTO=true: cualquiera puede crear una cuenta y gastar "
+                "cuota de modelo. Sólo para desarrollo local."
+            )
+        elif not self.emails_registro_permitidos():
+            # El caso que deja la instancia inservible tras un reinicio con `instance/` efímero.
+            log.warning(
+                "Alta de cuentas cerrada y MORPHOS_REGISTRO_ALLOWLIST vacía: nadie puede "
+                "registrarse. Si la base de usuarios está vacía, nadie podrá entrar."
+            )
+
     def validar_prod(self) -> None:
         """Requisitos que sólo aplican en producción; falla cerrado si faltan."""
         if self.entorno != "prod":
@@ -289,4 +346,5 @@ class Configuracion(BaseSettings):
 def obtener_config() -> Configuracion:
     cfg = Configuracion()
     cfg.validar_prod()
+    cfg.avisar_de_configuracion()
     return cfg

backend/app/routers/auth.py

@@ -93,6 +93,14 @@ async def login(request: Request, body: LoginBody, response: Response) -> dict:
 @router.post("/auth/registro")
 @limiter.limit(obtener_config().limite_login)
 async def registro(request: Request, body: RegistroBody, response: Response) -> dict:
+    # ANTES que la comprobación de existencia, a propósito: si se hiciera después, un email
+    # fuera de la lista distinguiría «ya existe» (409) de «no existe» (403) y el alta se
+    # convertiría en un oráculo de qué cuentas hay. Fuera de la lista, siempre 403.
+    if not obtener_config().registro_permitido(body.email):
+        raise HTTPException(
+            status.HTTP_403_FORBIDDEN,
+            "El alta de cuentas está restringida. Solicita acceso al administrador.",
+        )
     if buscar_usuario(body.email):
         raise HTTPException(status.HTTP_409_CONFLICT, "Ya existe una cuenta con ese email.")
     crear_usuario(body.nombre, body.apellido, body.email, body.password)

backend/app/routers/lab.py

@@ -73,7 +73,16 @@ async def get_pendientes(
     request: Request,
     _sesion: dict = Depends(usuario_actual),
 ) -> list[ResumenPendiente]:
-    """Cola de resultados recibidos (más recientes primero) para elegir sin teclear el ID."""
+    """Cola de resultados recibidos (más recientes primero) para elegir sin teclear el ID.
+
+    Desactivada por defecto (`MORPHOS_LAB_PENDIENTES_HABILITADO`): el almacén no está
+    segmentado, así que esto enumera las muestras de TODAS las clínicas y cada ID abre el panel
+    completo en `/lab/resultados`. 404 —y no 403— para que apagada sea indistinguible de no
+    existir. Ver el comentario en `config.py`: apagarla reduce el volcado masivo, no sustituye
+    al filtrado por tenant.
+    """
+    if not obtener_config().lab_pendientes_habilitado:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "No disponible.")
     return [
         ResumenPendiente(
             muestra_id=r.muestra_id,

backend/tests/conftest.py

@@ -12,9 +12,41 @@ import os
 import tempfile
 from pathlib import Path
 
+import pytest
+
 # Debe fijarse ANTES de importar la config (que se cachea con lru_cache).
 os.environ["MORPHOS_IGNORAR_ENV_FILE"] = "1"
 _TMP = Path(tempfile.mkdtemp(prefix="morphos_test_"))
 os.environ.setdefault("MORPHOS_DB_PATH", str(_TMP / "test.db"))
 os.environ.setdefault("MORPHOS_SESSION_SECRET", "x" * 40)
 os.environ.setdefault("MORPHOS_ENTORNO", "dev")
+
+
+@pytest.fixture(autouse=True)
+def _limitador_limpio():
+    """Vacía el contador de rate limiting entre pruebas.
+
+    El limitador es un almacén en memoria de proceso (`security/rate_limit.py`) compartido por
+    toda la suite, y el TestClient sale siempre desde la misma IP ('testclient'), así que los
+    contadores se acumulan de una prueba a otra: `limite_login` (5/minute) cubre también
+    `/api/auth/registro`, y bastaba añadir pruebas de alta para que otras empezaran a recibir
+    429 según el ORDEN en que corrieran. Resetear aquí hace que cada prueba mida lo suyo.
+    """
+    from app.security.rate_limit import limiter
+
+    limiter.reset()
+    yield
+    limiter.reset()
+
+
+@pytest.fixture
+def alta_abierta(monkeypatch):
+    """Abre el alta de cuentas para las pruebas que sólo necesitan una sesión.
+
+    El alta está CERRADA por defecto y así se queda en el resto de la suite: eso es lo que
+    comprueban las pruebas de `test_registro_cerrado.py`. Las que sólo quieren llegar a otro
+    endpoint piden este fixture en vez de repetir el monkeypatch.
+    """
+    from app.config import obtener_config
+
+    monkeypatch.setattr(obtener_config(), "registro_abierto", True)

backend/tests/test_api.py

@@ -38,7 +38,7 @@ def test_cabeceras_seguridad_presentes(cliente):
     assert r.headers.get("X-Frame-Options") == "DENY"
 
 
-def test_flujo_registro_login_e_interpret(cliente, monkeypatch):
+def test_flujo_registro_login_e_interpret(cliente, monkeypatch, alta_abierta):
     # Registro emite sesión + CSRF.
     reg = cliente.post(
         "/api/auth/registro",
@@ -81,7 +81,7 @@ def test_modelos_requiere_sesion(cliente):
     assert cliente.get("/api/modelos").status_code == 401
 
 
-def test_interpret_rechaza_modelo_fuera_de_la_lista_blanca(cliente):
+def test_interpret_rechaza_modelo_fuera_de_la_lista_blanca(cliente, alta_abierta):
     """422 (error del cliente) y no 502: la petición es inválida, el modelo ni se llama."""
     reg = cliente.post(
         "/api/auth/registro",
@@ -100,7 +100,7 @@ def test_interpret_rechaza_modelo_fuera_de_la_lista_blanca(cliente):
     assert "no permitido" in r.text
 
 
-def test_registro_rechaza_password_corta(cliente):
+def test_registro_rechaza_password_corta(cliente, alta_abierta):
     r = cliente.post(
         "/api/auth/registro",
         json={"nombre": "B", "apellido": "C", "email": "b@example.com", "password": "corta"},

backend/tests/test_lab_ingesta.py

@@ -53,7 +53,7 @@ def test_ingesta_bearer_erroneo_es_401(cliente, monkeypatch):
     assert r.status_code == 401
 
 
-def test_ingesta_y_consulta_completa(cliente, monkeypatch):
+def test_ingesta_y_consulta_completa(cliente, monkeypatch, alta_abierta):
     monkeypatch.setattr(obtener_config(), "lab_api_keys", ["k-secreta"])
 
     # Ingesta con key válida.
@@ -89,10 +89,19 @@ def test_ingesta_rechaza_observaciones_vacias(cliente, monkeypatch):
 
 
 def test_pendientes_requiere_sesion(cliente):
+    """401 antes que 404: la dependencia de sesión corre antes del cuerpo del endpoint, así que
+    la cola apagada no convierte esto en un endpoint anónimo."""
     assert cliente.get("/api/lab/pendientes").status_code == 401
 
 
-def test_pendientes_lista_mas_reciente_primero(cliente, monkeypatch):
+def test_pendientes_desactivada_por_defecto_es_404(cliente, alta_abierta):
+    """Con sesión válida y la cola apagada (el defecto), 404: indistinguible de no existir."""
+    _con_sesion(cliente, email="pend-off@example.com")
+    assert cliente.get("/api/lab/pendientes").status_code == 404
+
+
+def test_pendientes_lista_mas_reciente_primero(cliente, monkeypatch, alta_abierta):
+    monkeypatch.setattr(obtener_config(), "lab_pendientes_habilitado", True)
     monkeypatch.setattr(obtener_config(), "lab_api_keys", ["k-secreta"])
     for muestra in ("PEND-1", "PEND-2"):
         cliente.post(

backend/tests/test_registro_cerrado.py

@@ -0,0 +1,79 @@
+"""El alta de cuentas está cerrada por defecto y sólo la abre una allowlist de emails.
+
+Por qué importa: una cuenta alcanza `/api/interpret`, que gasta cuota de ZeroGPU compartida y,
+por la ruta Claude, dinero real. Mientras el alta fue abierta, el techo por usuario
+(`limite_interpret_usuario`) protegía una identidad que costaba una petición HTTP acuñar.
+"""
+
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.config import obtener_config
+from app.main import app
+
+ALTA = {"nombre": "Ana", "apellido": "Vet", "password": "clave-segura-1"}
+
+
+@pytest.fixture
+def cliente():
+    with TestClient(app) as c:
+        yield c
+
+
+def _alta(cliente, email):
+    return cliente.post("/api/auth/registro", json={**ALTA, "email": email})
+
+
+def test_alta_cerrada_por_defecto(cliente):
+    """Sin tocar nada: el defecto del servicio rechaza el alta."""
+    r = _alta(cliente, "desconocida@example.com")
+    assert r.status_code == 403
+    assert "restringida" in r.text
+
+
+def test_email_en_la_allowlist_puede_darse_de_alta(cliente, monkeypatch):
+    monkeypatch.setattr(obtener_config(), "registro_allowlist", ["permitida@example.com"])
+    r = _alta(cliente, "permitida@example.com")
+    assert r.status_code == 200, r.text
+    assert r.json()["ok"] is True
+
+
+def test_allowlist_ignora_mayusculas_y_espacios(cliente, monkeypatch):
+    """El email entra por un formulario; comparar crudo dejaría fuera a un aprobado."""
+    monkeypatch.setattr(obtener_config(), "registro_allowlist", ["  Mixta@Example.COM "])
+    assert _alta(cliente, "mixta@example.com").status_code == 200
+
+
+def test_fuera_de_la_allowlist_no_revela_si_la_cuenta_existe(cliente, monkeypatch):
+    """403 tanto si la cuenta existe como si no: el alta no puede ser un oráculo de cuentas.
+
+    Si la comprobación de allowlist fuera DESPUÉS de la de existencia, un email no aprobado
+    distinguiría 409 (existe) de 403 (no existe) y enumeraría la base de usuarios.
+    """
+    monkeypatch.setattr(obtener_config(), "registro_allowlist", ["existente@example.com"])
+    assert _alta(cliente, "existente@example.com").status_code == 200  # ya existe a partir de aquí
+
+    monkeypatch.setattr(obtener_config(), "registro_allowlist", [])
+    existente = _alta(cliente, "existente@example.com")
+    inexistente = _alta(cliente, "jamas-vista@example.com")
+    assert existente.status_code == 403
+    assert inexistente.status_code == 403
+    assert existente.text == inexistente.text
+
+
+def test_registro_abierto_deja_pasar_a_cualquiera(cliente, monkeypatch):
+    """La vía de escape para desarrollo local sigue funcionando."""
+    monkeypatch.setattr(obtener_config(), "registro_abierto", True)
+    assert _alta(cliente, "cualquiera@example.com").status_code == 200
+
+
+def test_allowlist_admite_cadena_separada_por_comas(monkeypatch):
+    """Forma documentada en .env.example; la de lista JSON ya la cubre el validador compartido."""
+    from app.config import Configuracion
+
+    cfg = Configuracion(registro_allowlist="uno@example.com, dos@example.com")
+    assert cfg.emails_registro_permitidos() == {"uno@example.com", "dos@example.com"}
+    assert cfg.registro_permitido("dos@example.com")
+    assert not cfg.registro_permitido("tres@example.com")

frontend/src/lab-import.ts

@@ -298,6 +298,13 @@ function inicializarCola(
         mostrarToast('Inicia sesión para ver los resultados recibidos.', true);
         return;
       }
+      // 404 = la cola está desactivada en el servidor (MORPHOS_LAB_PENDIENTES_HABILITADO).
+      // No es un error del usuario: se retira el botón en vez de dejarlo fallando.
+      if (resp.status === 404) {
+        btn.hidden = true;
+        lista.hidden = true;
+        return;
+      }
       if (!resp.ok) {
         mostrarToast('Error al consultar los resultados recibidos.', true);
         return;