Arquitecto de automatización con IA: Día 51

# Importaciones base, semilla de la serie y carpeta del caso de la clínica en Python:
import warnings
warnings.filterwarnings('ignore')
import json
import re
import math
import hmac
import hashlib
from datetime import datetime, date, timedelta
from zoneinfo import ZoneInfo
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 120)
clinica = Path('sonrisa_norte_dia51')
clinica.mkdir(exist_ok = True)
ZONA = ZoneInfo('America/Mexico_City')
MXN_POR_USD, USD_POR_EUR = 18.50, 1.08           # tipos didácticos fijos de la serie
print('numpy', np.__version__, '| pandas', pd.__version__)
print('Carpeta del caso:', clinica.name, '| zona:', ZONA.key,
      '| hoy:', datetime(2026, 3, 23, 9, 0, tzinfo = ZONA).isoformat())

# Ficha de Sonrisa Norte retomada del Día 7 y lo que cambia frente a Trigo Lento en Python:
ficha = {'citas_dia': 18, 'dias_habiles': 20, 'minutos_llamada': 2.0, 'inasistencia': 0.15,
         'ingreso_cita_mxn': 850, 'hora_recepcion_mxn': 70}
CITAS_MES = ficha['citas_dia'] * ficha['dias_habiles']
horas_llamadas = CITAS_MES * ficha['minutos_llamada'] / 60
perdidas = CITAS_MES * ficha['inasistencia']
print(f'Citas al mes: {CITAS_MES} | llamadas de recordatorio: {horas_llamadas:.1f} h = '
      f'{horas_llamadas * ficha["hora_recepcion_mxn"]:,.0f} MXN')
print(f'Inasistencias esperadas: {perdidas:.0f} citas = {perdidas * ficha["ingreso_cita_mxn"]:,.0f} MXN al mes')

comparacion = pd.DataFrame([
    ('Unidad de valor', 'encargo (380 MXN)', 'cita (850 MXN)', 'el coste invisible es el sillón vacío'),
    ('Mensajes salientes', 'recordatorio de recogida', 'recordatorio de cita', 'misma categoría: utilidad'),
    ('Datos del mensaje', 'nombre, pedido, hora', 'nombre de pila, fecha, hora', 'nunca tratamiento ni dentista'),
    ('Consentimiento', 'por finalidad', 'expreso, por finalidad y escrito', 'datos de salud en la agenda'),
    ('Texto libre del cliente', 'chatbot y Claude si es ambiguo', 'solo Irma, sin IA', 'puede contener datos de salud'),
    ('Horario de envío', 'lunes a sábado, 9:00 a 19:00', 'lunes a viernes, 9:00 a 19:00', 'cierres de Semana Santa'),
    ('Plataforma', 'n8n propio y Cloud API', 'la que pague la clínica', 'Valeria solo asesora'),
], columns = ['concepto', 'Trigo Lento', 'Sonrisa Norte', 'qué cambia'])
print(comparacion.to_string(index = False))
(clinica / 'ficha_dia51.json').write_text(json.dumps(ficha, indent = 2), encoding = 'utf-8')

{
  "name": "recordatorio_cita",
  "language": "es_MX",
  "category": "UTILITY",
  "parameter_format": "positional",
  "components": [
    {
      "type": "BODY",
      "text": "Hola, {{1}}. Le recordamos su cita en la Clínica Dental Sonrisa Norte el {{2}} a las {{3}}. Estamos en Calle Ejemplo 123, Lindavista. Use un botón para confirmar o pedir otro horario.",
      "example": {"body_text": [["Ana", "martes 24 de marzo", "10:30"]]}
    },
    {"type": "FOOTER", "text": "Responda BAJA para dejar de recibir recordatorios"},
    {
      "type": "BUTTONS",
      "buttons": [{"type": "QUICK_REPLY", "text": "Confirmar"}, {"type": "QUICK_REPLY", "text": "Reprogramar"}]
    }
  ]
}

# Revisión de la plantilla: categoría, botones, baja, datos de salud, promoción y legibilidad en Python:
FUERTES = set('aeoáéóíú')
VOCALES = FUERTES | set('iuü')

def contar_silabas(palabra):
    # Núcleos vocálicos (Día 49): dos vocales seguidas son una sílaba salvo que ambas sean fuertes:
    p = palabra.lower()
    if p.isdigit() or ':' in p:
        return 2
    if p == 'y':
        return 1
    p, silabas, previa = re.sub(r'y$', 'i', p), 0, ''
    for letra in p:
        if letra in VOCALES and (previa not in VOCALES or (previa in FUERTES and letra in FUERTES)):
            silabas += 1
        previa = letra
    return max(silabas, 1)

def szigriszt(texto):
    palabras = re.findall(r'\d+(?::\d+)?|[a-záéíóúüñ]+', texto.lower())
    frases = [f for f in re.split(r'[.!?]+(?:\s|$)', texto) if re.search(r'\w', f)]
    S, W, F = sum(contar_silabas(w) for w in palabras), len(palabras), len(frases)
    return round(206.835 - 62.3 * S / W - W / F, 2)

CAMPOS_PERMITIDOS = {'nombre_pila', 'fecha_cita', 'hora_cita'}
SALUD = r'\b(endodoncia|extracci[oó]n|implante|ortodoncia|caries|dolor|limpieza|resina|tratamiento|dra?\.)'
PROMO = r'(\d+\s*%|descuento|aprovech\w*|promoci[oó]n|oferta|gratis|2x1)'

def revisar_mensaje(plantilla, campos):
    comp = {c['type']: c for c in plantilla['components']}
    cuerpo = comp['BODY']['text']
    ejemplo = cuerpo
    for i, valor in enumerate(comp['BODY']['example']['body_text'][0], 1):
        ejemplo = ejemplo.replace('{{' + str(i) + '}}', valor)
    botones = [b['text'] for b in comp.get('BUTTONS', {}).get('buttons', [])]
    pie = comp.get('FOOTER', {}).get('text', '')
    P = szigriszt(ejemplo)
    revision = {
        'categoría': plantilla['category'],
        'campos de salud': ', '.join(c for c in campos if c not in CAMPOS_PERMITIDOS) or 'ninguno',
        'palabras clínicas': ', '.join(re.findall(SALUD, ejemplo, flags = re.I)) or 'ninguna',
        'promoción': ', '.join(m if isinstance(m, str) else m[0] for m in re.findall(PROMO, ejemplo, flags = re.I)) or 'ninguna',
        'botones': ' / '.join(botones),
        'baja en el pie': 'BAJA' in pie,
        'límites (1024/60/25)': len(cuerpo) <= 1024 and len(pie) <= 60 and all(len(b) <= 25 for b in botones),
        'Szigriszt-Pazos': P,
    }
    motivos = [k for k, v in revision.items() if (k in ('campos de salud', 'palabras clínicas', 'promoción') and
               v not in ('ninguno', 'ninguna')) or v is False]
    if P < 65:
        motivos.append('legibilidad < 65')
    if motivos[:1] and revision['promoción'] != 'ninguna':
        motivos.append('Meta la reclasificaría como marketing')
    return revision, ('RECHAZADA: ' + '; '.join(motivos) if motivos else 'ACEPTADA')

