Aislar por clínica los resultados de analizador

ARCHITECTURE_REVIEW §2.1 (+ la parte de identidad de §2.9). Era el hallazgo más
grave de la revisión: `lab/almacen.py` era un dict global sin dueño y
`routers/lab.py` no filtraba nada, así que CUALQUIER sesión autenticada podía
leer la muestra de cualquier clínica, y `/api/lab/pendientes` las enumeraba todas
—sin necesidad siquiera de adivinar IDs—. Cada `muestra_id` abre el panel completo
de analitos más las pistas de paciente (nombre de la mascota, raza, sexo).

IDENTIDAD DE DISPOSITIVO. `lab_api_keys` pasa de lista de secretos anónimos a
`clinica:clave`. `verificar_dispositivo` devuelve el tenant dueño en vez de None,
y el recorrido sigue siendo en tiempo constante sobre TODAS las claves (un lookup
por diccionario sobre un secreto filtra por tiempo). Revocar = quitar la clave y
reiniciar.

DE DÓNDE SALE EL TENANT. Del servidor, siempre: de la API key en la ingesta y de
la cookie FIRMADA en la lectura. Nunca del cuerpo de la petición —si el puente
pudiera declarar su clínica, mentir en un campo bastaría para escribir en la de
otro— ni de un parámetro de consulta. Hay prueba de las dos cosas.

USUARIOS. Columna `tenant` (migración 3, estrenando el mecanismo del commit
anterior) asignada desde la allowlist (`email=clinica`), no desde el formulario.

COMPATIBILIDAD. Sin tenants declarados todo cae en "principal": dispositivos sin
prefijo, cuentas sin sufijo y las sesiones ya emitidas, que no llevan el campo en
la cookie y durarían hasta 8h. Un despliegue de una sola clínica —el caso actual—
no nota el cambio, y el aislamiento aparece en cuanto se declaran clínicas.

Una muestra de otra clínica devuelve 404, no 403: que exista tampoco es
información que se dé.

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

CLAUDE.md

@@ -119,12 +119,15 @@ Dos defectos que se cerraron y **no se vuelven a abrir sin sustituirlos por algo
   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).
+- **Los resultados de analizador están segmentados por CLÍNICA (tenant).** El tenant lo pone
+  siempre el servidor: de la API key del dispositivo en la ingesta (`clinica:clave`) y de la
+  cookie firmada en la lectura. **Nunca del cuerpo ni de un parámetro** — si el puente pudiera
+  declarar su clínica, mentir en un campo bastaría para escribir en la de otro. Una muestra de
+  otra clínica devuelve 404, no 403. Sin tenants declarados todo cae en `principal`, así que un
+  despliegue de una sola clínica no nota nada.
+- **`GET /api/lab/pendientes` sigue apagado por defecto** (`lab_pendientes_habilitado=False` →
+  404). Ya no es un volcado global —sólo lista la clínica de la sesión—, pero dentro de ella
+  enumera todas las muestras, así que se enciende a propósito.
 
 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

backend/.env.example

@@ -18,7 +18,9 @@ MORPHOS_COOKIE_SECURE=false     # true en prod (HTTPS)
 # 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
+# Formato: `email` o `email=clinica`. La clínica (tenant) decide qué resultados de analizador
+# ve esa cuenta; sin sufijo, la de por defecto ("principal").
+# MORPHOS_REGISTRO_ALLOWLIST=vet1@clinica.com,vet2@otra.com=clinica-b
 MORPHOS_REGISTRO_ABIERTO=false   # true SÓLO en desarrollo local
 
 # --- Base de datos de usuarios (SQLite fuera del webroot) ---
@@ -81,12 +83,17 @@ MORPHOS_RAG_MAX_POR_LIBRO=2
 # MORPHOS_RAG_SCORE_MINIMO=
 
 # --- Integración de analizadores de laboratorio ---
