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

# Importaciones base, semilla de la serie, carpeta del día y supuestos fijos en Python:
import warnings
warnings.filterwarnings('ignore')
import json
import re
import sqlite3
import textwrap
from collections import Counter
from datetime import datetime, timedelta
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import FancyBboxPatch, FancyArrowPatch, Polygon, RegularPolygon, Ellipse
from scipy import stats

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 120)
pd.set_option('display.max_colwidth', 48)
proyecto = Path('trigo_lento')
carpeta = proyecto / 'dia_55'
carpeta.mkdir(parents = True, exist_ok = True)

# Supuestos de la serie (A.4.6 y A.5) y del módulo 5:
PRESUPUESTO = 45.00          # USD al mes para todo el ecosistema
MXN_POR_USD = 18.50          # tipo de cambio didáctico fijo
EVENTOS_MES = {'WhatsApp': 1560, 'Instagram': 400, 'Gmail': 300, 'Formulario': 70}   # Día 52
print('numpy', np.__version__, '| pandas', pd.__version__, '| carpeta:', carpeta.as_posix())
print(f'Eventos de comunicación al mes: {sum(EVENTOS_MES.values()):,}'.replace(',', ' '),
      '| presupuesto:', f'{PRESUPUESTO:.2f} USD ({PRESUPUESTO * MXN_POR_USD:.2f} MXN)')

# Inventario de los flujos del módulo 5 con canal, base de envío, dueño y persona al mando en Python:
inventario = pd.DataFrame([
    ('TL Orquestador v1', 52, 'Todos', 'Entrada', 'No escribe: enruta', 'Valeria', 'Escala a #aprobaciones'),
    ('TL Responder por canal v1', 52, 'WhatsApp, Instagram', 'Salida', 'Ventana abierta', 'Valeria',
     'Acuse y respuestas fijas'),
    ('TL Agente de pedidos v2', 38, 'WhatsApp', 'Conversación', 'Ventana abierta', 'Valeria',
     'Aprueba pasteles y cambios'),
    ('TL Gmail mayoristas v1', 47, 'Gmail', 'Borrador', 'Relación mayorista', 'Valeria', 'Valeria envía'),
    ('TL WhatsApp secuencias v2', 54, 'WhatsApp', 'Salida', 'Opt-in o pedido en curso', 'Valeria',
     'Plantillas que aprobó Valeria'),
    ('TL Slack operaciones v1', 50, 'Slack', 'Interno', 'Equipo', 'Valeria', 'Valeria o Don Ernesto'),
    ('TL Métricas de atención v1', 53, 'Slack', 'Interno', 'Equipo', 'Valeria', 'Lee #alertas'),
    ('TL Monitor de plantillas v1', 54, 'Slack', 'Interno', 'Equipo', 'Valeria', 'Lee #alertas'),
], columns = ['flujo', 'dia', 'canal', 'direccion', 'base_de_envio', 'dueno', 'persona_al_mando'])
inventario.to_csv(carpeta / 'inventario_modulo_5.csv', index = False, encoding = 'utf-8')
print(inventario.drop(columns = 'dueno').to_string(index = False))
print('Flujos:', len(inventario), '| escriben a clientes:',
      int(inventario.direccion.isin(['Salida', 'Conversación']).sum()),
      '| sin base de envío declarada:', int(inventario.base_de_envio.eq('').sum()),
      '| dueños distintos:', inventario.dueno.nunique())

# Mapa del ecosistema de comunicación dibujado con las formas de la serie en Python:
FORMAS = {'canal': ('disparador', '#1f9d55'), 'flujo': ('accion', '#2a78d6'), 'decision': ('decision', '#eb6834'),
          'ia': ('ia', '#7a5cc9'), 'persona': ('humano', '#8a8a8a'), 'error': ('error', '#c8423b')}

def dibujar_flujo(nodos, aristas, titulo, ancho = 1.9, alto = 0.8, tamano = (15, 8.4)):
    fig, ax = plt.subplots(figsize = tamano)
    pos = {n['id']: (n['x'], n['y']) for n in nodos}
    medio = {n['id']: {'decision': (1.15, 0.62), 'humano': (0.6, 0.6)}.get(FORMAS[n['tipo']][0],
                                                                            (ancho / 2, alto / 2)) for n in nodos}
    for o, d, rotulo in aristas:
        (x1, y1), (x2, y2) = pos[o], pos[d]
        if x1 == x2:      # vertical: de borde inferior o superior al opuesto
            s = 1 if y2 > y1 else -1
            a, b = (x1, y1 + s * medio[o][1]), (x2, y2 - s * medio[d][1])
        else:             # de izquierda a derecha: del borde derecho al borde izquierdo
            a, b = (x1 + medio[o][0], y1), (x2 - medio[d][0], y2)
        ax.add_patch(FancyArrowPatch(a, b, arrowstyle = '-|>', mutation_scale = 14, color = '#7d7b76',
                                     linewidth = 1.3, shrinkA = 2, shrinkB = 3, zorder = 1))
        if rotulo:
            ax.text((x1 + x2) / 2, (y1 + y2) / 2 + 0.12, rotulo, fontsize = 9, color = '#52514e', ha = 'center')
    for n in nodos:
        forma, color = FORMAS[n['tipo']]
        x, y = n['x'], n['y']
        if forma == 'decision':
            ax.add_patch(Polygon([(x - 1.15, y), (x, y + 0.62), (x + 1.15, y), (x, y - 0.62)],
                                 facecolor = color, edgecolor = 'white', linewidth = 2, zorder = 2))
        elif forma == 'disparador':
            ax.add_patch(Ellipse((x, y), ancho, alto, facecolor = color, edgecolor = 'white', linewidth = 2, zorder = 2))
        elif forma == 'humano':
            ax.add_patch(RegularPolygon((x, y), 6, radius = 0.62, orientation = np.pi / 6, facecolor = color,
                                        edgecolor = 'white', linewidth = 2, zorder = 2))
        else:
            ax.add_patch(FancyBboxPatch((x - ancho / 2, y - alto / 2), ancho, alto, boxstyle = 'round,pad=0.04',
                                        facecolor = color, edgecolor = 'white', linewidth = 2, zorder = 2))
        ax.text(x, y, textwrap.fill(n['id'], 15), ha = 'center', va = 'center', color = 'white',
                fontsize = 9, zorder = 3)
    xs = [p[0] for p in pos.values()]
    ys = [p[1] for p in pos.values()]
    ax.set_xlim(min(xs) - 1.3, max(xs) + 1.3)
    ax.set_ylim(min(ys) - 0.9, max(ys) + 0.9)
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_title(titulo, fontsize = 15)
    return fig, ax