aceptada = json.loads((clinica / 'plantillas' / 'recordatorio_cita.json').read_text(encoding = 'utf-8'))
rechazada = {'name': 'recordatorio_cita_v0', 'language': 'es_MX', 'category': 'UTILITY', 'components': [
    {'type': 'BODY', 'text': ('Hola {{1}}, te recordamos tu cita de {{2}} con {{3}} el {{4}} a las {{5}}. '
                              'Aprovecha 10 % de descuento en tu limpieza dental si confirmas hoy.'),
     'example': {'body_text': [['Ana', 'endodoncia', 'la Dra. Lucía Fernández', 'martes 24 de marzo', '10:30']]}},
    {'type': 'BUTTONS', 'buttons': [{'type': 'QUICK_REPLY', 'text': 'Confirmar'},
                                    {'type': 'QUICK_REPLY', 'text': 'Reprogramar'}]}]}
rev_0, veredicto_0 = revisar_mensaje(rechazada, ['nombre_pila', 'tratamiento', 'dentista', 'fecha_cita', 'hora_cita'])
rev_1, veredicto_1 = revisar_mensaje(aceptada, ['nombre_pila', 'fecha_cita', 'hora_cita'])
print(pd.DataFrame({'rechazada (v0)': rev_0, 'aceptada': rev_1}).to_string())
print('v0:', veredicto_0)
print('v1:', veredicto_1)
cuerpo = aceptada['components'][0]['text']
print(f"Caracteres: cuerpo {len(cuerpo)} de 1024 | pie {len(aceptada['components'][1]['text'])} de 60")

# Reglas de envío: consentimiento por finalidad, baja, día hábil, horario y cierres en Python:
CIERRES = {date(2026, 4, 2), date(2026, 4, 3)}          # Jueves y Viernes Santo
HORARIO = (9, 19)                                        # de 9:00 a 19:00, lunes a viernes

def es_habil(d):
    return d.weekday() < 5 and d not in CIERRES

def dia_habil_anterior(d):
    d -= timedelta(days = 1)
    while not es_habil(d):
        d -= timedelta(days = 1)
    return d

def puede_recordar(cita, consentimientos, ahora):
    # Devuelve (se puede enviar, motivo); el primer motivo que falla es el que se registra:
    vigentes = [c for c in consentimientos.get(cita['paciente'], [])
                if c['finalidad'] == 'recordatorios_cita' and c['canal'] == 'whatsapp' and c['fecha'] <= ahora]
    if not vigentes:
        return False, 'sin consentimiento para esta finalidad y canal'
    if any(c['baja'] is not None and c['baja'] <= ahora for c in vigentes):
        return False, 'el paciente se dio de baja'
    dia_cita = cita['inicio'].date()
    if not es_habil(dia_cita):
        return False, 'cita en día inhábil o de cierre: la revisa una persona'
    if not es_habil(ahora.date()):
        return False, 'hoy no es día hábil de la clínica'
    if not HORARIO[0] <= ahora.hour < HORARIO[1]:
        return False, 'fuera del horario de 9:00 a 19:00'
    if ahora.date() != dia_habil_anterior(dia_cita):
        return False, f'no toca: se recuerda el {dia_habil_anterior(dia_cita):%d/%m}'
    return True, 'enviar'

t = lambda m, d, h, mi = 0: datetime(2026, m, d, h, mi, tzinfo = ZONA)
DIAS = ['lun', 'mar', 'mié', 'jue', 'vie', 'sáb', 'dom']
corto = lambda x: f'{DIAS[x.weekday()]} {x:%d/%m %H:%M}'
alta = t(1, 15, 12)
consentimientos = {
    'P01': [{'finalidad': 'recordatorios_cita', 'canal': 'whatsapp', 'fecha': alta, 'baja': None}],
    'P02': [{'finalidad': 'revisiones_semestrales', 'canal': 'whatsapp', 'fecha': alta, 'baja': None}],
    'P03': [{'finalidad': 'recordatorios_cita', 'canal': 'whatsapp', 'fecha': alta, 'baja': t(3, 20, 18)}],
    'P04': [{'finalidad': 'recordatorios_cita', 'canal': 'sms', 'fecha': alta, 'baja': None}],
}
casos = [
    ('Caso normal', 'P01', t(3, 24, 10, 30), t(3, 23, 10)),
    ('Solo consintió revisiones', 'P02', t(3, 24, 10, 30), t(3, 23, 10)),
    ('Se dio de baja el viernes', 'P03', t(3, 24, 10, 30), t(3, 23, 10)),
    ('Consintió por SMS', 'P04', t(3, 24, 10, 30), t(3, 23, 10)),
    ('Reintento a las 20:15', 'P01', t(3, 24, 10, 30), t(3, 23, 20, 15)),
    ('Cita del lunes, enviada el viernes', 'P01', t(3, 30, 9), t(3, 27, 10)),
    ('Cita del lunes, enviada el domingo', 'P01', t(3, 30, 9), t(3, 29, 10)),
    ('Cita el sábado 28', 'P01', t(3, 28, 11), t(3, 27, 10)),
    ('Cita el Jueves Santo', 'P01', t(4, 2, 12), t(4, 1, 10)),
    ('Cita del lunes 6 de abril, el 1', 'P01', t(4, 6, 9, 30), t(4, 1, 10)),
    ('Cita del lunes 6 de abril, el 3', 'P01', t(4, 6, 9, 30), t(4, 3, 10)),
    ('Cita del miércoles, enviada el lunes', 'P01', t(3, 25, 16), t(3, 23, 10)),
]
filas = []
for nombre, paciente, inicio, ahora in casos:
    ok, motivo = puede_recordar({'paciente': paciente, 'inicio': inicio}, consentimientos, ahora)
    filas.append((nombre, corto(inicio), corto(ahora), 'sí' if ok else 'no', motivo))
pruebas = pd.DataFrame(filas, columns = ['caso', 'cita', 'ahora', 'envía', 'motivo'])
print(pruebas.to_string(index = False))
print('Envíos permitidos:', (pruebas['envía'] == 'sí').sum(), 'de', len(pruebas))

# Calendario de recordatorios de abril de 2026 con Semana Santa en Python:
habiles = [d for d in pd.date_range('2026-04-01', '2026-04-30').date if es_habil(d)]
huecos = [(h, m) for h in range(9, 19) for m in (0, 30)]          # 20 huecos de media hora
citas = []
for d in habiles:
    for k in rng.choice(len(huecos), size = ficha['citas_dia'], replace = False):
        h, m = huecos[k]
        citas.append({'id_cita': f'C{len(citas) + 1:04d}', 'inicio': datetime(d.year, d.month, d.day, h, m, tzinfo = ZONA)})
citas = pd.DataFrame(citas)
citas['envio_1'] = [datetime.combine(dia_habil_anterior(i.date()), datetime.min.time(), ZONA) + timedelta(hours = 10)
                    for i in citas['inicio']]
responde_1 = rng.random(len(citas)) < 0.60
citas['envio_2'] = [e1 + timedelta(hours = 7) if not r else pd.NaT for e1, r in zip(citas['envio_1'], responde_1)]
envios = pd.concat([citas['envio_1'].rename('momento').to_frame().assign(aviso = 'primero'),
                    citas['envio_2'].dropna().rename('momento').to_frame().assign(aviso = 'segundo')])
envios['dia'] = [m.date() for m in envios['momento']]
fuera = [m for m in envios['momento'] if not (es_habil(m.date()) and HORARIO[0] <= m.hour < HORARIO[1])]
antelacion = (citas['inicio'] - citas['envio_1']).dt.total_seconds() / 3600
print(f'Días hábiles de abril: {len(habiles)} | citas: {len(citas)} | primeros avisos: {(envios.aviso == "primero").sum()}'
      f' | segundos avisos: {(envios.aviso == "segundo").sum()}')