-# MORPHOS_LAB_API_KEYS=clave-del-puente-1,clave-del-puente-2
+# Formato: `clave` o `clinica:clave`. La clínica es la DUEÑA de lo que ingiera ese dispositivo,
+# y sólo las sesiones de esa misma clínica pueden leerlo. Sin prefijo, la de por defecto
+# ("principal"), que es lo que quiere un despliegue de una sola clínica.
+# El puente NO puede declarar su clínica en el cuerpo: sale de la clave, en el servidor.
+# Revocar un dispositivo = quitar su clave de aquí y reiniciar.
+# MORPHOS_LAB_API_KEYS=clinica-a:clave-del-puente-1,clinica-b: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.
+# UI. Desde el filtrado por clínica sólo enumera las muestras de la clínica de la sesión, así
+# que ya no es un volcado global. Sigue DESACTIVADA por defecto porque dentro de una misma
+# clínica lista todas las muestras de todos sus pacientes, que es más de lo que necesita la
+# mayoría de flujos; enciéndela si quieres el botón.
 MORPHOS_LAB_PENDIENTES_HABILITADO=false
 
 # --- Proxy inverso ---

backend/app/config.py

@@ -7,6 +7,7 @@ lo necesario para una función concreta.
 
 from __future__ import annotations
 
+import hmac
 import logging
 import os
 from functools import lru_cache
@@ -24,6 +25,11 @@ RAIZ_REPO = Path(__file__).resolve().parents[2]
 # Punto de montaje del almacenamiento persistente en HF Spaces.
 VOLUMEN_PERSISTENTE = Path("/data")
 
+# Clínica a la que pertenecen los dispositivos y usuarios que no declaran otra. Un despliegue de
+# una sola clínica —el caso normal— se queda entero aquí y no nota el cambio; el aislamiento
+# aparece en cuanto se declaran tenants distintos.
+TENANT_POR_DEFECTO = "principal"
+
 
 def _ruta_db_por_defecto() -> Path:
     """Volumen persistente si lo hay; si no, `instance/` (efímero) con aviso al arrancar.
@@ -344,9 +350,19 @@ class Configuracion(BaseSettings):
                 permitidos[nombre] = modo.strip().lower() == "prosa"
         return permitidos
 
+    def _allowlist_con_tenant(self) -> dict[str, str]:
+        """email → tenant. Formato `email` o `email=tenant`; sin sufijo, TENANT_POR_DEFECTO."""
+        mapa: dict[str, str] = {}
+        for entrada in self.registro_allowlist:
+            email, _, tenant = entrada.partition("=")
+            email = email.strip().lower()
+            if email:
+                mapa[email] = tenant.strip() or TENANT_POR_DEFECTO
+        return mapa
+
     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()}
+        return set(self._allowlist_con_tenant())
 
     def registro_permitido(self, email: str) -> bool:
         """Si este email puede darse de alta."""
@@ -354,6 +370,30 @@ class Configuracion(BaseSettings):
             return True
         return email.strip().lower() in self.emails_registro_permitidos()
 
+    def tenant_de_email(self, email: str) -> str:
+        """Clínica a la que pertenece un email al darse de alta.
+
+        Con el alta abierta (desarrollo) todo el mundo cae en el tenant por defecto: no hay
+        ninguna declaración de la que deducir otra cosa.
+        """
+        return self._allowlist_con_tenant().get(email.strip().lower(), TENANT_POR_DEFECTO)
+
+    def tenant_de_clave_dispositivo(self, token: str) -> str | None:
+        """Tenant dueño de esta API key de dispositivo, o None si no es válida.
+
+        Recorre TODAS las claves con `compare_digest` en vez de indexar un diccionario: un
+        lookup por hash sobre un secreto filtra por tiempo si coincide el prefijo, y esta
+        comparación es la única barrera de la ingesta.
+        """
+        encontrado: str | None = None
+        for entrada in self.lab_api_keys:
+            tenant, sep, clave = entrada.partition(":")
+            if not sep:
+                tenant, clave = TENANT_POR_DEFECTO, entrada
+            if hmac.compare_digest(token, clave.strip()):
+                encontrado = tenant.strip() or TENANT_POR_DEFECTO
+        return encontrado
+
     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:

backend/app/db.py

@@ -2,7 +2,7 @@
 
 Diferencias de seguridad frente a la versión PHP:
 - La BD SQLite vive en instance/ FUERA del directorio servido (no es descargable).
-- Sin credenciales por defecto: si se configura MySQL, usuario/clave vienen de entorno.
+- Esquema versionado con `PRAGMA user_version` (ver `_MIGRACIONES`).
 - Hash de contraseña con scrypt (stdlib), sal aleatoria por usuario.
 """
 