nodos = ([{'id': c, 'tipo': 'canal', 'x': 0, 'y': y} for c, y in
          [('WhatsApp', 4), ('Instagram', 2.6), ('Gmail', 1.2), ('Formulario', -0.2), ('Teléfono', -1.6)]] +
         [{'id': 'TL Orquestador v1', 'tipo': 'decision', 'x': 3.3, 'y': 1.2},
          {'id': 'TL Responder por canal v1', 'tipo': 'flujo', 'x': 6.6, 'y': 4.3},
          {'id': 'TL Agente de pedidos v2', 'tipo': 'ia', 'x': 6.6, 'y': 2.9},
          {'id': 'TL Gmail mayoristas v1', 'tipo': 'ia', 'x': 6.6, 'y': 1.5},
          {'id': 'TL WhatsApp secuencias v2', 'tipo': 'flujo', 'x': 6.6, 'y': 0.1},
          {'id': 'TL Monitor de plantillas v1', 'tipo': 'error', 'x': 6.6, 'y': -1.3},
          {'id': 'TL Slack operaciones v1', 'tipo': 'flujo', 'x': 9.9, 'y': 1.5},
          {'id': 'TL Métricas de atención v1', 'tipo': 'flujo', 'x': 9.9, 'y': -0.3},
          {'id': 'Valeria', 'tipo': 'persona', 'x': 12.9, 'y': 4.0},
          {'id': 'Don Ernesto', 'tipo': 'persona', 'x': 12.9, 'y': 1.5},
          {'id': 'Mostrador', 'tipo': 'persona', 'x': 12.9, 'y': -1.0}])
aristas = ([(c, 'TL Orquestador v1', '') for c in ['WhatsApp', 'Instagram', 'Gmail', 'Formulario', 'Teléfono']] +
           [('TL Orquestador v1', f, '') for f in ['TL Responder por canal v1', 'TL Agente de pedidos v2',
                                                   'TL Gmail mayoristas v1']] +
           [('TL Agente de pedidos v2', 'TL Slack operaciones v1', 'aprobación'),
            ('TL Gmail mayoristas v1', 'Valeria', 'borrador'),
            ('TL WhatsApp secuencias v2', 'TL Monitor de plantillas v1', ''),
            ('TL Monitor de plantillas v1', 'TL Métricas de atención v1', ''),
            ('TL Métricas de atención v1', 'TL Slack operaciones v1', '#alertas'),
            ('TL Slack operaciones v1', 'Valeria', ''), ('TL Slack operaciones v1', 'Don Ernesto', 'relevo'),
            ('TL Slack operaciones v1', 'Mostrador', '')])
nombres = {n['id'] for n in nodos}
assert all(o in nombres and d in nombres for o, d, _ in aristas), 'Arista hacia un nodo inexistente'
print('Nodos:', len(nodos), '| aristas:', len(aristas), '|', dict(Counter(n['tipo'] for n in nodos)))
grado = Counter([o for o, _, _ in aristas] + [d for _, d, _ in aristas])
print('Nodo con más conexiones:', grado.most_common(1)[0])
dibujar_flujo(nodos, aristas, 'Ecosistema de comunicación de Trigo Lento al cierre del módulo 5')
plt.tight_layout()
plt.show()

# Banco de 12 preguntas de decisión con retroalimentación por opción en Python:
def pregunta(n, tema, dia, enunciado, correcta, opciones):
    # opciones: cuatro pares (texto, retroalimentación) en el orden A, B, C, D:
    return {'n': n, 'tema': tema, 'dia': dia, 'enunciado': enunciado, 'correcta': correcta,
            'opciones': {l: t for l, (t, _) in zip('ABCD', opciones)},
            'retro': {l: r for l, (_, r) in zip('ABCD', opciones)}}