print('Envíos fuera del horario o en día inhábil:', len(fuera))
print(f'Antelación del primer aviso: mínima {antelacion.min():.1f} h, mediana {antelacion.median():.1f} h, '
      f'máxima {antelacion.max():.1f} h')
print('Citas recordadas el 1 de abril:', int((citas['envio_1'].dt.date == date(2026, 4, 1)).sum()),
      '| de ellas, del lunes 6:', int(((citas['envio_1'].dt.date == date(2026, 4, 1)) &
                                      (citas['inicio'].dt.date == date(2026, 4, 6))).sum()))

por_dia = envios.groupby(['dia', 'aviso']).size().unstack(fill_value = 0)
dias = pd.date_range('2026-03-31', '2026-04-30').date
por_dia = por_dia.reindex(dias, fill_value = 0)
fig, (ax1, ax2) = plt.subplots(2, 1, figsize = (11, 6.4), gridspec_kw = {'height_ratios': [3, 1.3]})
x = np.arange(len(dias))
for i, d in enumerate(dias):
    if d.weekday() >= 5:
        ax1.axvspan(i - 0.5, i + 0.5, color = '#ecebe7')
    if d in CIERRES:
        ax1.axvspan(i - 0.5, i + 0.5, color = '#f6d2c4')
ax1.bar(x, por_dia['primero'], color = '#2a78d6', label = 'Primer aviso, 10:00')
ax1.bar(x, por_dia['segundo'], bottom = por_dia['primero'], color = '#eb6834', label = 'Segundo aviso, 17:00')
ax1.text(2.5, 31, 'Cierre de\nSemana Santa', ha = 'center', fontsize = 9, color = '#a33f17')
ax1.set_xticks(x[::2])
ax1.set_xticklabels([f'{d:%d/%m}' for d in dias[::2]], rotation = 45)
ax1.set_ylabel('Mensajes enviados')
ax1.set_ylim(0, 37)
ax1.legend(loc = 'upper right', fontsize = 9)
ax1.set_title('Recordatorios de las citas de abril de 2026 por día de envío', fontsize = 14)
horas = [m.hour + m.minute / 60 for m in envios['momento']]
ax2.axvspan(9, 19, color = '#d9ead3', label = 'Horario permitido (9:00 a 19:00)')
ax2.hist(horas, bins = np.arange(0, 24.5, 0.5), color = '#52514e')
ax2.set_xlim(0, 24)
ax2.set_xticks(range(0, 25, 3))
ax2.set_xlabel('Hora del envío')
ax2.set_ylabel('Mensajes')
ax2.legend(loc = 'upper right', fontsize = 9)
plt.tight_layout()
plt.show()

# Respuestas a un recordatorio: firma X-Hub-Signature-256, enrutamiento y derivación a Irma en Python:
SECRETO_APP = 'EJEMPLO-NO-REAL-secreto-de-la-app-sonrisa-norte'   # en n8n vive en una variable de entorno

def firmar(cuerpo, secreto):
    return 'sha256=' + hmac.new(secreto.encode(), cuerpo, hashlib.sha256).hexdigest()

def evento(i, telefono, boton = None, texto = None):
    m = {'from': telefono, 'id': f'wamid.EJEMPLO-NO-REAL-{i:03d}', 'timestamp': str(1774290000 + 60 * i)}
    m.update({'type': 'button', 'button': boton} if boton else {'type': 'text', 'text': {'body': texto}})
    valor = {'messaging_product': 'whatsapp', 'metadata': {'phone_number_id': 'EJEMPLO-NO-REAL-PNID'}, 'messages': [m]}
    cuerpo = json.dumps({'object': 'whatsapp_business_account',
                         'entry': [{'changes': [{'field': 'messages', 'value': valor}]}]}).encode()
    return cuerpo, firmar(cuerpo, SECRETO_APP)

ACCIONES = {
    'confirmar': ('marcar confirmada', 'automático', 'Gracias, su cita quedó confirmada.'),
    'reprogramar': ('pendiente para Irma', 'Irma', 'Irma le escribirá hoy con horarios.'),
    'baja': ('retirar consentimiento', 'automático', 'Ya no recibirá recordatorios.'),
    'texto_libre': ('bandeja de Irma, sin IA', 'Irma', 'Recibimos su mensaje; Irma le responde.'),
}

def atender(cuerpo, firma):
    if not hmac.compare_digest(firmar(cuerpo, SECRETO_APP), firma or ''):
        return {'tipo': 'firma inválida', 'accion': 'descartar sin responder', 'responsable': '-', 'acuse': '-',
                'registro': 'evento descartado'}
    m = json.loads(cuerpo)['entry'][0]['changes'][0]['value']['messages'][0]
    if m['type'] == 'button':
        tipo, id_cita = m['button']['payload'].split(':')
        tipo = tipo.lower()
    else:
        tipo = 'baja' if re.match(r'\s*(baja|ya no)\b', m['text']['body'], flags = re.I) else 'texto_libre'
        id_cita = None
    accion, responsable, acuse = ACCIONES[tipo]
    # El registro guarda identificadores y estados, nunca el texto del paciente:
    return {'tipo': tipo, 'accion': accion, 'responsable': responsable, 'acuse': acuse,
            'registro': f"{m['id'][-3:]} {id_cita or '-'} {tipo}"}

tel = lambda n: f'+52 55 0000 00{n:02d}'
eventos = ([evento(i, tel(i), boton = {'payload': f'CONFIRMAR:C{1000 + i}', 'text': 'Confirmar'}) for i in range(1, 13)] +
           [evento(i, tel(i), boton = {'payload': f'REPROGRAMAR:C{1000 + i}', 'text': 'Reprogramar'}) for i in range(13, 16)] +
           [evento(16, tel(16), texto = 'BAJA'), evento(17, tel(17), texto = 'ya no, gracias'),
            evento(18, tel(18), texto = 'me duele mucho la muela, ¿puedo ir antes?'),
            evento(19, tel(19), texto = '¿cuánto cuesta la limpieza?')])
cuerpo_alterado, firma_original = evento(20, tel(20), boton = {'payload': 'CONFIRMAR:C1020', 'text': 'Confirmar'})
eventos.append((cuerpo_alterado.replace(b'C1020', b'C9999'), firma_original))
atendidos = pd.DataFrame([atender(c, f) for c, f in eventos])
print(atendidos.groupby(['tipo', 'accion', 'responsable', 'acuse'], sort = False).size().rename('n').reset_index()
      .to_string(index = False))
print('Ejemplos de registro:', list(atendidos['registro'].iloc[[0, 12, 17, 19]]))
print('¿Algún registro contiene el texto de un paciente?',
      any('muela' in r or 'limpieza' in r for r in atendidos['registro']))
print('Mensajes que llegan a un modelo de IA en este flujo:', 0)

# Coste mensual de los recordatorios por arquitectura y plataforma (Tablas B y C) en Python:
TARIFA = {'utilidad': 0.0085, 'servicio': 0.0085, 'twilio': 0.005}   # USD, revisado en octubre de 2026
PLATAFORMA = {'n8n Cloud Starter': 24 * USD_POR_EUR, 'servidor propio': 6.00}
LIMITE_STARTER = 2500