@@ -16,7 +16,7 @@ import sqlite3
 from collections.abc import Iterator
 from contextlib import contextmanager
 
-from .config import VOLUMEN_PERSISTENTE, obtener_config
+from .config import TENANT_POR_DEFECTO, VOLUMEN_PERSISTENTE, obtener_config
 
 log = logging.getLogger("morphos.db")
 
@@ -26,10 +26,11 @@ log = logging.getLogger("morphos.db")
 # Spaces, nadie puede llegar. Cada entrada de la lista es un paso; el índice+1 es la versión
 # resultante, y sólo se aplican los pasos por encima de la versión actual.
 #
-# Reglas: nunca se edita un paso ya publicado (una BD que lo aplicó no volvería a ejecutarlo),
-# los pasos se añaden al final, y cada uno debe poder correr sobre una BD que ya lo tuviera
-# —de ahí los `IF NOT EXISTS`—, porque las BD creadas antes de este mecanismo están en la
-# versión 0 con las tablas del paso 1 ya presentes.
+# Reglas: nunca se edita un paso ya publicado (una BD que lo aplicó no volvería a ejecutarlo) y
+# los pasos se añaden al final. La versión garantiza que cada paso corre UNA vez, así que no
+# tienen por qué ser idempotentes —el 3 es un ALTER TABLE, que no lo es—. Los `IF NOT EXISTS`
+# del paso 1 son por otro motivo: las BD creadas antes de este mecanismo están en la versión 0
+# con esas tablas ya presentes, y hay que poder ponerlas al día sin borrarlas.
 _MIGRACIONES: list[str] = [
     # 1 — esquema inicial (el que ya existía).
     """
@@ -60,6 +61,12 @@ CREATE TABLE IF NOT EXISTS resultados_lab (
     """
 CREATE INDEX IF NOT EXISTS idx_intentos_email_ip_momento
     ON intentos_login (email, ip, momento);
+""",
+    # 3 — clínica dueña de cada cuenta. Los usuarios que ya existan quedan en el tenant por
+    # defecto, que es donde también caen los dispositivos sin clínica declarada: un despliegue
+    # de una sola clínica no nota el cambio.
+    f"""
+ALTER TABLE usuarios ADD COLUMN tenant TEXT NOT NULL DEFAULT '{TENANT_POR_DEFECTO}';
 """,
 ]
 
@@ -127,17 +134,19 @@ def verificar_password(password: str, almacenado: str) -> bool:
 def buscar_usuario(email: str) -> sqlite3.Row | None:
     with _conexion() as con:
         cur = con.execute(
-            "SELECT id, nombre, apellido, email, password FROM usuarios WHERE email = ? LIMIT 1",
+            "SELECT id, nombre, apellido, email, password, tenant "
+            "FROM usuarios WHERE email = ? LIMIT 1",
             (email,),
         )
         return cur.fetchone()
 
 
-def crear_usuario(nombre: str, apellido: str, email: str, password: str) -> None:
+def crear_usuario(nombre: str, apellido: str, email: str, password: str, tenant: str) -> None:
     with _conexion() as con:
         con.execute(
-            "INSERT INTO usuarios (nombre, apellido, email, password) VALUES (?, ?, ?, ?)",
-            (nombre, apellido, email, hash_password(password)),
+            "INSERT INTO usuarios (nombre, apellido, email, password, tenant) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (nombre, apellido, email, hash_password(password), tenant),
         )
 
 

backend/app/lab/almacen.py

@@ -1,5 +1,8 @@
 """Almacén en proceso de resultados de analizador, emparejados por ID de muestra.
 
+Segmentado por TENANT: cada resultado lleva la clínica dueña y las lecturas la exigen. Antes era
+un dict global y cualquier sesión autenticada podía leer la muestra de cualquier clínica.
+
 Deliberadamente NO es SQLite: HF Spaces tiene disco efímero, un único worker de uvicorn, y
 los resultados son de vida corta (se emparejan con el formulario en minutos). Un dict con
 TTL + tope LRU es la primitiva correcta. Clave normalizada (trim + minúsculas) en lectura y
@@ -40,16 +43,24 @@ class AlmacenResultados:
             while len(self._datos) > self._max:
                 self._datos.popitem(last=False)  # desaloja el más antiguo
 
-    def obtener(self, muestra_id: str) -> ResultadoMapeado | None:
+    def obtener(self, muestra_id: str, tenant: str) -> ResultadoMapeado | None:
+        """Resultado de ESE tenant, o None. Un ID de otra clínica se comporta como inexistente.
+
+        El tenant es obligatorio a propósito: si fuera opcional, olvidarlo en una llamada nueva
+        devolvería datos de todas las clínicas en silencio, que es justo el fallo que esto cierra.
+        """
         with self._lock:
             self._barrer_locked()
             item = self._datos.get(_clave(muestra_id))
-            return item[1] if item else None
+            if item is None or item[1].tenant != tenant:
+                return None
+            return item[1]
 
-    def pendientes(self) -> list[ResultadoMapeado]:
+    def pendientes(self, tenant: str) -> list[ResultadoMapeado]:
+        """Cola de ESE tenant, más recientes primero."""
         with self._lock:
             self._barrer_locked()
-            return [r for (_, r) in reversed(self._datos.values())]
+            return [r for (_, r) in reversed(self._datos.values()) if r.tenant == tenant]
 
     def _barrer_locked(self) -> None:
         ahora = time.monotonic()

backend/app/routers/auth.py

@@ -14,7 +14,7 @@ import asyncio
 from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
 from pydantic import BaseModel, EmailStr, Field
 
-from ..config import obtener_config
+from ..config import TENANT_POR_DEFECTO, obtener_config
 from ..db import (
     buscar_usuario,
     crear_usuario,
@@ -50,9 +50,11 @@ class RegistroBody(BaseModel):
     password: str = Field(min_length=8, max_length=200)
 
 
-def _emitir_sesion(resp: Response, email: str, nombre: str) -> str:
+def _emitir_sesion(resp: Response, email: str, nombre: str, tenant: str) -> str:
     cfg = obtener_config()
-    token = firmar_sesion({"email": email, "nombre": nombre})
+    # El tenant viaja en la cookie FIRMADA: el cliente no puede cambiarlo sin romper la firma,
+    # y así leerlo no cuesta una consulta a la BD en cada petición.
+    token = firmar_sesion({"email": email, "nombre": nombre, "tenant": tenant})
     csrf = nuevo_token_csrf()
     resp.set_cookie(
         COOKIE_SESION, token, httponly=True, secure=cfg.cookie_secure,
@@ -94,7 +96,9 @@ async def login(request: Request, body: LoginBody, response: Response) -> dict:
         raise HTTPException(status.HTTP_401_UNAUTHORIZED, "Email o contraseña incorrectos.")
 
     await asyncio.to_thread(limpiar_intentos, body.email)
-    csrf = _emitir_sesion(response, usuario["email"], usuario["nombre"])
+    csrf = _emitir_sesion(
+        response, usuario["email"], usuario["nombre"], usuario["tenant"] or TENANT_POR_DEFECTO
+    )
     return {"ok": True, "nombre": usuario["nombre"], "csrf": csrf}
 
 
@@ -112,8 +116,13 @@ async def registro(request: Request, body: RegistroBody, response: Response) ->
     if await asyncio.to_thread(buscar_usuario, body.email):
         raise HTTPException(status.HTTP_409_CONFLICT, "Ya existe una cuenta con ese email.")
     # `crear_usuario` hashea con scrypt además de escribir: doble motivo para salir del bucle.
-    await asyncio.to_thread(crear_usuario, body.nombre, body.apellido, body.email, body.password)
-    csrf = _emitir_sesion(response, body.email, body.nombre)
+    # La clínica sale de la allowlist (`email=tenant`), no del cuerpo de la petición: dejar
+    # elegir tenant al que se registra permitiría entrar en los datos de otra clínica.
+    tenant = obtener_config().tenant_de_email(body.email)
+    await asyncio.to_thread(
+        crear_usuario, body.nombre, body.apellido, body.email, body.password, tenant
+    )
+    csrf = _emitir_sesion(response, body.email, body.nombre, tenant)
     return {"ok": True, "nombre": body.nombre, "csrf": csrf}
 
 

backend/app/routers/lab.py

@@ -24,7 +24,7 @@ from ..schemas_lab import (
     ResultadoMapeado,
     ResumenPendiente,
 )
-from ..security.authz import usuario_actual
+from ..security.authz import tenant_de_sesion, usuario_actual
 from ..security.device import verificar_dispositivo
 from ..security.rate_limit import limiter
 
@@ -36,9 +36,10 @@ router = APIRouter()
 async def post_ingesta(
     request: Request,  # requerido por slowapi
     cuerpo: ResultadoAnalizador,
-    _disp: None = Depends(verificar_dispositivo),  # 503 sin keys / 401 sin Bearer válido
+    tenant: str = Depends(verificar_dispositivo),  # 503 sin keys / 401 sin Bearer válido
 ) -> RespuestaIngesta:
     mapeado = mapear_resultado(cuerpo)
+    mapeado.tenant = tenant  # del servidor, a partir de la API key; nunca del cuerpo
     almacen.guardar(mapeado)
     if obtener_config().lab_persistir:
         # A un hilo como el resto de SQLite: el analizador manda en ráfaga
@@ -61,9 +62,9 @@ async def post_ingesta(
 async def get_resultados(
     request: Request,
     muestra: str = Query(..., min_length=1, max_length=128),
-    _sesion: dict = Depends(usuario_actual),  # 401 si no hay sesión
+    sesion: dict = Depends(usuario_actual),  # 401 si no hay sesión
 ) -> ResultadoMapeado:
-    res = almacen.obtener(muestra)
+    res = almacen.obtener(muestra, tenant_de_sesion(sesion))
     if res is None:
         raise HTTPException(
             status.HTTP_404_NOT_FOUND,
@@ -76,7 +77,7 @@ async def get_resultados(
 @limiter.limit(obtener_config().limite_lab_consulta)
 async def get_pendientes(
     request: Request,
-    _sesion: dict = Depends(usuario_actual),
+    sesion: dict = Depends(usuario_actual),
 ) -> list[ResumenPendiente]:
     """Cola de resultados recibidos (más recientes primero) para elegir sin teclear el ID.
 
@@ -96,5 +97,5 @@ async def get_pendientes(
             analitos=len(r.analitos),
             no_mapeados=len(r.no_mapeados),
         )
-        for r in almacen.pendientes()
+        for r in almacen.pendientes(tenant_de_sesion(sesion))
     ]

backend/app/schemas_lab.py

@@ -94,6 +94,10 @@ class ValorAnalito(BaseModel):
 class ResultadoMapeado(BaseModel):
     """Resultado listo para el frontend: analitos por clave canónica + no reconocidos."""
 
+    # Clínica dueña del resultado. Lo pone el SERVIDOR a partir de la API key del dispositivo
+    # (`verificar_dispositivo`), nunca el cuerpo de la ingesta: si el puente pudiera declararlo,
+    # mentir en un campo bastaría para escribir en la clínica de otro.
+    tenant: str = ""
     muestra_id: str
     instrumento_id: str
     momento: datetime

backend/app/security/authz.py

@@ -10,6 +10,7 @@ import hmac
 
 from fastapi import Cookie, Header, HTTPException, Request, status
 
+from ..config import TENANT_POR_DEFECTO
 from .session import CABECERA_CSRF, COOKIE_CSRF, COOKIE_SESION, leer_sesion
 
 
@@ -22,6 +23,17 @@ def usuario_actual(request: Request) -> dict:
     return sesion
 
 
+def tenant_de_sesion(sesion: dict) -> str:
+    """Clínica del usuario de la sesión.
+
+    Las sesiones emitidas ANTES de que existiera el tenant no lo llevan en la cookie firmada, y
+    duran hasta `session_max_age_s`. Caen al tenant por defecto, que es donde también viven los
+    dispositivos que no declaran clínica: un despliegue de una sola clínica —el caso normal—
+    sigue funcionando durante la transición sin que nadie tenga que volver a entrar.
+    """
+    return sesion.get("tenant") or TENANT_POR_DEFECTO
+
+
 def verificar_csrf(
     request: Request,
     x_csrf_token: str | None = Header(default=None, alias=CABECERA_CSRF),

backend/app/security/device.py

@@ -7,15 +7,19 @@ verificar_password en db.py). Falla cerrado: sin keys configuradas, la ingesta n
 
 from __future__ import annotations
 
-import hmac
-
 from fastapi import Header, HTTPException, status
 
 from ..config import obtener_config
 
 
-def verificar_dispositivo(authorization: str | None = Header(default=None)) -> None:
-    """Dependencia para /api/lab/ingesta. 503 si no hay keys; 401 si la Bearer no coincide."""
+def verificar_dispositivo(authorization: str | None = Header(default=None)) -> str:
+    """Dependencia para /api/lab/ingesta: devuelve el TENANT dueño de la clave.
+
+    Antes devolvía None y la clave era anónima: cualquier dispositivo escribía en un almacén
+    global y cualquier sesión lo leía. El tenant sale de la configuración del servidor, nunca
+    del cuerpo de la petición: si el puente pudiera declarar su clínica, bastaría mentir en un
+    campo para escribir en la de otro.
+    """
     cfg = obtener_config()
     if not cfg.lab_api_keys:
         raise HTTPException(
@@ -25,5 +29,7 @@ def verificar_dispositivo(authorization: str | None = Header(default=None)) -> N
     token = ""
     if authorization and authorization.lower().startswith("bearer "):
         token = authorization[7:].strip()
-    if not token or not any(hmac.compare_digest(token, k) for k in cfg.lab_api_keys):
+    tenant = cfg.tenant_de_clave_dispositivo(token) if token else None
+    if tenant is None:
         raise HTTPException(status.HTTP_401_UNAUTHORIZED, "Dispositivo no autorizado.")
+    return tenant

backend/tests/test_tenant_lab.py

@@ -0,0 +1,151 @@
+"""Aislamiento por clínica de los resultados de analizador (ARCHITECTURE_REVIEW §2.1).
+
+El almacén era un dict global sin dueño: cualquier sesión autenticada podía leer la muestra de
+cualquier clínica, y `/api/lab/pendientes` enumeraba TODAS. Cada `muestra_id` abre en
+`/api/lab/resultados` el panel completo más las pistas de paciente (nombre de la mascota, raza,
+sexo), así que el aislamiento es lo único que separa a una clínica de los datos de otra.
+
+Dos cosas que estas pruebas fijan y no pueden relajarse: el tenant lo pone el SERVIDOR (de la API
+key en la ingesta, de la cookie firmada en la lectura) y una muestra de otra clínica se comporta
+como inexistente, no como prohibida.
+"""
+
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.config import TENANT_POR_DEFECTO, obtener_config
+from app.lab.almacen import almacen
+from app.main import app
+
+CLAVE_A = "clave-de-la-clinica-a"
+CLAVE_B = "clave-de-la-clinica-b"
+
+PAYLOAD = {
+    "muestra_id": "M-1",
+    "instrumento_id": "vetscan-1",
+    "fabricante": "Abaxis",
+    "observaciones": [{"codigo_prueba": "GLU", "valor": "5.0", "unidad": "mmol/L"}],
+    "momento": "2026-07-25T10:00:00Z",
+}
+
+
+@pytest.fixture
+def cliente():
+    almacen._datos.clear()
+    with TestClient(app) as c:
+        yield c
+    almacen._datos.clear()
+
+
+@pytest.fixture
+def dos_clinicas(monkeypatch):
+    """Dos dispositivos y dos cuentas, cada uno en su clínica."""
+    cfg = obtener_config()
+    monkeypatch.setattr(cfg, "lab_api_keys", [f"clinica-a:{CLAVE_A}", f"clinica-b:{CLAVE_B}"])
+    monkeypatch.setattr(
+        cfg, "registro_allowlist", ["a@example.com=clinica-a", "b@example.com=clinica-b"]
+    )
+    monkeypatch.setattr(cfg, "lab_pendientes_habilitado", True)
+
+
+def _ingerir(cliente, clave, muestra):
+    return cliente.post(
+        "/api/lab/ingesta",
+        json={**PAYLOAD, "muestra_id": muestra},
+        headers={"Authorization": f"Bearer {clave}"},
+    )
+
+
+def _sesion(cliente, email):
+    """Sesión para ese email. La BD de pruebas se comparte, así que si la cuenta ya existe de
+    otra prueba se entra en vez de darla de alta (el tenant quedó fijado al crearla)."""
+    r = cliente.post(
+        "/api/auth/registro",
+        json={"nombre": "V", "apellido": "Vet", "email": email, "password": "clave-segura-1"},
+    )
+    if r.status_code == 409:
+        r = cliente.post(
+            "/api/auth/login", json={"email": email, "password": "clave-segura-1"}
+        )
+    assert r.status_code == 200, r.text
+    return r
+
+
+def test_una_clinica_no_ve_la_muestra_de_otra(cliente, dos_clinicas):
+    """El hallazgo central de §2.1: cualquier sesión leía cualquier muestra."""
+    assert _ingerir(cliente, CLAVE_A, "M-DE-A").status_code == 200
+
+    _sesion(cliente, "b@example.com")
+    r = cliente.get("/api/lab/resultados", params={"muestra": "M-DE-A"})
+
+    # 404 y no 403: existir o no en otra clínica tampoco es información que se dé.
+    assert r.status_code == 404
+
+
+def test_la_propia_clinica_si_la_ve(cliente, dos_clinicas):
+    """El complemento obligatorio: aislar no puede romper el caso legítimo."""
+    assert _ingerir(cliente, CLAVE_A, "M-DE-A").status_code == 200
+
+    _sesion(cliente, "a@example.com")
+    r = cliente.get("/api/lab/resultados", params={"muestra": "M-DE-A"})
+
+    assert r.status_code == 200
+    assert r.json()["muestra_id"] == "M-DE-A"
+
+
+def test_pendientes_solo_enumera_lo_propio(cliente, dos_clinicas):
+    """`pendientes` era el volcado en una petición: ahora sólo lista la clínica de la sesión."""
+    _ingerir(cliente, CLAVE_A, "M-DE-A")
+    _ingerir(cliente, CLAVE_B, "M-DE-B")
+
+    _sesion(cliente, "b@example.com")
+    r = cliente.get("/api/lab/pendientes")
+
+    assert r.status_code == 200
+    ids = [x["muestra_id"] for x in r.json()]
+    assert ids == ["M-DE-B"]
+
+
+def test_el_puente_no_puede_declarar_su_clinica(cliente, dos_clinicas):
+    """El tenant sale de la API key; si viniera del cuerpo, mentir bastaría para escribir en otra."""
+    r = cliente.post(
+        "/api/lab/ingesta",
+        json={**PAYLOAD, "muestra_id": "M-MENTIRA", "tenant": "clinica-b"},
+        headers={"Authorization": f"Bearer {CLAVE_A}"},
+    )
+    assert r.status_code == 200
+
+    _sesion(cliente, "b@example.com")
+    assert cliente.get("/api/lab/resultados", params={"muestra": "M-MENTIRA"}).status_code == 404
+
+
+def test_clave_sin_clinica_declarada_cae_en_la_de_por_defecto(cliente, monkeypatch):
+    """Compatibilidad: un despliegue de una sola clínica no declara tenants y sigue funcionando."""
+    cfg = obtener_config()
+    monkeypatch.setattr(cfg, "lab_api_keys", ["clave-suelta"])
+    monkeypatch.setattr(cfg, "registro_abierto", True)
+    monkeypatch.setattr(cfg, "lab_pendientes_habilitado", True)
+
+    assert _ingerir(cliente, "clave-suelta", "M-SUELTA").status_code == 200
+    _sesion(cliente, "suelto@example.com")
+
+    r = cliente.get("/api/lab/resultados", params={"muestra": "M-SUELTA"})
+    assert r.status_code == 200
+    assert r.json()["tenant"] == TENANT_POR_DEFECTO
+
+
+def test_clave_invalida_sigue_siendo_401(cliente, dos_clinicas):
+    assert _ingerir(cliente, "no-es-una-clave", "M-X").status_code == 401
+
+
+def test_el_tenant_de_la_clave_se_resuelve_bien():
+    """Unidad sobre el parseo `tenant:clave`, que es lo que sostiene todo lo anterior."""
+    cfg = obtener_config().model_copy(
+        update={"lab_api_keys": ["clinica-a:secreta-a", "suelta-sin-tenant"]}
+    )
+    assert cfg.tenant_de_clave_dispositivo("secreta-a") == "clinica-a"
+    assert cfg.tenant_de_clave_dispositivo("suelta-sin-tenant") == TENANT_POR_DEFECTO
+    assert cfg.tenant_de_clave_dispositivo("clinica-a") is None  # el prefijo no es la clave
+    assert cfg.tenant_de_clave_dispositivo("") is None