BANCO = [
    pregunta(1, 'Ventana y plantillas', 48, 'Escribió hace 26 h y pregunta por su pastel: ¿qué se le envía?', 'C', [
        ('Un texto libre con la respuesta', 'A las 24 horas la ventana se cerró: ya no cabe texto libre.'),
        ('Una plantilla de marketing con el pastel', 'Sin opt-in de marketing, y además no es promoción.'),
        ('Una plantilla de utilidad aprobada sobre su pedido', 'Correcto: el pedido en curso es la base.'),
        ('Nada hasta que vuelva a escribir', 'Sí hay base: su pedido en curso admite una plantilla de utilidad.')]),
    pregunta(2, 'Ventana y plantillas', 48, 'Utilidad con "llévese 10 % en conchas": ¿qué pasa?', 'B', [
        ('Nada: la categoría la elige el negocio', 'La categoría la decide el contenido, no quien la registra.'),
        ('Meta la trata como marketing', 'Correcto: más cara y exige consentimiento de marketing.'),
        ('Se cobra igual que antes', 'Pasa de 0.0085 a 0.0397 USD por mensaje.'),
        ('Solo cambia el pie del mensaje', 'Cambian categoría, tarifa y consentimiento exigido.')]),
    pregunta(3, 'Ventana y plantillas', 54, 'La Cloud API responde 400: plantilla pausada. ¿Qué hace el flujo?', 'D', [
        ('Reintenta cada 5 segundos', 'Un 400 no es un error de red: reintentar no cambia nada.'),
        ('Lo marca como enviado', 'Es justo lo que ocultó el incidente del Día 54.'),
        ('Cambia la plantilla por texto libre', 'Fuera de la ventana el texto libre no está permitido.'),
        ('Registra, avisa en #alertas y usa el respaldo', 'Correcto: se ve el fallo y el recordatorio sale.')]),
    pregunta(4, 'Consentimiento y orquestación', 48, 'Opt-in solo de confirmaciones: ¿bienvenida de novedades?', 'A', [
        ('No: falta el consentimiento de marketing', 'Correcto: el consentimiento es por finalidad.'),
        ('Sí, si se envía en horario', 'El horario no sustituye al consentimiento.'),
        ('Sí, una sola vez', 'Ni una vez: la finalidad no coincide.'),
        ('Sí, como plantilla de utilidad', 'Una bienvenida comercial no es utilidad.')]),
    pregunta(5, 'Consentimiento y orquestación', 48, 'Responde "ya no" a un recordatorio: ¿qué ocurre?', 'C', [
        ('Se le pregunta el motivo primero', 'La baja no se condiciona a nada.'),
        ('Baja solo de recordatorios', 'La baja se aplica a todas las finalidades.'),
        ('Baja inmediata en todas las finalidades', 'Correcto: en el mismo minuto, sin borrar el registro.'),
        ('Valeria decide al final del día', 'No hay nada que decidir.')]),
    pregunta(6, 'Consentimiento y orquestación', 52, 'Mismo pastel por WhatsApp e Instagram en 10 min: ¿qué hace?', 'B', [
        ('Responde en los dos canales', 'Es la respuesta doble que el orquestador evita.'),
        ('Fusiona por huella y responde una vez', 'Correcto: ventana de 30 min con huella del pedido.'),
        ('Borra el segundo mensaje', 'No se borra nada: se fusiona y queda registrado.'),
        ('Pregunta a la clienta por cuál siguen', 'Solo se pregunta si la coincidencia es dudosa.')]),
    pregunta(7, 'Control humano', 47, 'Correo de Marisol con queja y cambio de pedido: ¿qué deja el flujo?', 'A', [
        ('Un borrador con hueco para la queja', 'Correcto: la queja la escribe y firma Valeria.'),
        ('La respuesta enviada sola', 'TL Gmail mayoristas v1 no tiene ningún nodo de envío.'),
        ('Nada: las quejas se ignoran', 'Se etiqueta y se deja lista para Valeria.'),
        ('Una disculpa redactada por Claude', 'Las quejas no las redacta el modelo.')]),
    pregunta(8, 'Control humano', 50, 'Botón de Slack con firma válida y marca de hace 10 min: ¿qué hace?', 'D', [
        ('La acepta: la firma es válida', 'Una firma vieja puede ser una repetición.'),
        ('La acepta si viene de Valeria', 'La identidad no corrige una marca vencida.'),
        ('La guarda para mañana', 'No hay nada que guardar: se rechaza.'),
        ('La rechaza: tolerancia de 5 minutos', 'Correcto: firma, marca y que nadie haya decidido antes.')]),
    pregunta(9, 'Control humano', 38, 'Pastel con alergia a la nuez: ¿quién confirma al cliente?', 'C', [
        ('El agente, si la receta lo permite', 'Las recetas no entran en ningún modelo.'),
        ('El chatbot con un mensaje fijo', 'Una alergia no tiene respuesta fija segura.'),
        ('Valeria, tras consultar a Don Ernesto', 'Correcto: es una puerta humana desde el Día 6.'),
        ('Nadie: se rechaza el pedido', 'Se atiende, pero lo decide una persona.')]),
    pregunta(10, 'Medición y costes', 53, 'p95 de WhatsApp 11.9 y del formulario 35.3: ¿p95 conjunto?', 'D', [
        ('23.6 minutos, la media', 'Los percentiles no se promedian.'),
        ('35.3, el peor de los dos', 'El conjunto mezcla volúmenes muy distintos.'),
        ('11.9, el canal con más eventos', 'Hay que mirar todos los eventos juntos.'),
        ('Se calcula sobre todos los eventos juntos', 'Correcto: percentil de la muestra conjunta.')]),
    pregunta(11, 'Medición y costes', 53, 'SLO del 95 % y 1 560 mensajes al mes: ¿presupuesto de error?', 'B', [
        ('1 482 incumplimientos', 'Es el número de mensajes buenos, no el presupuesto.'),
        ('78 incumplimientos', 'Correcto: B = (1 - 0.95) * 1 560 = 78.'),
        ('95 incumplimientos', 'Confundió el SLO con un número de eventos.'),
        ('7.8 incumplimientos', 'Usó un SLO del 99.5 %.')]),
    pregunta(12, 'Medición y costes', 46, '¿Por qué WhatsApp por Twilio costaba 19.13 USD?', 'A', [
        ('Recargo de 0.005 por mensaje recibido y enviado', 'Correcto: 85 % de la factura era recargo.'),
        ('Por las tarifas de marketing', 'Trigo Lento casi no enviaba marketing.'),
        ('Por la cuota fija de Twilio', 'Twilio no tiene cuota fija en ese uso.'),
        ('Por los mensajes de servicio', 'Antes de octubre de 2026 Meta no los cobraba.')]),
]
TEMAS = ['Ventana y plantillas', 'Consentimiento y orquestación', 'Control humano', 'Medición y costes']
(carpeta / 'banco_preguntas_dia_55.json').write_text(json.dumps(BANCO, ensure_ascii = False, indent = 2),
                                                    encoding = 'utf-8')