def volumen(citas = CITAS_MES, p1 = 0.60, p2 = 0.50, p_irma = 0.16):
    plantillas = citas + citas * (1 - p1)                  # primer aviso a todos, segundo a quien no respondió
    respuestas = citas * p1 + citas * (1 - p1) * p2
    return {'plantillas': plantillas, 'respuestas': respuestas, 'acuses': respuestas,
            'avisos_irma': round(respuestas * p_irma), 'corridas': 2 * ficha['dias_habiles']}

def coste_recordatorios(arquitectura, plataforma, v, regimen = 'octubre'):
    acuses_cobrados = max(0, v['acuses'] - 1000) if regimen == 'octubre' else 0
    meta = (v['plantillas'] + v['avisos_irma']) * TARIFA['utilidad'] + acuses_cobrados * TARIFA['servicio']
    recargo = 0.0
    if arquitectura == 'Twilio':
        recargo = (v['plantillas'] + v['avisos_irma'] + v['respuestas'] + v['acuses']) * TARIFA['twilio']
    salientes = v['plantillas'] + v['acuses'] + v['avisos_irma']
    ejecuciones = v['corridas'] + v['respuestas'] + 3 * salientes      # enviado, entregado y leído
    total = meta + recargo + PLATAFORMA[plataforma]
    return {'arquitectura': arquitectura, 'plataforma': plataforma, 'meta': round(meta, 2), 'recargo': round(recargo, 2),
            'plataforma_usd': round(PLATAFORMA[plataforma], 2), 'total_usd': round(total, 2),
            'total_mxn': round(total * MXN_POR_USD, 2), 'ejecuciones': int(ejecuciones),
            'cabe_en_starter': ejecuciones <= LIMITE_STARTER if plataforma == 'n8n Cloud Starter' else '-'}

v = volumen()
print({k: round(x, 1) for k, x in v.items()})
print(f"Solo recordatorios por Cloud API: {v['plantillas'] * TARIFA['utilidad']:.2f} USD | por Twilio: "
      f"{v['plantillas'] * (TARIFA['utilidad'] + TARIFA['twilio']) + 2 * v['respuestas'] * TARIFA['twilio']:.2f} USD")
plan = 40 + v['respuestas'] + 3 * v['plantillas']
print(f'Ejecuciones contadas en el plan: {plan:.0f} | con estados de acuses y avisos: '
      f"{v['corridas'] + v['respuestas'] + 3 * (v['plantillas'] + v['acuses'] + v['avisos_irma']):.0f} | límite Starter: {LIMITE_STARTER}")
tabla_4 = pd.DataFrame([coste_recordatorios(a, p, v) for a in ('Cloud API directa', 'Twilio') for p in PLATAFORMA])
print(tabla_4.to_string(index = False))
anterior = coste_recordatorios('Cloud API directa', 'servidor propio', v, regimen = 'septiembre')['total_usd']
print('Régimen anterior al 1 de octubre, Cloud API y servidor propio:', anterior, 'USD (los acuses no llegan a 1 000)')

fig, ax = plt.subplots(figsize = (9, 4.8))
etiquetas = [f"{a}\n{p}" for a, p in zip(tabla_4.arquitectura, tabla_4.plataforma)]
ax.bar(etiquetas, tabla_4.meta, color = '#2a78d6', label = 'Tarifa de Meta')
ax.bar(etiquetas, tabla_4.recargo, bottom = tabla_4.meta, color = '#eb6834', label = 'Recargo del proveedor')
ax.bar(etiquetas, tabla_4.plataforma_usd, bottom = tabla_4.meta + tabla_4.recargo, color = '#8a8986', label = 'Plataforma n8n')
for i, total in enumerate(tabla_4.total_usd):
    ax.text(i, total + 0.6, f'{total:.2f} USD', ha = 'center', fontsize = 10)
ax.set_ylabel('USD al mes')
ax.set_ylim(0, 42)
ax.legend(loc = 'upper left', fontsize = 9)
ax.set_title('Coste mensual de los recordatorios de Sonrisa Norte', fontsize = 14)
plt.tight_layout()
plt.show()

# Simulación de 1 000 meses de citas con y sin recordatorios en Python:
MESES = 1000
P_RESPUESTA = (0.60, 0.50)                                  # primer aviso y segundo aviso
REPARTO = {'confirma': 0.82, 'reprograma': 0.12, 'baja': 0.02, 'texto_libre': 0.04}
P_FALTA = {'confirma': 0.05, 'baja': 0.15, 'texto_libre': 0.10, 'no_responde': 0.25}
P_REOCUPAR = 0.55                                           # hueco avisado que Irma vuelve a llenar
MIN_IRMA = {'reprograma': 4.0, 'texto_libre': 3.0}          # minutos de Irma por respuesta derivada

sin = rng.binomial(CITAS_MES, ficha['inasistencia'], size = MESES)
resultado = []
for _ in range(MESES):
    responde = (rng.random(CITAS_MES) < P_RESPUESTA[0]) | (rng.random(CITAS_MES) < P_RESPUESTA[1])
    grupo = np.where(responde, rng.choice(list(REPARTO), size = CITAS_MES, p = list(REPARTO.values())), 'no_responde')
    falta = np.array([rng.random() < P_FALTA.get(g, 0.0) for g in grupo])
    n_rep, n_lib = (grupo == 'reprograma').sum(), (grupo == 'texto_libre').sum()
    resultado.append({'faltas': falta.sum(), 'reprogramadas': n_rep, 'reocupadas': rng.binomial(n_rep, P_REOCUPAR),
                      'respuestas': responde.sum(),
                      'horas_irma': CITAS_MES * 2 / 60 - (n_rep * MIN_IRMA['reprograma'] + n_lib * MIN_IRMA['texto_libre']) / 60})
con = pd.DataFrame(resultado)
recuperadas = sin - con['faltas']
ingreso = recuperadas * ficha['ingreso_cita_mxn']
p = lambda s: f'{s.mean():.1f} [{np.percentile(s, 2.5):.1f}, {np.percentile(s, 97.5):.1f}]'
print('Media [intervalo del 95 %] de 1 000 meses simulados:')
print('  Inasistencias sin recordatorios:', p(pd.Series(sin)), f'| tasa {sin.mean() / CITAS_MES:.1%}')
print('  Inasistencias con recordatorios:', p(con['faltas']), f"| tasa {con['faltas'].mean() / CITAS_MES:.1%}")
print('  Respuestas al recordatorio:', p(con['respuestas']), '| reprogramadas:', p(con['reprogramadas']),
      '| huecos reocupados:', p(con['reocupadas']))
