NutriSync — Revisión Adversarial: Capa de Caché

• ✓ Paso 1: CLAIM — decisión nombrada con su impacto
• ✓ Paso 2: EXTRACT — artefacto + contrato aislados, sin razonamiento
• ✓ Paso 3: DOUBT — revisor con prompt adversarial invocado
• ✓ Paso 4: RECONCILE — cada hallazgo clasificado contra el texto del artefacto
• ✓ Paso 5: STOP — condición de parada alcanzada (ciclo 2 sin hallazgos sustantivos)

# nutrition/cache.py
import threading
from functools import lru_cache
from typing import Optional
from datetime import datetime, timedelta

_plan_cache: dict = {}
_cache_lock = threading.Lock()
_CACHE_TTL_SECONDS = 300

def get_cached_plan(patient_id: int, clinic_id: int) -> Optional[dict]:
    key = f"{clinic_id}:{patient_id}"
    with _cache_lock:
        entry = _plan_cache.get(key)
        if entry and (datetime.utcnow() - entry["cached_at"]) < timedelta(seconds=_CACHE_TTL_SECONDS):
            return entry["data"]
        return None

def set_cached_plan(patient_id: int, clinic_id: int, data: dict) -> None:
    key = f"{clinic_id}:{patient_id}"
    with _cache_lock:
        _plan_cache[key] = {"data": data, "cached_at": datetime.utcnow()}

def invalidate_plan(patient_id: int, clinic_id: int) -> None:
    key = f"{clinic_id}:{patient_id}"
    with _cache_lock:
        _plan_cache.pop(key, None)

• C1Thread-safe bajo 50+ workers Gunicorn multi-proceso concurrentes.
• C2Aislamiento total: paciente de clínica A nunca expone datos a clínica B.
• C3Invalidación garantizada cuando un dietista actualiza el plan.
• C4TTL máximo 5 minutos para datos sensibles de salud.
• C5Compatible con despliegue multi-instancia en Railway.

⚠ Nota: el CLAIM no fue pasado al revisor. Solo ARTIFACT + CONTRACT.

Procediendo con hallazgos de modelo único solamente.

# nutrition/cache.py — v2 (post doubt-cycle 1)
# Reemplaza dict in-memory por Redis para garantizar C1, C3, C5

import json
import copy
from typing import Optional
import redis

_CACHE_TTL_SECONDS = 300  # 5 min — satisface C4
_KEY_PREFIX = "plan"       # namespace explícito

def _redis() -> redis.Redis:
    from app.config import settings
    return redis.Redis.from_url(settings.REDIS_URL, decode_responses=True)

def _key(clinic_id: int, patient_id: int) -> str:
    # Tipos explícitos — evita colisión int vs str (F2)
    return f"{_KEY_PREFIX}:{int(clinic_id)}:{int(patient_id)}"

def get_cached_plan(patient_id: int, clinic_id: int) -> Optional[dict]:
    """C1: Redis es thread-safe + process-safe por diseño.
    C2: key incluye clinic_id — aislamiento garantizado.
    C4: TTL gestionado por Redis EXPIRE."""
    raw = _redis().get(_key(clinic_id, patient_id))
    if raw is None:
        return None
    return json.loads(raw)   # deserialización = copia implícita (resuelve F4)

def set_cached_plan(patient_id: int, clinic_id: int, data: dict) -> None:
    # C4: EX=300 expira automáticamente
    # C3: invalidación en Redis es cross-process y cross-instance
    _redis().set(
        _key(clinic_id, patient_id),
        json.dumps(data),      # serialización = copia — resuelve F4
        ex=_CACHE_TTL_SECONDS
    )

def invalidate_plan(patient_id: int, clinic_id: int) -> None:
    # C3: DEL propaga a todos los procesos e instancias
    _redis().delete(_key(clinic_id, patient_id))

Se inició ciclo 2 sobre el artefacto corregido. El revisor examinó cache.py v2 y no encontró hallazgos sustantivos:

• Redis es thread-safe y process-safe por diseño de su cliente — no requiere Lock adicional
• JSON serialization es segura para tipos básicos (los planes nutricionales son dicts con strings/numbers)
• La key con int() explícito previene colisiones
• TTL de Redis respeta C4 exactamente

Condición de parada alcanzada: ciclo 2 devolvió solo hallazgos triviales (una sugerencia de añadir type hints explícitos al módulo Redis). Artefacto aprobado para commit.

• ✓ Toda decisión no trivial nombrada explícitamente como CLAIM antes de quedar asentada
• ✓ Al menos una revisión fresh-context por artefacto no trivial
• ✓ El revisor recibió ARTIFACT + CONTRACT — NO el CLAIM, NO el razonamiento del autor
• ✓ Prompt del revisor adversarial ("encuentra problemas"), no validador ("¿está bien?")
• ✓ Hallazgos clasificados contra el texto del artefacto (no rubber-stamping)
• ✓ Condición de parada alcanzada: ciclo 2 sin hallazgos sustantivos
• ✓ Cross-model ofrecido explícitamente al usuario en sesión interactiva
• — Cross-model skipped: deadline urgente, usuario autorizó explícitamente saltar
• ✓ Skip de cross-model reconocido en output (no silencioso)