banco = pd.DataFrame(BANCO)
print('Preguntas por tema:', banco.groupby('tema', sort = False).size().to_dict())
print('Respuestas correctas por letra:', banco['correcta'].value_counts().sort_index().to_dict())
print('Días que cubre el banco:', sorted(banco['dia'].unique().tolist()))

# Corrección, diagnóstico por tema con umbral del 80 % y días a repasar en Python:
def corregir(respuestas, banco = BANCO):
    # Una fila por pregunta con el acierto y la retroalimentación de la opción elegida:
    return pd.DataFrame([{'n': p['n'], 'tema': p['tema'], 'dia': p['dia'],
                          'elegida': respuestas.get(p['n'], '-'), 'correcta': p['correcta'],
                          'acierto': respuestas.get(p['n']) == p['correcta'],
                          'retro': p['retro'].get(respuestas.get(p['n']), 'Sin respuesta.')} for p in banco])

# Respuestas de un lector de ejemplo (inventadas para la demostración):
lector = {1: 'C', 2: 'B', 3: 'D', 4: 'A', 5: 'C', 6: 'B', 7: 'A', 8: 'D', 9: 'C', 10: 'A', 11: 'B', 12: 'B'}
resultado = corregir(lector)
aciertos = int(resultado['acierto'].sum())
print(f'Aciertos: {aciertos} de {len(resultado)} ({aciertos / len(resultado):.1%})')
for _, f in resultado[~resultado['acierto']].iterrows():
    print(f'Pregunta {f.n} (Día {f.dia}): eligió {f.elegida}, era {f.correcta}. {f.retro}')
por_tema = resultado.groupby('tema', sort = False)['acierto'].agg(['sum', 'count'])
por_tema['porcentaje'] = 100 * por_tema['sum'] / por_tema['count']
print(por_tema.to_string())
print('Temas bajo el umbral del 80 %:', por_tema.index[por_tema.porcentaje < 80].tolist(),
      '| días a repasar:', sorted(resultado.loc[~resultado.acierto, 'dia'].unique().tolist()))
print(f'P(10 o más aciertos al azar) = {stats.binom.sf(9, 12, 0.25):.2e} | media al azar: '
      f'{stats.binom.mean(12, 0.25):.0f} aciertos')

fig, ax = plt.subplots(figsize = (9, 4.2))
colores = ['#3a9d5d' if v >= 80 else '#eb6834' for v in por_tema['porcentaje']]
ax.barh(por_tema.index[::-1], por_tema['porcentaje'][::-1], color = colores[::-1], height = 0.55)
for i, (v, s, c) in enumerate(zip(por_tema['porcentaje'][::-1], por_tema['sum'][::-1], por_tema['count'][::-1])):
    ax.text(v - 2, i, f'{v:.0f} % ({s} de {c})', ha = 'right', va = 'center', color = 'white', fontsize = 11)
ax.axvline(80, color = '#52514e', linestyle = '--', linewidth = 1.5)
ax.text(81, 3.45, 'umbral 80 %', fontsize = 10, color = '#52514e')
ax.set_xlim(0, 108)
ax.set_ylim(-0.5, 3.75)
ax.set_xlabel('Aciertos (%)')
ax.set_title('Lector de ejemplo: puntuación por tema del módulo 5', fontsize = 15)
ax.grid(axis = 'x', color = '#e6e5e1')
ax.set_axisbelow(True)
plt.tight_layout()
plt.show()

# Auditoría automática del código de honor sobre los cuatro workflows exportados del módulo en Python:
RUTAS = {'TL Gmail mayoristas v1': 'dia_47/flujos/n8n/gmail_mayoristas_v1.json',
         'TL WhatsApp secuencias v1': 'dia_48/flujos/n8n/whatsapp_secuencias_v1.json',
         'TL Slack operaciones v1': 'dia_50/flujos/n8n/slack_operaciones_v1.json',
         'TL Orquestador v1': 'dia_52/flujos/n8n/orquestador_v1.json'}