print('  Citas recuperadas:', p(recuperadas), '| ingreso recuperado (MXN):', p(ingreso))
print('  Horas de llamadas que Irma recupera, netas de reprogramar y leer textos:', p(con['horas_irma']))
print(f"  Meses con inasistencia por encima del 10.7 %: {(con['faltas'] / CITAS_MES > 0.107).mean():.1%}")
coste_mxn = tabla_4.query("arquitectura == 'Cloud API directa' and plataforma == 'servidor propio'")['total_mxn'].item()
sens = pd.DataFrame({'inasistencia_con_recordatorios': [0.12, 0.107, 0.09, round(con['faltas'].mean() / CITAS_MES, 3)]})
sens['citas_recuperadas'] = (CITAS_MES * (ficha['inasistencia'] - sens.iloc[:, 0])).round(1)
sens['ingreso_mxn'] = (sens['citas_recuperadas'] * ficha['ingreso_cita_mxn']).round(0)
sens['neto_mxn'] = (sens['ingreso_mxn'] + con['horas_irma'].mean() * ficha['hora_recepcion_mxn'] - coste_mxn).round(0)
print(sens.to_string(index = False))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (11, 4.6))
ax1.boxplot([sin, con['faltas']], widths = 0.5)
ax1.set_xticks([1, 2])
ax1.set_xticklabels(['Sin recordatorios', 'Con recordatorios'])
ax1.axhline(CITAS_MES * 0.09, color = '#eb6834', linestyle = '--', linewidth = 1, label = 'Supuesto del Día 7 (9 %)')
ax1.set_ylabel('Inasistencias al mes')
ax1.legend(fontsize = 9)
ax1.set_title('Inasistencias en 1 000 meses simulados', fontsize = 13)
ax2.hist(ingreso / 1000, bins = 30, color = '#1f9d55')
ax2.axvline(ingreso.mean() / 1000, color = '#52514e', linestyle = '--', label = f'Media: {ingreso.mean():,.0f} MXN')
ax2.set_xlabel('Ingreso recuperado (miles de MXN al mes)')
ax2.set_ylabel('Meses')
ax2.legend(fontsize = 9)
ax2.set_title('Ingreso recuperado por mes', fontsize = 13)
plt.tight_layout()
plt.show()