PLANTILLAS = {p['name']: p for p in json.loads((proyecto / 'dia_48' / 'plantillas_trigo_lento.json')
                                              .read_text(encoding = 'utf-8'))}
# Plantillas que envía cada flujo según su máquina de estados (Día 48):
ENVIA = {'TL WhatsApp secuencias v1': ['bienvenida_novedades', 'bienvenida_favoritos']}
SECRETO = re.compile(r'(?i)(sk-ant-[\w-]{8,}|xox[bp]-[\w-]+|hooks\.slack\.com/services/T\w+|'
                     r'"bearer [\w.-]{12,}|"x-api-key"\s*:\s*"[^"=]{8,}")')

def auditar(nombre, wf, texto):
    nodos = wf['nodes']
    urls = [n['parameters'].get('url', '') for n in nodos]
    tipos = [n['type'].split('.')[-1] for n in nodos]
    a_clientes = any('graph.facebook.com' in u and u.endswith('/messages') for u in urls)
    usa_claude = any('api.anthropic.com' in u for u in urls)
    con_webhook = 'webhook' in tipos
    plantillas = ENVIA.get(nombre, [])
    silenciados = [n['name'] for n in nodos if n.get('onError') == 'continueRegularOutput' or
                   '"neverError": true' in json.dumps(n.get('parameters', {}))]
    r = {}
    r[1] = ('cumple' if not any('/send' in u for u in urls) and (not a_clientes or 'template' in texto)
            else 'pendiente')
    r[2] = ('no aplica' if not a_clientes and 'consentimientos' not in texto else
            'cumple' if 'consentimientos' in texto and ('baja' in texto) else 'pendiente')
    r[3] = ('no aplica' if not usa_claude else 'cumple' if 'Seudonimizar' in [n['name'] for n in nodos]
            else 'pendiente')
    pies = [c.get('text', '') for p in plantillas for c in PLANTILLAS.get(p, {}).get('components', [])
            if c['type'] == 'FOOTER']
    r[4] = ('no aplica' if not a_clientes else 'cumple' if pies and all('automático' in t for t in pies)
            else 'pendiente')
    r[5] = 'pendiente' if SECRETO.search(texto) else 'cumple'
    r[6] = ('no aplica' if not con_webhook else 'cumple' if ('headerAuth' in texto or 'createHmac' in texto)
            else 'pendiente')
    r[7] = ('no aplica' if not usa_claude else 'cumple' if 'dato, no una instrucción' in texto else 'pendiente')
    r[8] = 'cumple' if wf['settings'].get('saveDataSuccessExecution') == 'none' else 'pendiente'
    r[9] = 'cumple' if wf['settings'].get('errorWorkflow') and not silenciados else 'pendiente'
    r[10] = 'pendiente' if re.search(r'(?i)receta', texto) else 'cumple'
    return r, silenciados

ARTICULOS = ['Humano al mando', 'Consentimiento', 'Minimización', 'Transparencia', 'Secretos',
             'Entradas verificadas', 'Dato, no orden', 'Registro sin datos sensibles', 'Coste y caída',
             'Lo que no sale']
auditoria, notas = {}, {}
for nombre, ruta in RUTAS.items():
    texto = (proyecto / ruta).read_text(encoding = 'utf-8')
    wf = json.loads(texto)
    assert wf['name'] == nombre, f'El archivo {ruta} no es {nombre}'
    auditoria[nombre], notas[nombre] = auditar(nombre, wf, texto)
tabla_honor = pd.DataFrame(auditoria)
tabla_honor.index = [f'{i}. {a}' for i, a in zip(tabla_honor.index, ARTICULOS)]
print(tabla_honor.rename(columns = lambda c: c.replace('TL ', '').replace(' v1', '')).to_string())
for nombre in RUTAS:
    col = tabla_honor[nombre]
    print(f'{nombre}: cumple {int((col == "cumple").sum())} de {int((col != "no aplica").sum())} aplicables;'
          f' pendientes: {[a.split(". ")[1] for a in col.index[col == "pendiente"]] or "ninguno"}')
print('Nodos con errores silenciados:', {k: v for k, v in notas.items() if v} or 'ninguno')
print('Aceptados para producción sin cambios:', [n for n in RUTAS if (tabla_honor[n] != 'pendiente').all()])

# Matriz de riesgos de la comunicación antes y después de los controles, con mapa de calor, en Python:
riesgos = pd.DataFrame([
    ('R1', 'Mensaje libre fuera de ventana', 4, 3, 'puede_enviar antes de cada envío', 48, 1, 3),
    ('R2', 'Plantilla mal categorizada', 3, 3, 'Validador de plantillas', 48, 1, 3),
    ('R3', 'Borrador enviado sin revisar', 2, 5, 'Sin nodo de envío en Gmail', 47, 1, 5),
    ('R4', 'Alerta perdida o ignorada', 4, 4, 'Severidades y agrupación en #alertas', 50, 2, 3),
    ('R5', 'Respuesta doble entre canales', 4, 2, 'Huella y ventana de 30 min', 52, 2, 2),
    ('R6', 'Datos de clientes en Slack', 3, 4, 'Lista blanca de campos', 50, 1, 4),
    ('R7', 'Cambio de tarifas de Meta', 3, 2, 'Taxímetro y revisión trimestral', 46, 3, 1),
    ('R8', 'Plantilla pausada sin aviso', 3, 4, 'Webhook de estado y respaldo', 54, 2, 2),
    ('R9', 'Traducción que cambia el sentido', 2, 3, 'Glosario y revisión humana', 49, 1, 3),
], columns = ['id', 'riesgo', 'p', 'i', 'control', 'dia', 'p_res', 'i_res'])
riesgos['antes'] = riesgos.p * riesgos.i
riesgos['despues'] = riesgos.p_res * riesgos.i_res
riesgos['reduccion'] = 1 - riesgos.despues / riesgos.antes
print(riesgos[['id', 'riesgo', 'p', 'i', 'antes', 'p_res', 'i_res', 'despues', 'dia']].to_string(index = False))
print(f'Exposición total: {riesgos.antes.sum()} antes y {riesgos.despues.sum()} después '
      f'({1 - riesgos.despues.sum() / riesgos.antes.sum():.1%} menos)')
print('Riesgos que siguen en 6 o más:', riesgos.loc[riesgos.despues >= 6, 'id'].tolist(),
      '| el de mayor riesgo residual:', riesgos.loc[riesgos.despues.idxmax(), 'riesgo'])

fig, ejes = plt.subplots(1, 2, figsize = (13, 5.6), sharey = True)
fondo = np.add.outer(np.arange(1, 6), np.arange(1, 6))
for ax, (titulo, pc, ic) in zip(ejes, [('Antes de los controles', 'p', 'i'),
                                        ('Después de los controles', 'p_res', 'i_res')]):
    malla = np.outer(np.arange(1, 6), np.arange(1, 6))
    ax.imshow(malla, origin = 'lower', cmap = 'YlOrRd', vmin = 1, vmax = 25, extent = (0.5, 5.5, 0.5, 5.5))
    celdas = riesgos.groupby([pc, ic])['id'].apply(list)
    for (p, i), ids in celdas.items():
        ax.text(i, p, '\n'.join([' '.join(ids[k:k + 2]) for k in range(0, len(ids), 2)]), ha = 'center',
                va = 'center', fontsize = 11, fontweight = 'bold', color = '#1f1f1f')
    ax.set_xticks(range(1, 6))
    ax.set_yticks(range(1, 6))
    ax.set_xlabel('Impacto (1 a 5)')
    ax.set_title(f'{titulo}: exposición {riesgos[pc].mul(riesgos[ic]).sum()}', fontsize = 13)
ejes[0].set_ylabel('Probabilidad (1 a 5)')
fig.suptitle('Riesgos de la comunicación automatizada de Trigo Lento', fontsize = 15)
plt.tight_layout()
plt.show()

# Coste mensual consolidado de la comunicación frente a los 45 USD en Python:
claude = pd.Series({'Cascada de clasificación (Día 30)': 1.47, 'Agente de pedidos (Día 38)': 2.88,
                    'Gmail: Haiku y Sonnet (Día 47)': 0.039 + 1.43, 'Chatbot: Haiku (Día 48)': 0.0254,
                    'Traducción al inglés (Día 49)': 0.33})
whatsapp = pd.Series({'Respuestas y recordatorios (Día 46)': 6.25, 'Secuencia de bienvenida (Día 48)': 3.18})
coste = pd.Series({'WhatsApp (Cloud API)': whatsapp.sum(), 'API de Claude': claude.sum(), 'Make Core': 10.59,
                   'Servidor n8n': 6.00, 'Slack (plan gratuito)': 0.00})
rubro = pd.Series({'WhatsApp (Cloud API)': 12.00, 'API de Claude': 8.00, 'Make Core': 10.59,
                   'Servidor n8n': 6.00, 'Slack (plan gratuito)': 0.00})
tabla3 = pd.DataFrame({'gasto': coste.round(2), 'rubro': rubro})
tabla3['uso_del_rubro'] = (tabla3.gasto / tabla3.rubro).map(lambda v: f'{v:.0%}' if np.isfinite(v) else '-')
print(claude.round(4).to_string())
print(tabla3.to_string())
total = coste.sum()
print(f'Total: {total:.2f} USD ({total * MXN_POR_USD:.2f} MXN) | libre: {PRESUPUESTO - total:.2f} USD '
      f'({(PRESUPUESTO - total) / PRESUPUESTO:.1%} del presupuesto)')
# Escenario de volumen de diseño del Día 46 (todo cliente responde y todo encargo lleva recordatorio):
diseno = total - whatsapp.iloc[0] + 8.74
print(f'Con el volumen de diseño: WhatsApp {8.74 + whatsapp.iloc[1]:.2f} USD de 12 y total {diseno:.2f} USD '
      f'(libre {PRESUPUESTO - diseno:.2f})')

fig, ax = plt.subplots(figsize = (11, 3.6))
colores = ['#3a9d5d', '#7a5cc9', '#2a78d6', '#52514e']
izquierda = 0
for (nombre, v), color in zip(coste[coste > 0].items(), colores):
    ax.barh(0, v, left = izquierda, color = color, edgecolor = 'white', label = nombre)
    ax.text(izquierda + v / 2, 0, f'{v:.2f}', ha = 'center', va = 'center', color = 'white', fontsize = 11)
    izquierda += v
ax.barh(0, PRESUPUESTO - total, left = total, color = '#e6e5e1', edgecolor = 'white', label = 'Libre')
ax.text(total + (PRESUPUESTO - total) / 2, 0, f'libre {PRESUPUESTO - total:.2f}', ha = 'center', va = 'center',
        fontsize = 11, color = '#1f1f1f')