[
  {
    "name": "SN Recordatorios de citas v1",
    "nodes": [
      {
        "parameters": {"rule": {"interval": [{"field": "cronExpression", "expression": "0 10,17 * * 1-5"}]}},
        "id": "5a510001-0000-4000-8000-000000000001",
        "name": "Lunes a viernes 10:00 y 17:00",
        "type": "n8n-nodes-base.scheduleTrigger",
        "typeVersion": 1.2,
        "position": [0, 0]
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "SELECT c.id_cita, p.nombre_pila, p.telefono, sn_fecha_texto(c.inicio) AS fecha_texto, to_char(c.inicio AT TIME ZONE 'America/Mexico_City', 'HH24:MI') AS hora_texto, (cs.id_consentimiento IS NOT NULL) AS consentimiento_vigente, sn_dentro_de_horario(now()) AS dentro_de_horario FROM citas c JOIN pacientes p USING (id_paciente) LEFT JOIN consentimientos cs ON cs.id_paciente = p.id_paciente AND cs.finalidad = 'recordatorios_cita' AND cs.canal = 'whatsapp' AND cs.baja IS NULL WHERE c.estado = 'agendada' AND (c.inicio AT TIME ZONE 'America/Mexico_City')::date = sn_siguiente_dia_habil(current_date) AND NOT EXISTS (SELECT 1 FROM respuestas r WHERE r.id_cita = c.id_cita) AND (SELECT count(*) FROM envios e WHERE e.id_cita = c.id_cita) = CASE WHEN extract(hour FROM now() AT TIME ZONE 'America/Mexico_City') < 12 THEN 0 ELSE 1 END;",
          "options": {}
        },
        "id": "5a510001-0000-4000-8000-000000000002",
        "name": "Citas del siguiente día hábil",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [220, 0],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "conditions": {
            "options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2},
            "conditions": [
              {
                "id": "c0000000-0000-4000-8000-000000000001",
                "leftValue": "={{ $json.consentimiento_vigente }}",
                "operator": {"type": "boolean", "operation": "true", "singleValue": true},
                "rightValue": ""
              },
              {
                "id": "c0000000-0000-4000-8000-000000000002",
                "leftValue": "={{ $json.dentro_de_horario }}",
                "operator": {"type": "boolean", "operation": "true", "singleValue": true},
                "rightValue": ""
              }
            ],
            "combinator": "and"
          },
          "options": {}
        },
        "id": "5a510001-0000-4000-8000-000000000003",
        "name": "¿Consentimiento y horario?",
        "type": "n8n-nodes-base.if",
        "typeVersion": 2.2,
        "position": [440, 0]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "=https://graph.facebook.com/v26.0/{{ $vars.sn_phone_number_id }}/messages",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpHeaderAuth",
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={{ JSON.stringify({messaging_product: 'whatsapp', to: $json.telefono, type: 'template', template: {name: 'recordatorio_cita', language: {code: 'es_MX'}, components: [{type: 'body', parameters: [{type: 'text', text: $json.nombre_pila}, {type: 'text', text: $json.fecha_texto}, {type: 'text', text: $json.hora_texto}]}, {type: 'button', sub_type: 'quick_reply', index: '0', parameters: [{type: 'payload', payload: 'CONFIRMAR:' + $json.id_cita}]}, {type: 'button', sub_type: 'quick_reply', index: '1', parameters: [{type: 'payload', payload: 'REPROGRAMAR:' + $json.id_cita}]}]}}) }}",
          "options": {"timeout": 30000}
        },
        "id": "5a510001-0000-4000-8000-000000000004",
        "name": "Enviar recordatorio_cita",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [660, -100],
        "retryOnFail": true,
        "maxTries": 3,
        "waitBetweenTries": 5000,
        "credentials": {"httpHeaderAuth": {"id": "0000000000000051", "name": "Cloud API Sonrisa Norte (token de sistema)"}}
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "INSERT INTO envios (id_cita, wamid, intento, enviado_en) VALUES ('{{ $('Citas del siguiente día hábil').item.json.id_cita }}', '{{ $json.messages[0].id }}', (SELECT count(*) + 1 FROM envios WHERE id_cita = '{{ $('Citas del siguiente día hábil').item.json.id_cita }}'), now());",
          "options": {}
        },
        "id": "5a510001-0000-4000-8000-000000000005",
        "name": "Registrar envío",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [880, -100],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "INSERT INTO descartes (id_cita, motivo, registrado_en) VALUES ('{{ $json.id_cita }}', CASE WHEN {{ $json.consentimiento_vigente }} THEN 'fuera de horario' ELSE 'sin consentimiento vigente' END, now());",
          "options": {}
        },
        "id": "5a510001-0000-4000-8000-000000000006",
        "name": "Registrar descarte",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [660, 100],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "content": "## Cierres y reprogramaciones\nLas citas del 2 y 3 de abril (Semana Santa) las reprograma Irma por teléfono antes del cierre. Este workflow no reprograma nada.",
          "height": 160,
          "width": 300
        },
        "id": "5a510001-0000-4000-8000-000000000007",
        "name": "Irma reprograma los cierres",
        "type": "n8n-nodes-base.stickyNote",
        "typeVersion": 1,
        "position": [880, 100]
      }
    ],
    "connections": {
      "Lunes a viernes 10:00 y 17:00": {"main": [[{"node": "Citas del siguiente día hábil", "type": "main", "index": 0}]]},
      "Citas del siguiente día hábil": {"main": [[{"node": "¿Consentimiento y horario?", "type": "main", "index": 0}]]},
      "¿Consentimiento y horario?": {
        "main": [
          [{"node": "Enviar recordatorio_cita", "type": "main", "index": 0}],
          [{"node": "Registrar descarte", "type": "main", "index": 0}]
        ]
      },
      "Enviar recordatorio_cita": {"main": [[{"node": "Registrar envío", "type": "main", "index": 0}]]}
    },
    "settings": {
      "executionOrder": "v1",
      "timezone": "America/Mexico_City",
      "saveDataSuccessExecution": "none",
      "saveManualExecutions": false
    },
    "pinData": {},
    "meta": {"templateCredsSetupCompleted": true}
  },
  {
    "name": "SN Respuestas de citas v1",
    "nodes": [
      {
        "parameters": {
          "httpMethod": "POST",
          "path": "sn-whatsapp",
          "responseMode": "onReceived",
          "options": {"rawBody": true}
        },
        "id": "5a510002-0000-4000-8000-000000000001",
        "name": "Webhook de Meta",
        "type": "n8n-nodes-base.webhook",
        "typeVersion": 2,
        "position": [0, 0],
        "webhookId": "5a510002-0000-4000-8000-5a51abcdef01"
      },
      {
        "parameters": {
          "jsCode": "const crypto = require('crypto');\nconst firma = $input.first().json.headers['x-hub-signature-256'] ?? '';\nconst cuerpo = Buffer.from($input.first().binary.data.data, 'base64');\nconst esperada = 'sha256=' + crypto.createHmac('sha256', $env.SN_APP_SECRET).update(cuerpo).digest('hex');\nconst valida = firma.length === esperada.length && crypto.timingSafeEqual(Buffer.from(firma), Buffer.from(esperada));\nif (!valida) { throw new Error('Firma X-Hub-Signature-256 inválida: se descarta el evento'); }\nconst v = JSON.parse(cuerpo.toString('utf8')).entry[0].changes[0].value;\nif (v.statuses) { return v.statuses.map(s => ({json: {tipo: 'estado', wamid: s.id, estado: s.status}})); }\nreturn (v.messages ?? []).map(m => ({json: {telefono: m.from, wamid: m.id,\n  tipo: m.type === 'button' ? m.button.payload.split(':')[0].toLowerCase() : (/^\\s*(baja|ya no)\\b/i.test(m.text?.body ?? '') ? 'baja' : 'texto_libre'),\n  id_cita: m.type === 'button' ? m.button.payload.split(':')[1] : null, texto: m.text?.body ?? null}}));"
        },
        "id": "5a510002-0000-4000-8000-000000000002",
        "name": "Verificar firma y normalizar",
        "type": "n8n-nodes-base.code",
        "typeVersion": 2,
        "position": [220, 0]
      },
      {
        "parameters": {
          "rules": {
            "values": [
              {
                "conditions": {
                  "options": {"caseSensitive": false, "leftValue": "", "typeValidation": "loose", "version": 2},
                  "conditions": [
                    {
                      "id": "c0000000-0000-4000-8000-000000000001",
                      "leftValue": "={{ $json.tipo }}",
                      "operator": {"type": "string", "operation": "equals"},
                      "rightValue": "confirmar"
                    }
                  ],
                  "combinator": "and"
                },
                "renameOutput": true,
                "outputKey": "confirmar"
              },
              {
                "conditions": {
                  "options": {"caseSensitive": false, "leftValue": "", "typeValidation": "loose", "version": 2},
                  "conditions": [
                    {
                      "id": "c0000000-0000-4000-8000-000000000002",
                      "leftValue": "={{ $json.tipo }}",
                      "operator": {"type": "string", "operation": "equals"},
                      "rightValue": "reprogramar"
                    }
                  ],
                  "combinator": "and"
                },
                "renameOutput": true,
                "outputKey": "reprogramar"
              },
              {
                "conditions": {
                  "options": {"caseSensitive": false, "leftValue": "", "typeValidation": "loose", "version": 2},
                  "conditions": [
                    {
                      "id": "c0000000-0000-4000-8000-000000000003",
                      "leftValue": "={{ $json.tipo }}",
                      "operator": {"type": "string", "operation": "equals"},
                      "rightValue": "baja"
                    }
                  ],
                  "combinator": "and"
                },
                "renameOutput": true,
                "outputKey": "baja"
              },
              {
                "conditions": {
                  "options": {"caseSensitive": false, "leftValue": "", "typeValidation": "loose", "version": 2},
                  "conditions": [
                    {
                      "id": "c0000000-0000-4000-8000-000000000004",
                      "leftValue": "={{ $json.tipo }}",
                      "operator": {"type": "string", "operation": "equals"},
                      "rightValue": "texto_libre"
                    }
                  ],
                  "combinator": "and"
                },
                "renameOutput": true,
                "outputKey": "texto_libre"
              },
              {
                "conditions": {
                  "options": {"caseSensitive": false, "leftValue": "", "typeValidation": "loose", "version": 2},
                  "conditions": [
                    {
                      "id": "c0000000-0000-4000-8000-000000000005",
                      "leftValue": "={{ $json.tipo }}",
                      "operator": {"type": "string", "operation": "equals"},
                      "rightValue": "estado"
                    }
                  ],
                  "combinator": "and"
                },
                "renameOutput": true,
                "outputKey": "estado"
              }
            ]
          },
          "options": {}
        },
        "id": "5a510002-0000-4000-8000-000000000003",
        "name": "¿Qué respondió?",
        "type": "n8n-nodes-base.switch",
        "typeVersion": 3.2,
        "position": [440, 0]
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "UPDATE citas SET estado = 'confirmada' WHERE id_cita = '{{ $json.id_cita }}' RETURNING id_cita, (SELECT telefono FROM pacientes p WHERE p.id_paciente = citas.id_paciente) AS telefono;",
          "options": {}
        },
        "id": "5a510002-0000-4000-8000-000000000004",
        "name": "Marcar confirmada",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [660, -300],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "method": "POST",
          "url": "=https://graph.facebook.com/v26.0/{{ $vars.sn_phone_number_id }}/messages",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpHeaderAuth",
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={{ JSON.stringify({messaging_product: 'whatsapp', to: $json.telefono, type: 'text', text: {body: 'Gracias, su cita quedó confirmada. Lo esperamos.'}}) }}",
          "options": {"timeout": 30000}
        },
        "id": "5a510002-0000-4000-8000-000000000005",
        "name": "Acuse de confirmación",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [880, -300],
        "retryOnFail": true,
        "maxTries": 3,
        "waitBetweenTries": 5000,
        "credentials": {"httpHeaderAuth": {"id": "0000000000000051", "name": "Cloud API Sonrisa Norte (token de sistema)"}}
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "INSERT INTO bandeja_recepcion (id_cita, telefono, motivo, recibido_en) VALUES ('{{ $json.id_cita }}', '{{ $json.telefono }}', 'reprogramar', now()) RETURNING telefono;",
          "options": {}
        },
        "id": "5a510002-0000-4000-8000-000000000006",
        "name": "Pendiente para Irma",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [660, -150],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "method": "POST",
          "url": "=https://graph.facebook.com/v26.0/{{ $vars.sn_phone_number_id }}/messages",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpHeaderAuth",
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={{ JSON.stringify({messaging_product: 'whatsapp', to: $json.telefono, type: 'text', text: {body: 'Gracias. Irma le escribirá hoy con horarios disponibles.'}}) }}",
          "options": {"timeout": 30000}
        },
        "id": "5a510002-0000-4000-8000-000000000007",
        "name": "Acuse de reprogramación",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [880, -150],
        "retryOnFail": true,
        "maxTries": 3,
        "waitBetweenTries": 5000,
        "credentials": {"httpHeaderAuth": {"id": "0000000000000051", "name": "Cloud API Sonrisa Norte (token de sistema)"}}
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "UPDATE consentimientos SET baja = now() WHERE finalidad = 'recordatorios_cita' AND id_paciente = (SELECT id_paciente FROM pacientes WHERE telefono = '{{ $json.telefono }}') RETURNING '{{ $json.telefono }}' AS telefono;",
          "options": {}
        },
        "id": "5a510002-0000-4000-8000-000000000008",
        "name": "Retirar consentimiento",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [660, 0],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "method": "POST",
          "url": "=https://graph.facebook.com/v26.0/{{ $vars.sn_phone_number_id }}/messages",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpHeaderAuth",
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={{ JSON.stringify({messaging_product: 'whatsapp', to: $json.telefono, type: 'text', text: {body: 'Listo. Ya no recibirá recordatorios por WhatsApp.'}}) }}",
          "options": {"timeout": 30000}
        },
        "id": "5a510002-0000-4000-8000-000000000009",
        "name": "Acuse de baja",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [880, 0],
        "retryOnFail": true,
        "maxTries": 3,
        "waitBetweenTries": 5000,
        "credentials": {"httpHeaderAuth": {"id": "0000000000000051", "name": "Cloud API Sonrisa Norte (token de sistema)"}}
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "INSERT INTO bandeja_recepcion (telefono, motivo, texto, recibido_en) VALUES ('{{ $json.telefono }}', 'texto_libre', $1, now()) RETURNING telefono;",
          "options": {"queryReplacement": "={{ $json.texto }}"}
        },
        "id": "5a510002-0000-4000-8000-000000000010",
        "name": "Texto libre a la bandeja",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [660, 150],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "method": "POST",
          "url": "=https://graph.facebook.com/v26.0/{{ $vars.sn_phone_number_id }}/messages",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpHeaderAuth",
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={{ JSON.stringify({messaging_product: 'whatsapp', to: $vars.sn_telefono_recepcion, type: 'template', template: {name: 'aviso_recepcion', language: {code: 'es_MX'}, components: [{type: 'body', parameters: [{type: 'text', text: 'pendiente en la bandeja'}]}]}}) }}",
          "options": {"timeout": 30000}
        },
        "id": "5a510002-0000-4000-8000-000000000011",
        "name": "Aviso a Irma (sin contenido)",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [880, 150],
        "retryOnFail": true,
        "maxTries": 3,
        "waitBetweenTries": 5000,
        "credentials": {"httpHeaderAuth": {"id": "0000000000000051", "name": "Cloud API Sonrisa Norte (token de sistema)"}}
      },
      {
        "parameters": {
          "operation": "executeQuery",
          "query": "UPDATE envios SET estado = '{{ $json.estado }}' WHERE wamid = '{{ $json.wamid }}';",
          "options": {}
        },
        "id": "5a510002-0000-4000-8000-000000000012",
        "name": "Actualizar estado",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.5,
        "position": [660, 300],
        "credentials": {"postgres": {"id": "0000000000000052", "name": "Agenda Sonrisa Norte (rol n8n_recordatorios)"}}
      },
      {
        "parameters": {
          "content": "## Irma al mando\nIrma lee la bandeja, escribe a cada paciente con huecos reales y decide cualquier cambio de cita. Ningún mensaje de paciente pasa por un modelo de IA.",
          "height": 180,
          "width": 300
        },
        "id": "5a510002-0000-4000-8000-000000000013",
        "name": "Irma responde y reprograma",
        "type": "n8n-nodes-base.stickyNote",
        "typeVersion": 1,
        "position": [1100, -80]
      }
    ],
    "connections": {
      "Webhook de Meta": {"main": [[{"node": "Verificar firma y normalizar", "type": "main", "index": 0}]]},
      "Verificar firma y normalizar": {"main": [[{"node": "¿Qué respondió?", "type": "main", "index": 0}]]},
      "¿Qué respondió?": {
        "main": [
          [{"node": "Marcar confirmada", "type": "main", "index": 0}],
          [{"node": "Pendiente para Irma", "type": "main", "index": 0}],
          [{"node": "Retirar consentimiento", "type": "main", "index": 0}],
          [{"node": "Texto libre a la bandeja", "type": "main", "index": 0}],
          [{"node": "Actualizar estado", "type": "main", "index": 0}]
        ]
      },
      "Marcar confirmada": {"main": [[{"node": "Acuse de confirmación", "type": "main", "index": 0}]]},
      "Pendiente para Irma": {
        "main": [
          [
            {"node": "Acuse de reprogramación", "type": "main", "index": 0},
            {"node": "Aviso a Irma (sin contenido)", "type": "main", "index": 0}
          ]
        ]
      },
      "Retirar consentimiento": {"main": [[{"node": "Acuse de baja", "type": "main", "index": 0}]]},
      "Texto libre a la bandeja": {"main": [[{"node": "Aviso a Irma (sin contenido)", "type": "main", "index": 0}]]}
    },
    "settings": {
      "executionOrder": "v1",
      "timezone": "America/Mexico_City",
      "saveDataSuccessExecution": "none",
      "saveManualExecutions": false
    },
    "pinData": {},
    "meta": {"templateCredsSetupCompleted": true}
  }
]