ax.axvline(PRESUPUESTO, color = '#c8423b', linestyle = '--', linewidth = 1.5)
ax.axvline(diseno, color = '#52514e', linestyle = ':', linewidth = 1.5)
ax.text(diseno, 0.56, f'volumen de diseño: {diseno:.2f}', ha = 'center', fontsize = 10, color = '#52514e')
ax.set_yticks([])
ax.set_xlim(0, 47)
ax.set_ylim(-0.5, 0.8)
ax.set_xlabel('USD al mes')
ax.set_title(f'Gasto mensual por rubro: {total:.2f} de {PRESUPUESTO:.0f} USD', fontsize = 15)
ax.legend(loc = 'upper center', bbox_to_anchor = (0.5, -0.32), ncol = 5, frameon = False)
plt.tight_layout()
plt.show()

# Revisión de bajas pendientes y consentimientos caducados en SQLite antes del fin de semana en Python:
con = sqlite3.connect(':memory:')
con.executescript('''
CREATE TABLE consentimientos (cliente_id TEXT, finalidad TEXT, canal TEXT, otorgado_en TEXT, baja_en TEXT);
CREATE TABLE mensajes_entrantes (cliente_id TEXT, recibido_en TEXT, texto_normalizado TEXT);''')
hoy = datetime(2026, 3, 27, 9, 0)
filas = []
for k in range(1, 321):
    cid = f'C{k:04d}'
    otorgado = hoy - timedelta(days = int(rng.integers(3, 520)))
    finalidad = 'marketing' if k % 3 == 0 else 'confirmaciones'
    baja = (otorgado + timedelta(days = int(rng.integers(1, 60)))).isoformat() if rng.random() < 0.06 else None
    filas.append((cid, finalidad, 'whatsapp', otorgado.isoformat(), baja))
con.executemany('INSERT INTO consentimientos VALUES (?, ?, ?, ?, ?)', filas)
# Palabras de baja recibidas esta semana (seudonimizadas; el texto ya llega normalizado a la palabra clave):
activos = [f[0] for f in filas if f[4] is None]
bajas_recibidas = [(c, (hoy - timedelta(hours = int(h))).isoformat(), 'BAJA')
                   for c, h in zip(rng.choice(activos, 7, replace = False), rng.integers(2, 120, 7))]
con.executemany('INSERT INTO mensajes_entrantes VALUES (?, ?, ?)', bajas_recibidas)
con.executemany('UPDATE consentimientos SET baja_en = ? WHERE cliente_id = ?',
                [(t, c) for c, t, _ in bajas_recibidas[:5]])     # cinco ya aplicadas por el orquestador
pendientes = con.execute('''
SELECT m.cliente_id, m.recibido_en FROM mensajes_entrantes m JOIN consentimientos c USING (cliente_id)
WHERE m.texto_normalizado = 'BAJA' AND c.baja_en IS NULL ORDER BY m.recibido_en''').fetchall()
caducados = con.execute('''
SELECT COUNT(*) FROM consentimientos WHERE finalidad = 'marketing' AND baja_en IS NULL
AND julianday(?) - julianday(otorgado_en) > 365''', (hoy.isoformat(),)).fetchone()[0]
vigentes = con.execute('''SELECT finalidad, COUNT(*) FROM consentimientos WHERE baja_en IS NULL
GROUP BY finalidad''').fetchall()
print('Consentimientos vigentes por finalidad:', dict(vigentes))
print('Bajas recibidas esta semana:', len(bajas_recibidas), '| sin aplicar:', len(pendientes))
for c, t in pendientes:
    print(f'  {c} pidió la baja el {t[:16].replace("T", " ")} y sigue activo')
print('Consentimientos de marketing con más de 12 meses sin renovar:', caducados)
con.close()

# Matriz "quién contesta qué" por tipo de mensaje y volumen mensual en Python:
quien = pd.DataFrame([
    ('Horario, precios y ubicación', 620, 'Máquina sola', 'Chatbot con reglas y botones'),
    ('Fuera de horario', 380, 'Máquina sola', 'Acuse automático y cola'),
    ('Baja ("BAJA", "ya no")', 30, 'Máquina sola', 'Baja inmediata'),
    ('Correo informativo (molino, boletín)', 170, 'Máquina sola', 'Etiqueta en Gmail, sin respuesta'),
    ('Encargo sencillo', 420, 'Máquina con aviso', 'Agente de pedidos y #pedidos-del-dia'),
    ('Pastel por encargo', 40, 'Máquina con aprobación', 'Agente y #aprobaciones'),
    ('Cambio de pedido', 120, 'Máquina con aprobación', 'Agente y Valeria o Don Ernesto'),
    ('Correo que pide respuesta', 130, 'Borrador y persona', 'Gmail: Valeria revisa y envía'),
    ('Mensaje libre en inglés', 90, 'Borrador y persona', 'Sonnet propone y una persona revisa'),
    ('Queja', 60, 'Solo persona', 'Valeria contesta y firma'),
    ('Alergia o ingrediente', 40, 'Solo persona', 'Valeria consulta a Don Ernesto'),
    ('Otros o ambiguos', 230, 'Solo persona', 'Mostrador o Valeria'),
], columns = ['tipo', 'al_mes', 'quien_contesta', 'como'])
assert quien.al_mes.sum() == sum(EVENTOS_MES.values()), 'La matriz no suma los 2 330 eventos'
resumen = quien.groupby('quien_contesta', sort = False)['al_mes'].sum().to_frame()
resumen['porcentaje'] = (100 * resumen.al_mes / resumen.al_mes.sum()).round(1)
print(quien[['tipo', 'al_mes', 'quien_contesta']].to_string(index = False))
print(resumen.to_string())
persona = resumen.loc[['Borrador y persona', 'Solo persona'], 'al_mes'].sum()
print(f'Mensajes que firma o decide una persona: {persona} de {quien.al_mes.sum()} '
      f'({persona / quien.al_mes.sum():.1%}); con aprobación previa: '
      f'{resumen.loc["Máquina con aprobación", "al_mes"]}; sin ninguna persona: '
      f'{resumen.loc["Máquina sola", "al_mes"]}')

# Resumen de una página para Don Ernesto con Claude Opus 5.5 a partir de cifras agregadas en Python (bloque API, no se ejecuta aquí):
import json
import re
import anthropic

# Solo cifras agregadas de los bloques 6, 7, 8, 9 y 10: ni nombres, ni teléfonos, ni textos de clientes:
cifras = {
    'flujos_auditados': 4, 'aceptados_sin_cambios': ['TL Slack operaciones v1'],
    'pendientes': {'TL WhatsApp secuencias v1': ['Transparencia', 'Registro sin datos sensibles', 'Coste y caída'],
                   'TL Gmail mayoristas v1': ['Coste y caída'], 'TL Orquestador v1': ['Coste y caída']},
    'exposicion_riesgo': {'antes': 91, 'despues': 35, 'mayor_residual': 'Alerta perdida o ignorada'},
    'coste_usd': {'whatsapp': 9.43, 'claude': 6.17, 'make': 10.59, 'servidor': 6.00, 'total': 32.19, 'libre': 12.81},
    'bajas_sin_aplicar': 2, 'consentimientos_marketing_vencidos': 32,
    'quien_contesta': {'maquina_sola': 1200, 'maquina_con_aviso': 420, 'con_aprobacion': 160,
                       'borrador_y_persona': 220, 'solo_persona': 330},
}
ESQUEMA = {'type': 'object', 'additionalProperties': False,
           'required': ['titular', 'lo_que_ya_funciona', 'lo_que_falta', 'decision_para_el_lunes'],
           'properties': {'titular': {'type': 'string'},
                          'lo_que_ya_funciona': {'type': 'array', 'items': {'type': 'string'}},
                          'lo_que_falta': {'type': 'array', 'items': {'type': 'string'}},
                          'decision_para_el_lunes': {'type': 'string'}}}
SISTEMA = ('Usted escribe para Don Ernesto, dueño de la panadería Trigo Lento, un resumen semanal de una página. '
           'Escriba en español, de usted, con frases cortas y sin palabras técnicas en inglés. Use solo las cifras '
           'del bloque <cifras>; no invente ninguna y no redondee los importes. Diga primero quién contesta qué, '
           'después lo que falta y termine con una sola decisión que él pueda tomar el lunes.')

cliente = anthropic.Anthropic()   # lee ANTHROPIC_API_KEY del entorno
respuesta = cliente.beta.messages.create(
    model = 'claude-opus-5-5',
    max_tokens = 1500,
    betas = ['server-side-fallback-2026-07-01'],
    fallbacks = 'default',                      # respaldo del lado del servidor ante un rechazo
    output_config = {'effort': 'low',            # sin temperature ni top_p
                     'format': {'type': 'json_schema', 'schema': ESQUEMA}},
    system = SISTEMA,
    messages = [{'role': 'user', 'content': f'<cifras>{json.dumps(cifras, ensure_ascii = False)}</cifras>'}],
)
if respuesta.stop_reason != 'end_turn':
    raise SystemExit(f'Sin resumen ({respuesta.stop_reason}): Valeria lo escribe a mano')
resumen = json.loads(next(b.text for b in respuesta.content if b.type == 'text'))
# Comprobación barata: cada cifra del resumen debe existir en las cifras de entrada:
permitidas = set(re.findall(r'\d+(?:\.\d+)?', json.dumps(cifras)))
inventadas = set(re.findall(r'\d+(?:\.\d+)?', json.dumps(resumen, ensure_ascii = False))) - permitidas
print(json.dumps(resumen, ensure_ascii = False, indent = 2))
print('Cifras que no estaban en la entrada:', sorted(inventadas) or 'ninguna')
print('Tokens:', respuesta.usage.input_tokens, 'de entrada y', respuesta.usage.output_tokens, 'de salida')

# Salida de ejemplo (puede variar):
# {
#   "titular": "La máquina contesta sola 1200 mensajes al mes; 330 los atiende solo una persona.",
#   "lo_que_ya_funciona": ["Slack de operaciones cumple todo el código de honor.",
#                          "El riesgo baja de 91 a 35 puntos con los controles.",
#                          "La comunicación cuesta 32.19 USD y quedan 12.81 libres."],
#   "lo_que_falta": ["Aplicar 2 bajas que siguen sin aplicar.",
#                    "Pedir de nuevo el permiso a 32 clientes de novedades.",
#                    "Que los errores de tres flujos avisen en Slack."],
#   "decision_para_el_lunes": "Autorizar que las novedades digan que son mensajes automáticos."
# }
# Cifras que no estaban en la entrada: ninguna
# Tokens: 518 de entrada y 214 de salida