# Lectura, revisión y dibujo de los workflows SN Recordatorios de citas v1 y SN Respuestas de citas v1 en Python:
import textwrap
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch, Polygon, RegularPolygon

flujos = json.loads((clinica / 'flujos' / 'n8n' / 'recordatorios_citas_v1.json').read_text(encoding = 'utf-8'))

def nodos_desde_n8n(wf):
    nodos = [{'id': n['name'], 'tipo': n['type'].split('.')[-1],
              'x': n['position'][0] / 100, 'y': -n['position'][1] / 100} for n in wf['nodes']]
    aristas = [(o, d['node']) for o, s in wf['connections'].items()
               for lista in s.values() for destinos in lista for d in destinos]
    return nodos, aristas

def revisar_clinica(wf):
    hallazgos, nombres = [], {n['name'] for n in wf['nodes']}
    for n in wf['nodes']:
        texto = json.dumps(n['parameters'], ensure_ascii = False)
        if 'anthropic' in texto or 'langchain' in n['type']:
            hallazgos.append(f"{n['name']}: un mensaje de paciente llegaría a un modelo de IA")
        if re.search(r'Bearer\s+[A-Za-z0-9]|EAA[A-Za-z0-9]{20}', texto):
            hallazgos.append(f"{n['name']}: token pegado en los parámetros")
        if 'graph.facebook.com' in texto and 'httpHeaderAuth' not in n.get('credentials', {}):
            hallazgos.append(f"{n['name']}: llama a Meta sin la credencial guardada")
        if 'Aviso a Irma' in n['name'] and '$json.texto' in texto:
            hallazgos.append(f"{n['name']}: el aviso copia el texto del paciente")
        if re.search(r'tratamiento|motivo_consulta|diagnostico', texto):
            hallazgos.append(f"{n['name']}: usa un campo de salud")
    if any(n['type'].endswith('webhook') for n in wf['nodes']):
        primero = wf['connections'][next(n['name'] for n in wf['nodes'] if n['type'].endswith('webhook'))]
        destino = primero['main'][0][0]['node']
        if 'X-Hub-Signature-256' not in json.dumps(next(n for n in wf['nodes'] if n['name'] == destino)['parameters']):
            hallazgos.append('el primer paso tras el webhook no verifica la firma')
    if any('graph.facebook.com' in json.dumps(n['parameters']) and 'template' in json.dumps(n['parameters'])
           and 'recordatorio_cita' in json.dumps(n['parameters']) for n in wf['nodes']):
        if not any(n['type'].endswith('.if') and 'consentimiento' in json.dumps(n['parameters']) for n in wf['nodes']):
            hallazgos.append('envía la plantilla sin comprobar el consentimiento')
    for o, d in nodos_desde_n8n(wf)[1]:
        if o not in nombres or d not in nombres:
            hallazgos.append(f'conexión rota: {o} -> {d}')
    return hallazgos

for wf in flujos:
    nodos, aristas = nodos_desde_n8n(wf)
    tipos = {k: int(x) for k, x in pd.Series([n['tipo'] for n in nodos]).value_counts().items()}
    print(f"{wf['name']}: {len(nodos)} nodos | {len(aristas)} conexiones | tipos: {tipos}")
    print('  Hallazgos:', revisar_clinica(wf) or 'ninguno')
alterado = json.loads(json.dumps(flujos[1]))
alterado['nodes'][1]['parameters']['jsCode'] = 'return $input.all();'
alterado['nodes'].append({'parameters': {'model': 'claude-haiku-5-5'}, 'name': 'Resumir texto libre',
                          'type': '@n8n/n8n-nodes-langchain.lmChatAnthropic', 'position': [880, 300]})
print('Hallazgos en una copia sin verificación de firma y con un modelo:', revisar_clinica(alterado))

COLORES = {'disparador': '#1f9d55', 'accion': '#2a78d6', 'decision': '#eb6834', 'humano': '#8a8986'}
def forma_de(n):
    if n['tipo'] in ('scheduleTrigger', 'webhook'):
        return 'disparador'
    if n['tipo'] in ('if', 'switch'):
        return 'decision'
    return 'humano' if n['tipo'] == 'stickyNote' else 'accion'

fig, ejes = plt.subplots(2, 1, figsize = (13, 9.4), gridspec_kw = {'height_ratios': [1, 2.1]})
for ax, wf in zip(ejes, flujos):
    nodos, aristas = nodos_desde_n8n(wf)
    pos = {n['id']: (n['x'] * 1.05, n['y'] * 1.1) for n in nodos}
    for n in nodos:
        forma, (x, y) = forma_de(n), pos[n['id']]
        color = COLORES[forma]
        if forma == 'decision':
            ax.add_patch(Polygon([(x - 0.95, y), (x, y + 0.72), (x + 0.95, y), (x, y - 0.72)], facecolor = color, edgecolor = 'white'))
        elif forma == 'humano':
            ax.add_patch(RegularPolygon((x, y), 6, radius = 0.95, orientation = math.pi / 6, facecolor = color, edgecolor = 'white'))
        else:
            estilo = 'round,pad=0.05,rounding_size=0.35' if forma == 'disparador' else 'round,pad=0.05'
            ax.add_patch(FancyBboxPatch((x - 0.95, y - 0.4), 1.9, 0.8, boxstyle = estilo, facecolor = color,
                                        edgecolor = 'white', linewidth = 2))
        nombre = textwrap.fill(n['id'], 15, break_long_words = False, break_on_hyphens = False)
        ax.text(x, y + 0.08, nombre, ha = 'center', va = 'center', color = 'white', fontsize = 7)
        ax.text(x, y - 0.3, n['tipo'], ha = 'center', va = 'center', color = 'white', fontsize = 6.5)
    for o, d in aristas:
        (x1, y1), (x2, y2) = pos[o], pos[d]
        # Las flechas salen del borde derecho de una forma y llegan al borde izquierdo de la siguiente:
        ax.add_patch(FancyArrowPatch((x1 + 0.95, y1), (x2 - 0.95, y2), arrowstyle = '-|>', mutation_scale = 11,
                                     shrinkA = 1, shrinkB = 1, color = '#52514e', linewidth = 1.1))
    if 'Irma responde y reprograma' in pos:
        for origen in ('Aviso a Irma (sin contenido)', 'Acuse de reprogramación'):
            (x1, y1), (x2, y2) = pos[origen], pos['Irma responde y reprograma']
            ax.add_patch(FancyArrowPatch((x1 + 0.95, y1), (x2 - 0.9, y2), arrowstyle = '-|>', mutation_scale = 11,
                                         shrinkA = 1, shrinkB = 1, color = '#8a8986', linewidth = 1.4, linestyle = '--'))
    ax.set_xlim(-1.1, max(p[0] for p in pos.values()) + 1.1)
    ax.set_ylim(min(p[1] for p in pos.values()) - 1.0, max(p[1] for p in pos.values()) + 1.0)
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_title(wf['name'], fontsize = 13)
plt.suptitle('Sonrisa Norte: el flujo envía y clasifica; las decisiones son de Irma', fontsize = 14)
plt.tight_layout()
plt.show()

# Envío de la plantilla recordatorio_cita al número de prueba de Meta con la Cloud API en Python (bloque API, no se ejecuta aquí):
import os
import requests

VERSION = 'v26.0'                                   # versión de la Graph API vigente en octubre de 2026
ID_NUMERO = os.environ['SN_PHONE_NUMBER_ID']        # identificador del número de prueba de Meta
# Token de sistema con el permiso whatsapp_business_messaging; vive en el entorno, nunca en el código:
cabeceras = {'Authorization': f"Bearer {os.environ['SN_WHATSAPP_TOKEN']}", 'Content-Type': 'application/json'}

def enviar_recordatorio(telefono, nombre_pila, fecha_texto, hora_texto, id_cita):
    # Los botones llevan la cita en su carga útil: así la respuesta llega con su identificador:
    cuerpo = {'messaging_product': 'whatsapp', 'to': telefono, 'type': 'template',
              'template': {'name': 'recordatorio_cita', 'language': {'code': 'es_MX'}, 'components': [
                  {'type': 'body', 'parameters': [{'type': 'text', 'text': nombre_pila},
                                                  {'type': 'text', 'text': fecha_texto},
                                                  {'type': 'text', 'text': hora_texto}]},
                  {'type': 'button', 'sub_type': 'quick_reply', 'index': '0',
                   'parameters': [{'type': 'payload', 'payload': f'CONFIRMAR:{id_cita}'}]},
                  {'type': 'button', 'sub_type': 'quick_reply', 'index': '1',
                   'parameters': [{'type': 'payload', 'payload': f'REPROGRAMAR:{id_cita}'}]}]}}
    r = requests.post(f'https://graph.facebook.com/{VERSION}/{ID_NUMERO}/messages',
                      headers = cabeceras, json = cuerpo, timeout = 30)
    if r.status_code != 200:
        # Error de Meta: se registra el código, nunca el teléfono ni el nombre del paciente:
        return {'ok': False, 'codigo': r.status_code, 'error': r.json().get('error', {}).get('code')}
    return {'ok': True, 'wamid': r.json()['messages'][0]['id']}

# Solo al número de prueba de la cuenta de desarrollo, con datos inventados:
print(enviar_recordatorio('+52 55 0000 0001', 'Ana', 'martes 24 de marzo', '10:30', 'C0001'))

# Salida de ejemplo (puede variar):
# {'ok': True, 'wamid': 'wamid.EJEMPLO-NO-REAL-HBgNNTIxNTUwMDAwMDAwMRUCABEYEjk0'}
# Si la plantilla todavía no está aprobada, Meta responde 400 y la función devuelve:
# {'ok': False, 'codigo': 400, 'error': 132001}