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

# Importaciones base, semilla de la serie, zona horaria, carpeta del día y supuestos en Python:
import warnings
warnings.filterwarnings('ignore')
import json
import sqlite3
import textwrap
import threading
import time
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timedelta
from pathlib import Path
from zoneinfo import ZoneInfo
import numpy as np
import pandas as pd
import matplotlib.dates as mdates
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch, FancyBboxPatch, Polygon, RegularPolygon, Wedge, Rectangle

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 140)
pd.set_option('display.max_colwidth', 70)
CDMX = ZoneInfo('America/Mexico_City')
carpeta = Path('trigo_lento') / 'dia_76'
carpeta.mkdir(parents = True, exist_ok = True)

# Supuestos del día (ficha) y datos fijos de la serie:
PUBLICACIONES_MES = 36        # piezas al mes en tres redes (Día 71)
P_CADUCIDAD = 0.04            # probabilidad supuesta de que una aprobación caduque
TICKET_PAY = 380              # pay de queso entero (P12), MXN
MXN_POR_USD = 18.50           # tipo de cambio didáctico de la serie
PRESUPUESTO_USD = 45          # presupuesto mensual del ecosistema
print('numpy', np.__version__, '| pandas', pd.__version__)
print('Desfase de la Ciudad de México el 16 de abril de 2026:', datetime(2026, 4, 16, 20, tzinfo = CDMX).strftime('%z'))
print(f'Supuestos: {PUBLICACIONES_MES} piezas al mes | caducidad {P_CADUCIDAD:.0%} | pay {TICKET_PAY} MXN')

# Registros reconstruidos del incidente (ejecuciones, aprobaciones y publicaciones) y línea de tiempo en Python:
dia = lambda h, m, s = 0, d = 16: datetime(2026, 4, d, h, m, s, tzinfo = CDMX)
ejecuciones = pd.DataFrame([
    ('TL Publicación multired', 'v1', dia(18, 0), dia(20, 0, 3), 'success', 'publicada en 2 redes'),
    ('TL Aprobaciones', 'v1', dia(18, 0), dia(20, 0, 0), 'success', 'devolvió estado "caducada"'),
    ('TL WhatsApp entrantes', 'v3', dia(20, 0, 2), dia(20, 0, 2), 'success', 'escribió estado "rechazada"'),
], columns = ['flujo', 'version', 'inicio', 'fin', 'estado', 'nota'])
aprobaciones = pd.DataFrame([      # historial de escrituras sobre la fila 'APR-0416-07'
    (dia(18, 0, 0), 'Crear aprobación', None, 'pendiente', 'Slack #aprobaciones'),
    (dia(18, 30, 0), 'Escalado', 'pendiente', 'pendiente', 'Valeria, por Slack'),
    (dia(19, 0, 0), 'Escalado', 'pendiente', 'pendiente', 'Don Ernesto, por WhatsApp'),
    (dia(20, 0, 0), 'Reloj de caducidad (Wait)', 'pendiente', 'caducada', 'escritor 1'),
    (dia(20, 0, 2), 'Webhook del botón', 'caducada', 'rechazada', 'escritor 2'),
], columns = ['hora', 'escritor', 'antes', 'despues', 'canal'])
publicaciones = pd.DataFrame([
    ('TL-0416-PROMO-IG', 'instagram', dia(20, 0, 1), dia(20, 42, 10)),
    ('TL-0416-PROMO-FB', 'facebook', dia(20, 0, 1), dia(20, 42, 40)),
], columns = ['pieza', 'red', 'publicada', 'retirada'])
personas = pd.DataFrame([
    (dia(19, 59, 58), 'WhatsApp de Don Ernesto', 'Pulsa "Rechazar"'),
    (dia(20, 35, 0), 'Mensaje directo de una clienta', '"¿Es cierto lo del 2x1?"'),
    (dia(8, 0, 0, d = 17), 'Cuadro de mando del Día 75', 'Aprobación válida: 35 de 36'),
], columns = ['hora', 'fuente', 'evento'])
for nombre, df in [('ejecuciones', ejecuciones), ('aprobaciones', aprobaciones), ('publicaciones', publicaciones)]:
    df.to_csv(carpeta / f'{nombre}_incidente.csv', index = False)

linea = pd.concat([
    aprobaciones.assign(fuente = 'tabla aprobaciones', evento = aprobaciones['escritor'] + ' (' + aprobaciones['canal'] + ')',
                        estado = aprobaciones['despues'])[['hora', 'fuente', 'evento', 'estado']],
    publicaciones.assign(hora = publicaciones['publicada'], fuente = 'API de publicación',
                         evento = 'Publicada ' + publicaciones['pieza'], estado = 'caducada')[['hora', 'fuente', 'evento', 'estado']],
    publicaciones.assign(hora = publicaciones['retirada'], fuente = 'API de publicación',
                         evento = 'Retirada a mano ' + publicaciones['pieza'], estado = 'rechazada')[['hora', 'fuente', 'evento', 'estado']],
    personas.assign(estado = ['pendiente', 'rechazada', 'rechazada'])[['hora', 'fuente', 'evento', 'estado']],
]).sort_values('hora').reset_index(drop = True)
linea['hora_txt'] = linea['hora'].dt.strftime('%d/%m %H:%M:%S')
print(linea[['hora_txt', 'fuente', 'evento', 'estado']].to_string(index = False))

publicada, retirada = publicaciones['publicada'].min(), publicaciones['retirada'].max()
clienta, panel = personas['hora'].iloc[1], personas['hora'].iloc[2]
ventana = (aprobaciones['hora'].iloc[4] - personas['hora'].iloc[0]).total_seconds()
print(f'Ventana de la carrera (botón a escritura del webhook): {ventana:.0f} s')
hms = lambda td: str(td).split(' ')[-1]                     # duración como hh:mm:ss
print(f'Tiempo publicada: {hms(retirada - publicada)} | detección por una persona: {hms(clienta - publicada)}')
print(f'Detección por el propio sistema (panel de la mañana): {hms(panel - publicada)}')

# Línea de tiempo: la tarde completa y el acercamiento a los cuatro segundos de la carrera:
fig, (ax1, ax2) = plt.subplots(2, 1, figsize = (12, 7.4), gridspec_kw = {'height_ratios': [1, 1.25]})
carriles = {'Personas': 3, 'Webhook del botón (escritor 2)': 2, 'Reloj de caducidad (escritor 1)': 1, 'Flujo de publicación': 0}
hitos = [(dia(18, 0), 'Flujo de publicación', 'Borrador y\npedido de aprobación', '#2a78d6'),
         (dia(18, 30), 'Personas', 'Escala a\nValeria', '#8a8a8a'),
         (dia(19, 0), 'Personas', 'Escala a\nDon Ernesto', '#8a8a8a'),
         (dia(20, 0, 1), 'Flujo de publicación', 'Publicada', '#d62728'),
         (dia(20, 35), 'Personas', 'Aviso de\nuna clienta', '#8a8a8a'),
         (dia(20, 42, 40), 'Flujo de publicación', 'Retirada\na mano', '#1f9d55')]
for hora, carril, texto, color in hitos:
    ax1.plot(hora, carriles[carril], 'o', color = color, markersize = 10)
    ax1.annotate(texto, (hora, carriles[carril]), xytext = (0, 14), textcoords = 'offset points',
                 ha = 'center', fontsize = 9)
ax1.axvspan(publicada, retirada, color = '#d62728', alpha = 0.12, label = 'Publicada sin aprobación válida (42 min)')
ax1.set_yticks(list(carriles.values()))
ax1.set_yticklabels(list(carriles.keys()), fontsize = 9)
ax1.set_ylim(-0.6, 3.9)
ax1.set_xlim(dia(17, 50), dia(21, 0))
ax1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M', tz = CDMX))
ax1.legend(loc = 'lower right', fontsize = 9)
ax1.set_title('Jueves 16 de abril de 2026: la tarde del incidente', fontsize = 14)
cerca = [(personas['hora'].iloc[0], 'Personas', 'Don Ernesto pulsa\n"Rechazar" 19:59:58', '#8a8a8a'),
         (dia(20, 0, 0), 'Reloj de caducidad (escritor 1)', 'Escribe "caducada"\n20:00:00', '#eb6834'),
         (dia(20, 0, 1), 'Flujo de publicación', 'Switch: salida por defecto,\npublica 20:00:01', '#d62728'),
         (dia(20, 0, 2), 'Webhook del botón (escritor 2)', 'Escribe "rechazada"\n20:00:02', '#7b3fb5')]
for hora, carril, texto, color in cerca:
    ax2.plot(hora, carriles[carril], 's', color = color, markersize = 11)
    ax2.annotate(texto, (hora, carriles[carril]), xytext = (0, 13), textcoords = 'offset points',
                 ha = 'center', fontsize = 9)
ax2.axvspan(personas['hora'].iloc[0], dia(20, 0, 2), color = '#eb6834', alpha = 0.15,
            label = 'Ventana de la carrera: 4 segundos')
ax2.axvline(dia(20, 0, 0), color = '#52514e', linestyle = '--', linewidth = 1.2)
ax2.set_yticks(list(carriles.values()))
ax2.set_yticklabels(list(carriles.keys()), fontsize = 9)
ax2.set_ylim(-0.6, 3.9)
ax2.set_xlim(dia(19, 59, 56), dia(20, 0, 4))
ax2.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S', tz = CDMX))
ax2.legend(loc = 'lower left', fontsize = 9)
ax2.set_title('Acercamiento: dos escritores sobre la misma fila de aprobaciones', fontsize = 13)
plt.tight_layout()
plt.show()

# Reproducción de la condición de carrera con dos escritores en hilos sobre una copia de SQLite en Python:
ruta_bd = carpeta / 'trigo_lento_copia.sqlite'
ruta_bd.unlink(missing_ok = True)
TERMINALES = ('aprobada', 'rechazada', 'caducada')

def preparar(con):
    con.executescript("""
        CREATE TABLE aprobaciones (id INTEGER PRIMARY KEY, version TEXT, estado TEXT NOT NULL);
        CREATE TABLE historial (id_aprobacion INTEGER, antes TEXT, despues TEXT);
        CREATE TRIGGER registrar AFTER UPDATE OF estado ON aprobaciones
        BEGIN INSERT INTO historial VALUES (NEW.id, OLD.estado, NEW.estado); END;
        CREATE TRIGGER terminal_inmutable BEFORE UPDATE OF estado ON aprobaciones
        WHEN NEW.version = 'v2' AND OLD.estado <> 'pendiente'
        BEGIN SELECT RAISE(ABORT, 'transición prohibida desde un estado terminal'); END;""")

def conectar():
    return sqlite3.connect(ruta_bd, timeout = 5, isolation_level = None, check_same_thread = False)

def escribir(con, id_, estado, version):
    # v1: "la última escritura gana"; v2: comparar e intercambiar (solo si sigue pendiente):
    sql = 'UPDATE aprobaciones SET estado = ? WHERE id = ?'
    if version == 'v2':
        sql += " AND estado = 'pendiente'"
    try:
        return con.execute(sql, (estado, id_)).rowcount
    except sqlite3.IntegrityError:
        return 0

def reloj_de_caducidad(id_, version, espera, reanudada):
    time.sleep(espera)
    con = conectar()
    if reanudada.is_set():                         # la decisión llegó antes: no hay caducidad
        visto = 'rechazada'
    elif escribir(con, id_, 'caducada', version) == 1:
        visto = 'caducada'
    else:                                          # v2: otro escritor ganó; se lee lo que quedó
        visto = con.execute('SELECT estado FROM aprobaciones WHERE id = ?', (id_,)).fetchone()[0]
    con.close()
    return visto

def webhook_del_boton(id_, version, espera, reanudada):
    time.sleep(espera)
    con = conectar()
    filas = escribir(con, id_, 'rechazada', version)
    if filas == 1:
        reanudada.set()                            # reanuda la espera del flujo
    con.close()
    return 'aplicada' if filas == 1 else 'tardía: aviso a Slack'

con = conectar()
preparar(con)
REPETICIONES, PLAZO = 1000, 0.020                  # 1 000 carreras; la caducidad, a los 20 ms
resultados = []
with ThreadPoolExecutor(max_workers = 2) as hilos:
    for version in ['v1', 'v2']:
        for i in range(REPETICIONES):
            desfase = rng.uniform(-0.015, 0.015)
            while abs(desfase) < 0.003:            # separaciones de al menos 3 ms
                desfase = rng.uniform(-0.015, 0.015)
            id_ = con.execute('INSERT INTO aprobaciones (version, estado) VALUES (?, ?)', (version, 'pendiente')).lastrowid
            reanudada = threading.Event()
            f1 = hilos.submit(reloj_de_caducidad, id_, version, PLAZO, reanudada)
            f2 = hilos.submit(webhook_del_boton, id_, version, PLAZO + desfase, reanudada)
            visto, boton = f1.result(), f2.result()
            final = con.execute('SELECT estado FROM aprobaciones WHERE id = ?', (id_,)).fetchone()[0]
            resultados.append({'version': version, 'id': id_, 'boton_tarde': desfase > 0, 'visto': visto,
                               'final': final, 'boton': boton})
prohibidas = pd.read_sql("SELECT a.version, COUNT(*) AS n FROM historial h JOIN aprobaciones a ON a.id = h.id_aprobacion "
                         "WHERE h.antes <> 'pendiente' GROUP BY a.version", con).set_index('version')['n']
con.close()
carreras = pd.DataFrame(resultados)
carreras['publico_vio_otro'] = carreras['visto'] != carreras['final']
for version, g in carreras.groupby('version'):
    print(f'{version}: botón después del plazo en {g.boton_tarde.sum()} de {len(g)} carreras')
    print('   estado que vio el flujo de publicación:', g['visto'].value_counts().to_dict())
    print('   estado final del registro:            ', g['final'].value_counts().to_dict())
    print('   el registro contradice lo que vio el flujo:', int(g['publico_vio_otro'].sum()),
          '| transiciones prohibidas aceptadas:', int(prohibidas.get(version, 0)),
          '| decisiones tardías avisadas:', int((g['boton'] != 'aplicada').sum()))

# Máquina de estados con transiciones permitidas y decidir_publicacion en versión abierta y cerrada en Python:
ESTADOS = ['pendiente', 'aprobada', 'rechazada', 'caducada']
TRANSICIONES = {'pendiente': {'aprobada', 'rechazada', 'caducada'}, 'aprobada': set(), 'rechazada': set(), 'caducada': set()}

def transicion_valida(antes, despues):
    return despues in TRANSICIONES.get(antes, set())

def decidir_publicacion_abierta(estado):
    # Como el switch de TL Publicación multired v1: un caso "rechazada" y la salida por defecto publica:
    if estado == 'rechazada':
        return 'bloquear'
    return 'publicar'

def decidir_publicacion_cerrada(estado):
    # Como TL Publicación multired v2: solo "aprobada" publica; todo lo demás se detiene y avisa:
    if estado == 'aprobada':
        return 'publicar'
    return 'detener y avisar'

matriz = pd.DataFrame([[transicion_valida(a, d) for d in ESTADOS] for a in ESTADOS], index = ESTADOS, columns = ESTADOS)
print('Transiciones permitidas:', int(matriz.values.sum()), 'de', matriz.size)
print(matriz.replace({True: 'sí', False: '-'}).to_string())
casos = ESTADOS + ['Aprobada', 'cancelada', None]
tabla_verdad = pd.DataFrame({'estado': [repr(c) for c in casos],
                             'v1 abierta': [decidir_publicacion_abierta(c) for c in casos],
                             'v2 cerrada': [decidir_publicacion_cerrada(c) for c in casos],
                             'esperado': ['publicar' if c == 'aprobada' else 'no publicar' for c in casos]})
tabla_verdad['v1 correcta'] = (tabla_verdad['v1 abierta'] == 'publicar') == (tabla_verdad['esperado'] == 'publicar')
tabla_verdad['v2 correcta'] = (tabla_verdad['v2 cerrada'] == 'publicar') == (tabla_verdad['esperado'] == 'publicar')
print(tabla_verdad.to_string(index = False))
print('Casos correctos: v1', int(tabla_verdad['v1 correcta'].sum()), 'de', len(casos),
      '| v2', int(tabla_verdad['v2 correcta'].sum()), 'de', len(casos))

# Árbol de fallos con probabilidades supuestas por rama y probabilidad del evento superior en Python:
def compuerta_o(ps):
    return 1 - np.prod([1 - p for p in ps])

def compuerta_y(ps):
    return float(np.prod(ps))

HOJAS = {'caducada': 0.04, 'desconocido': 0.002, 'falsificada': 0.0005, 'manual': 0.001}   # por pieza, supuestos
SALIDA_ABIERTA = {'v1': 1.0, 'v2': 0.0}
arbol = {}
for version, abierta in SALIDA_ABIERTA.items():
    llega = compuerta_o([HOJAS['caducada'], HOJAS['desconocido']])
    rama_y = compuerta_y([llega, abierta])
    superior = compuerta_o([rama_y, HOJAS['falsificada'], HOJAS['manual']])
    arbol[version] = {'estado no aprobado llega': llega, 'rama Y': rama_y, 'evento superior': superior,
                      'piezas al año': superior * PUBLICACIONES_MES * 12}
print(pd.DataFrame(arbol).round(5).to_string())
print(f"La corrección divide el evento superior entre {arbol['v1']['evento superior'] / arbol['v2']['evento superior']:.1f}")

# Dibujo del árbol de fallos con compuertas Y y O:
def caja(ax, x, y, texto, color, ancho = 2.6, alto = 0.9):
    ax.add_patch(FancyBboxPatch((x - ancho / 2, y - alto / 2), ancho, alto, boxstyle = 'round,pad=0.04',
                                facecolor = color, edgecolor = '#52514e', linewidth = 1.2))
    ax.text(x, y, texto, ha = 'center', va = 'center', fontsize = 9.5, color = 'white' if color != '#f2f2f2' else '#222')

def puerta(ax, x, y, tipo):
    if tipo == 'Y':
        ax.add_patch(Rectangle((x - 0.35, y - 0.3), 0.7, 0.3, facecolor = '#ffd27f', edgecolor = '#52514e'))
        ax.add_patch(Wedge((x, y), 0.35, 0, 180, facecolor = '#ffd27f', edgecolor = '#52514e'))
    else:
        ax.add_patch(Polygon([(x - 0.38, y - 0.3), (x, y - 0.12), (x + 0.38, y - 0.3), (x + 0.3, y + 0.05), (x, y + 0.42),
                              (x - 0.3, y + 0.05)], closed = True, facecolor = '#ffd27f', edgecolor = '#52514e'))
    ax.text(x, y - 0.02, tipo, ha = 'center', va = 'center', fontsize = 10, weight = 'bold')

def unir(ax, x1, y1, x2, y2):
    ax.plot([x1, x1, x2, x2], [y1, (y1 + y2) / 2, (y1 + y2) / 2, y2], color = '#52514e', linewidth = 1.1)

v1, v2 = arbol['v1'], arbol['v2']
fig, ax = plt.subplots(figsize = (13, 7.2))
caja(ax, 6.5, 6.4, f"Pieza publicada sin aprobación válida\nv1: {v1['evento superior']:.4f} | v2: {v2['evento superior']:.4f} por pieza",
     '#d62728', ancho = 4.6, alto = 1.0)
puerta(ax, 6.5, 5.35, 'O')
unir(ax, 6.5, 5.9, 6.5, 5.75)
caja(ax, 3.0, 4.0, f"Estado no aprobado con salida\npor defecto abierta\nv1: {v1['rama Y']:.4f} | v2: {v2['rama Y']:.4f}",
     '#2a78d6', ancho = 3.6, alto = 1.1)
caja(ax, 7.4, 4.0, f"Aprobación falsificada\n(botón sin firma verificada)\n{HOJAS['falsificada']}", '#8a8a8a', ancho = 3.2, alto = 1.1)
caja(ax, 11.2, 4.0, f"Publicación manual\nfuera del flujo\n{HOJAS['manual']}", '#8a8a8a', ancho = 3.0, alto = 1.1)
for x in (3.0, 7.4, 11.2):
    unir(ax, 6.5, 5.05, x, 4.55)
puerta(ax, 3.0, 2.95, 'Y')
unir(ax, 3.0, 3.45, 3.0, 3.3)
caja(ax, 1.6, 1.6, f"Estado distinto de\n\"aprobada\" llega\n{v1['estado no aprobado llega']:.4f}", '#2a78d6', ancho = 2.6, alto = 1.1)
caja(ax, 4.9, 1.6, "Switch con salida por\ndefecto hacia publicar\nv1: 1.0 | v2: 0.0", '#eb6834', ancho = 2.9, alto = 1.1)
unir(ax, 3.0, 2.65, 1.6, 2.15)
unir(ax, 3.0, 2.65, 4.9, 2.15)
puerta(ax, 1.6, 0.6, 'O')
unir(ax, 1.6, 1.05, 1.6, 0.95)
ax.text(1.6, -0.15, f"caducada {HOJAS['caducada']} | desconocido {HOJAS['desconocido']}", ha = 'center', fontsize = 9.5)
ax.text(9.3, 1.4, f"Piezas al año sin aprobación válida\n(432 piezas): v1 {v1['piezas al año']:.2f} | v2 {v2['piezas al año']:.2f}",
        ha = 'center', fontsize = 11, color = '#222')
ax.set_xlim(-0.2, 13.2)
ax.set_ylim(-0.5, 7.1)
ax.axis('off')
ax.set_title('Árbol de fallos del incidente (probabilidades supuestas por pieza)', fontsize = 14)
plt.tight_layout()
plt.show()

# Monte Carlo de 1 000 años de publicaciones con falla abierta y con falla cerrada en Python:
ANIOS = 1000
caducadas = rng.binomial(PUBLICACIONES_MES, P_CADUCIDAD, size = (ANIOS, 12))      # por año y mes
sin_aprobacion_abierta = caducadas.sum(axis = 1)        # falla abierta: cada caducada sale publicada
sin_aprobacion_cerrada = np.zeros(ANIOS, dtype = int)   # falla cerrada: ninguna sale
retenidas = caducadas.sum(axis = 1)                     # falla cerrada: vuelven a pedir aprobación
retraso_min = rng.lognormal(np.log(35), 0.8, size = retenidas.sum())   # nueva aprobación, mediana 35 min
pierden_hueco = retraso_min > 120                       # más de 2 h: se reprograma la pieza
print(f'Falla abierta: {sin_aprobacion_abierta.mean():.2f} piezas al año sin aprobación válida '
      f'(analítico {PUBLICACIONES_MES * 12 * P_CADUCIDAD:.2f})')
print(f'P(al menos una en un mes): simulada {(caducadas > 0).mean():.3f} | analítica {1 - (1 - P_CADUCIDAD) ** PUBLICACIONES_MES:.3f}')
print(f'Años sin ninguna: {(sin_aprobacion_abierta == 0).sum()} de {ANIOS} | máximo en un año: {sin_aprobacion_abierta.max()}')
print(f'Falla cerrada: {sin_aprobacion_cerrada.mean():.2f} sin aprobación | {retenidas.mean():.2f} retenidas al año')
print(f'Retraso de la nueva aprobación: mediana {np.median(retraso_min):.1f} min | p90 {np.percentile(retraso_min, 90):.1f} min')
print(f'Retenidas que pierden su hueco (> 2 h) y se reprograman: {pierden_hueco.mean():.1%} '
      f'= {pierden_hueco.sum() / ANIOS:.2f} piezas al año')

# Piezas sin aprobación válida por año y piezas retenidas con su retraso:
fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (13, 4.8))
bordes = np.arange(-0.5, sin_aprobacion_abierta.max() + 1.5)
ax1.hist(sin_aprobacion_abierta, bins = bordes, color = '#d62728', alpha = 0.75, label = 'Falla abierta (v1)')
ax1.hist(sin_aprobacion_cerrada, bins = bordes, color = '#1f9d55', alpha = 0.85, label = 'Falla cerrada (v2): 0 siempre')
ax1.axvline(sin_aprobacion_abierta.mean(), color = '#52514e', linestyle = '--', label = f'Media abierta: {sin_aprobacion_abierta.mean():.2f}')
ax1.set_xlabel('Piezas publicadas sin aprobación válida en un año')
ax1.set_ylabel('Años simulados (de 1 000)')
ax1.set_title('Lo que sale sin permiso', fontsize = 13)
ax1.legend(fontsize = 9)
ax2.hist(retraso_min, bins = np.arange(0, 300, 10), color = '#2a78d6', alpha = 0.8)
ax2.axvline(120, color = '#d62728', linestyle = '--', label = 'Más de 2 h: se reprograma')
ax2.set_xlabel('Retraso de la nueva aprobación de una pieza retenida (minutos)')
ax2.set_ylabel('Piezas retenidas (1 000 años)')
ax2.set_title('El precio de la falla cerrada: esperar', fontsize = 13)
ax2.legend(fontsize = 9)
plt.tight_layout()
plt.show()

[
  {
    "name": "TL Aprobaciones v2",
    "nodes": [
      {
        "parameters": {"workflowInputs": {"values": [{"name": "pieza"}, {"name": "red"}, {"name": "texto"}, {"name": "huella"}]}},
        "id": "0b1c7600-0000-4000-8000-000000000001",
        "name": "Pedir aprobación",
        "type": "n8n-nodes-base.executeWorkflowTrigger",
        "typeVersion": 1.1,
        "position": [0, 0]
      },
      {
        "parameters": {"operation": "executeQuery", "query": "INSERT INTO aprobaciones (pieza, red, huella, estado, version_contrato, url_reanudar, caduca_en) VALUES ($1, $2, $3, 'pendiente', 2, $4, now() + interval '2 hours') RETURNING id, estado, caduca_en;", "options": {"queryReplacement": "={{ [$json.pieza, $json.red, $json.huella, $execution.resumeUrl] }}"}},
        "id": "0b1c7600-0000-4000-8000-000000000002",
        "name": "Crear aprobación",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [220, 0],
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG01", "name": "Postgres TL aprobaciones"}}
      },
      {
        "parameters": {"method": "POST", "url": "={{ $env.TL_SLACK_WEBHOOK_APROBACIONES }}", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: 'Aprobación pendiente: ' + $('Pedir aprobación').item.json.pieza, id_aprobacion: $json.id }) }}", "options": {"timeout": 10000}},
        "id": "0b1c7600-0000-4000-8000-000000000003",
        "name": "Avisar a quien aprueba",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [440, 0]
      },
      {
        "parameters": {"resume": "webhook", "httpMethod": "POST", "limitWaitTime": true, "limitType": "afterTimeInterval", "resumeAmount": 2, "resumeUnit": "hours", "options": {}},
        "id": "0b1c7600-0000-4000-8000-000000000004",
        "name": "Esperar decisión",
        "type": "n8n-nodes-base.wait",
        "typeVersion": 1.1,
        "position": [660, 0],
        "webhookId": "00000000-0000-4000-8000-0000000076aa"
      },
      {
        "parameters": {"operation": "executeQuery", "query": "UPDATE aprobaciones SET estado = 'caducada', cerrada_en = now(), cerrada_por = 'reloj' WHERE id = $1 AND estado = 'pendiente' RETURNING id, estado;", "options": {"queryReplacement": "={{ [$('Crear aprobación').item.json.id] }}"}},
        "id": "0b1c7600-0000-4000-8000-000000000005",
        "name": "Caducar si sigue pendiente",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [880, 0],
        "alwaysOutputData": true,
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG01", "name": "Postgres TL aprobaciones"}}
      },
      {
        "parameters": {"operation": "executeQuery", "query": "SELECT id, estado, aprobador, huella, version_contrato FROM aprobaciones WHERE id = $1;", "options": {"queryReplacement": "={{ [$('Crear aprobación').item.json.id] }}"}},
        "id": "0b1c7600-0000-4000-8000-000000000006",
        "name": "Leer estado final",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [1100, 0],
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG01", "name": "Postgres TL aprobaciones"}}
      },
      {
        "parameters": {"assignments": {"assignments": [{"id": "a7600001", "name": "estado", "value": "={{ $json.estado }}", "type": "string"}, {"id": "a7600002", "name": "aprobador", "value": "={{ $json.aprobador }}", "type": "string"}, {"id": "a7600003", "name": "huella", "value": "={{ $json.huella }}", "type": "string"}, {"id": "a7600004", "name": "version_contrato", "value": 2, "type": "number"}]}, "options": {}},
        "id": "0b1c7600-0000-4000-8000-000000000007",
        "name": "Responder con contrato v2",
        "type": "n8n-nodes-base.set",
        "typeVersion": 3.4,
        "position": [1320, 0]
      },
      {
        "parameters": {"httpMethod": "POST", "path": "tl-decision-aprobacion", "responseMode": "onReceived", "options": {"rawBody": true}},
        "id": "0b1c7600-0000-4000-8000-000000000008",
        "name": "Botón de decisión",
        "type": "n8n-nodes-base.webhook",
        "typeVersion": 2,
        "position": [0, 300],
        "webhookId": "00000000-0000-4000-8000-0000000076bb"
      },
      {
        "parameters": {"operation": "executeQuery", "query": "UPDATE aprobaciones SET estado = $2, aprobador = $3, cerrada_en = now(), cerrada_por = 'persona' WHERE id = $1 AND estado = 'pendiente' AND $2 IN ('aprobada', 'rechazada') RETURNING id, estado, url_reanudar;", "options": {"queryReplacement": "={{ [$json.body.id_aprobacion, $json.body.decision, $json.body.aprobador] }}"}},
        "id": "0b1c7600-0000-4000-8000-000000000009",
        "name": "Registrar decisión si sigue pendiente",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [220, 300],
        "alwaysOutputData": true,
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG01", "name": "Postgres TL aprobaciones"}}
      },
      {
        "parameters": {"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "c7600001", "leftValue": "={{ $json.id }}", "rightValue": "", "operator": {"type": "number", "operation": "exists", "singleValue": true}}], "combinator": "and"}, "options": {}},
        "id": "0b1c7600-0000-4000-8000-000000000010",
        "name": "¿Llegó a tiempo?",
        "type": "n8n-nodes-base.if",
        "typeVersion": 2.2,
        "position": [440, 300]
      },
      {
        "parameters": {"method": "POST", "url": "={{ $json.url_reanudar }}", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ estado: $json.estado }) }}", "options": {"timeout": 10000}},
        "id": "0b1c7600-0000-4000-8000-000000000011",
        "name": "Reanudar la espera",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [660, 200]
      },
      {
        "parameters": {"method": "POST", "url": "={{ $env.TL_SLACK_WEBHOOK_ALERTAS }}", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: 'Decisión tardía o repetida: la aprobación ' + $('Botón de decisión').item.json.body.id_aprobacion + ' ya estaba cerrada; no se cambió nada.' }) }}", "options": {"timeout": 10000}},
        "id": "0b1c7600-0000-4000-8000-000000000012",
        "name": "Avisar decisión tardía",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [660, 400]
      }
    ],
    "connections": {
      "Pedir aprobación": {"main": [[{"node": "Crear aprobación", "type": "main", "index": 0}]]},
      "Crear aprobación": {"main": [[{"node": "Avisar a quien aprueba", "type": "main", "index": 0}]]},
      "Avisar a quien aprueba": {"main": [[{"node": "Esperar decisión", "type": "main", "index": 0}]]},
      "Esperar decisión": {"main": [[{"node": "Caducar si sigue pendiente", "type": "main", "index": 0}]]},
      "Caducar si sigue pendiente": {"main": [[{"node": "Leer estado final", "type": "main", "index": 0}]]},
      "Leer estado final": {"main": [[{"node": "Responder con contrato v2", "type": "main", "index": 0}]]},
      "Botón de decisión": {"main": [[{"node": "Registrar decisión si sigue pendiente", "type": "main", "index": 0}]]},
      "Registrar decisión si sigue pendiente": {"main": [[{"node": "¿Llegó a tiempo?", "type": "main", "index": 0}]]},
      "¿Llegó a tiempo?": {"main": [[{"node": "Reanudar la espera", "type": "main", "index": 0}], [{"node": "Avisar decisión tardía", "type": "main", "index": 0}]]}
    },
    "settings": {"executionOrder": "v1", "timezone": "America/Mexico_City", "errorWorkflow": "EJEMPLO-NO-REAL-ERR"},
    "pinData": {},
    "meta": {"templateCredsSetupCompleted": true}
  },
  {
    "name": "TL Publicación multired v2",
    "nodes": [
      {
        "parameters": {"rule": {"interval": [{"field": "minutes", "minutesInterval": 15}]}},
        "id": "0b1c7601-0000-4000-8000-000000000001",
        "name": "Cada 15 minutos",
        "type": "n8n-nodes-base.scheduleTrigger",
        "typeVersion": 1.2,
        "position": [0, 0]
      },
      {
        "parameters": {"operation": "executeQuery", "query": "SELECT p.id, p.pieza, p.red, p.texto_final, p.huella, p.clave_idempotencia FROM publicaciones p WHERE p.estado = 'programado' AND p.hora_programada <= now() AND NOT EXISTS (SELECT 1 FROM registro_publicaciones r WHERE r.clave_idempotencia = p.clave_idempotencia) ORDER BY p.hora_programada LIMIT 10;", "options": {}},
        "id": "0b1c7601-0000-4000-8000-000000000002",
        "name": "Piezas por publicar",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [220, 0],
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG02", "name": "Postgres TL solo publicaciones"}}
      },
      {
        "parameters": {"source": "database", "workflowId": {"__rl": true, "value": "EJEMPLO-NO-REAL-APR2", "mode": "id"}, "workflowInputs": {"mappingMode": "defineBelow", "value": {"pieza": "={{ $json.pieza }}", "red": "={{ $json.red }}", "texto": "={{ $json.texto_final }}", "huella": "={{ $json.huella }}"}}, "options": {"waitForSubWorkflow": true}},
        "id": "0b1c7601-0000-4000-8000-000000000003",
        "name": "Pedir aprobación v2",
        "type": "n8n-nodes-base.executeWorkflow",
        "typeVersion": 1.2,
        "position": [440, 0]
      },
      {
        "parameters": {"rules": {"values": [{"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "s7600001", "leftValue": "={{ $json.estado }}", "rightValue": "aprobada", "operator": {"type": "string", "operation": "equals"}}], "combinator": "and"}, "renameOutput": true, "outputKey": "aprobada"}]}, "options": {"fallbackOutput": "extra", "renameFallbackOutput": "cualquier otro estado"}},
        "id": "0b1c7601-0000-4000-8000-000000000004",
        "name": "¿Estado de la aprobación?",
        "type": "n8n-nodes-base.switch",
        "typeVersion": 3.2,
        "position": [660, 0]
      },
      {
        "parameters": {"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "c7601001", "leftValue": "={{ $json.version_contrato }}", "rightValue": 2, "operator": {"type": "number", "operation": "equals"}}, {"id": "c7601002", "leftValue": "={{ $json.huella }}", "rightValue": "={{ $('Piezas por publicar').item.json.huella }}", "operator": {"type": "string", "operation": "equals"}}, {"id": "c7601003", "leftValue": "={{ $json.aprobador }}", "rightValue": "", "operator": {"type": "string", "operation": "notEmpty", "singleValue": true}}], "combinator": "and"}, "options": {}},
        "id": "0b1c7601-0000-4000-8000-000000000005",
        "name": "¿Contrato, huella y aprobador?",
        "type": "n8n-nodes-base.if",
        "typeVersion": 2.2,
        "position": [880, 0]
      },
      {
        "parameters": {"source": "database", "workflowId": {"__rl": true, "value": "EJEMPLO-NO-REAL-RED1", "mode": "id"}, "workflowInputs": {"mappingMode": "defineBelow", "value": {"pieza": "={{ $('Piezas por publicar').item.json.pieza }}", "red": "={{ $('Piezas por publicar').item.json.red }}"}}, "options": {"waitForSubWorkflow": true}},
        "id": "0b1c7601-0000-4000-8000-000000000006",
        "name": "Publicar por red",
        "type": "n8n-nodes-base.executeWorkflow",
        "typeVersion": 1.2,
        "position": [1100, 0]
      },
      {
        "parameters": {"operation": "executeQuery", "query": "INSERT INTO registro_publicaciones (clave_idempotencia, pieza, red, hora_publicada, id_publicacion, aprobador, estado_aprobacion) VALUES ($1, $2, $3, now(), $4, $5, 'aprobada') ON CONFLICT (clave_idempotencia) DO NOTHING;", "options": {"queryReplacement": "={{ [$('Piezas por publicar').item.json.clave_idempotencia, $('Piezas por publicar').item.json.pieza, $('Piezas por publicar').item.json.red, $json.id_publicacion, $('¿Estado de la aprobación?').item.json.aprobador] }}"}},
        "id": "0b1c7601-0000-4000-8000-000000000007",
        "name": "Registrar publicación",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [1320, 0],
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG02", "name": "Postgres TL solo publicaciones"}}
      },
      {
        "parameters": {"operation": "executeQuery", "query": "UPDATE publicaciones SET estado = 'retenida', motivo = 'aprobación no válida: ' || $2 WHERE id = $1;", "options": {"queryReplacement": "={{ [$('Piezas por publicar').item.json.id, $json.estado || 'sin estado'] }}"}},
        "id": "0b1c7601-0000-4000-8000-000000000008",
        "name": "Retener la pieza",
        "type": "n8n-nodes-base.postgres",
        "typeVersion": 2.6,
        "position": [1100, 260],
        "credentials": {"postgres": {"id": "EJEMPLO-NO-REAL-PG02", "name": "Postgres TL solo publicaciones"}}
      },
      {
        "parameters": {"method": "POST", "url": "={{ $env.TL_SLACK_WEBHOOK_ALERTAS }}", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: 'Pieza retenida ' + $('Piezas por publicar').item.json.pieza + ': la aprobación no es válida. Pida una nueva aprobación.' }) }}", "options": {"timeout": 10000}},
        "id": "0b1c7601-0000-4000-8000-000000000009",
        "name": "Avisar en Slack",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4.2,
        "position": [1320, 260]
      },
      {
        "parameters": {"errorMessage": "={{ 'Publicación detenida: la pieza ' + $('Piezas por publicar').item.json.pieza + ' no tiene una aprobación válida.' }}"},
        "id": "0b1c7601-0000-4000-8000-000000000010",
        "name": "Detener sin aprobación",
        "type": "n8n-nodes-base.stopAndError",
        "typeVersion": 1,
        "position": [1540, 260]
      }
    ],
    "connections": {
      "Cada 15 minutos": {"main": [[{"node": "Piezas por publicar", "type": "main", "index": 0}]]},
      "Piezas por publicar": {"main": [[{"node": "Pedir aprobación v2", "type": "main", "index": 0}]]},
      "Pedir aprobación v2": {"main": [[{"node": "¿Estado de la aprobación?", "type": "main", "index": 0}]]},
      "¿Estado de la aprobación?": {"main": [[{"node": "¿Contrato, huella y aprobador?", "type": "main", "index": 0}], [{"node": "Retener la pieza", "type": "main", "index": 0}]]},
      "¿Contrato, huella y aprobador?": {"main": [[{"node": "Publicar por red", "type": "main", "index": 0}], [{"node": "Retener la pieza", "type": "main", "index": 0}]]},
      "Publicar por red": {"main": [[{"node": "Registrar publicación", "type": "main", "index": 0}]]},
      "Retener la pieza": {"main": [[{"node": "Avisar en Slack", "type": "main", "index": 0}]]},
      "Avisar en Slack": {"main": [[{"node": "Detener sin aprobación", "type": "main", "index": 0}]]}
    },
    "settings": {"executionOrder": "v1", "timezone": "America/Mexico_City", "executionTimeout": 9000, "saveDataSuccessExecution": "all", "errorWorkflow": "EJEMPLO-NO-REAL-ERR"},
    "pinData": {},
    "meta": {"templateCredsSetupCompleted": true}
  }
]

# Lectura de los workflows v2 con nodos_desde_n8n, comprobaciones de falla cerrada y dibujo en Python:
exportados = json.loads((carpeta / 'flujos' / 'n8n' / 'aprobaciones_y_publicacion_v2.json').read_text(encoding = 'utf-8'))
flujos = {wf['name']: wf for wf in exportados}

FORMAS = {'scheduleTrigger': ('disparador', '#1f9d55'), 'webhook': ('disparador', '#1f9d55'),
          'executeWorkflowTrigger': ('disparador', '#1f9d55'), 'postgres': ('accion', '#2a78d6'),
          'httpRequest': ('accion', '#2a78d6'), 'set': ('accion', '#2a78d6'), 'executeWorkflow': ('accion', '#2a78d6'),
          'wait': ('humano', '#8a8a8a'), 'if': ('decision', '#eb6834'), 'switch': ('decision', '#eb6834'),
          'stopAndError': ('error', '#d62728')}
HUMANOS = {'Pedir aprobación v2'}                       # subflujo que espera a una persona

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'], tipo, salida) for o, s in wf['connections'].items()
               for tipo, lista in s.items() for salida, destinos in enumerate(lista) for d in destinos]
    return nodos, aristas

def alcanzables(aristas, origen, salida = None):
    # Nodos a los que se llega desde un nodo (y, si se indica, desde una de sus salidas):
    pendientes = [d for o, d, _, s in aristas if o == origen and (salida is None or s == salida)]
    vistos = set()
    while pendientes:
        n = pendientes.pop()
        if n not in vistos:
            vistos.add(n)
            pendientes += [d for o, d, _, _ in aristas if o == n]
    return vistos

def dibujar_flujo(nodos, aristas, titulo, rotulos):
    fig, ax = plt.subplots(figsize = (15, 5.6))
    pos = {n['id']: (n['x'], n['y']) for n in nodos}
    for n in nodos:
        forma, color = ('humano', '#8a8a8a') if n['id'] in HUMANOS else FORMAS[n['tipo']]
        x, y = n['x'], n['y']
        if forma == 'decision':
            ax.add_patch(Polygon([(x - 0.9, y), (x, y + 0.55), (x + 0.9, y), (x, y - 0.55)], facecolor = color,
                                 edgecolor = 'white', linewidth = 2))
        elif forma == 'humano':
            ax.add_patch(RegularPolygon((x, y), 6, radius = 0.72, orientation = np.pi / 2, facecolor = color,
                                        edgecolor = 'white', linewidth = 2))
        else:
            estilo = 'round,pad=0.05,rounding_size=0.35' if forma == 'disparador' else 'round,pad=0.05'
            ax.add_patch(FancyBboxPatch((x - 0.85, y - 0.4), 1.7, 0.8, boxstyle = estilo,
                                        facecolor = color, edgecolor = 'white', linewidth = 2))
        etiqueta = textwrap.fill(n['id'], 12 if forma in ('decision', 'humano') else 18, break_long_words = False)
        ax.text(x, y + 0.08, etiqueta, ha = 'center', va = 'center', color = 'white', fontsize = 8.3)
        ax.text(x, y - 0.3, n['tipo'], ha = 'center', va = 'center', color = 'white', fontsize = 6.5)
    for o, d, _, salida in aristas:
        (x1, y1), (x2, y2) = pos[o], pos[d]
        if abs(y1 - y2) < 0.01:
            ax.add_patch(FancyArrowPatch((x1 + 0.92, y1), (x2 - 0.92, y2), arrowstyle = '-|>', mutation_scale = 13,
                                         color = '#52514e', linewidth = 1.4))
        else:
            ax.add_patch(FancyArrowPatch((x1, y1 - 0.56), (x2 - 0.92, y2), arrowstyle = '-|>', mutation_scale = 13,
                                         color = '#52514e', linewidth = 1.4,
                                         connectionstyle = 'angle,angleA=90,angleB=0,rad=0.1'))
    for nodo, dx, dy, texto in rotulos:
        ax.text(pos[nodo][0] + dx, pos[nodo][1] + dy, texto, fontsize = 9, color = '#52514e')
    xs = [p[0] for p in pos.values()]
    ys = [p[1] for p in pos.values()]
    ax.set_xlim(min(xs) - 1, max(xs) + 1)
    ax.set_ylim(min(ys) - 0.9, max(ys) + 0.9)
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_title(titulo, fontsize = 14)
    return ax

for nombre, wf in flujos.items():
    nodos, aristas = nodos_desde_n8n(wf)
    nombres = {n['id'] for n in nodos}
    print(f"{nombre}: {len(nodos)} nodos | {len(aristas)} conexiones | destinos inexistentes:",
          [d for _, d, _, _ in aristas if d not in nombres] or 'ninguno')
apr = flujos['TL Aprobaciones v2']
consultas = {n['name']: n['parameters']['query'] for n in apr['nodes'] if n['type'].endswith('postgres')}
for nombre, q in consultas.items():
    if q.startswith('UPDATE'):
        print(f'  {nombre}: condicional = {"estado = " + chr(39) + "pendiente" + chr(39) in q} | RETURNING = {"RETURNING" in q}')
pub = flujos['TL Publicación multired v2']
nodos, aristas = nodos_desde_n8n(pub)
switch = next(n for n in pub['nodes'] if n['type'].endswith('switch'))
reglas = [c['rightValue'] for r in switch['parameters']['rules']['values'] for c in r['conditions']['conditions']]
print('Switch: casos =', reglas, '| salida de respaldo =', switch['parameters']['options']['fallbackOutput'])
print('Desde la salida de respaldo se llega a:', sorted(alcanzables(aristas, switch['name'], salida = 1)))
print('¿La salida de respaldo puede llegar a "Publicar por red"?', 'Publicar por red' in alcanzables(aristas, switch['name'], 1))
print('Caminos a "Publicar por red" que no pasan por el caso "aprobada":',
      ['Publicar por red' in alcanzables(aristas, o, s) for o, d, _, s in aristas if o == switch['name'] and s > 0])
texto_json = json.dumps(exportados, ensure_ascii = False)
print('Claves o URL de webhook escritas:', [p for p in ['hooks.slack.com', 'Bearer ', 'x-api-key', 'EAAG'] if p in texto_json] or 'ninguna')
dibujar_flujo(nodos, aristas, f"{pub['name']}, leído del JSON exportado",
              [('¿Estado de la aprobación?', 0.55, 0.45, 'aprobada'), ('¿Estado de la aprobación?', 0.12, -1.05, 'cualquier otro estado'),
               ('¿Contrato, huella y aprobador?', 0.55, 0.45, 'sí'), ('¿Contrato, huella y aprobador?', 0.12, -1.05, 'no')])
plt.tight_layout()
plt.show()

# Pruebas de regresión: tabla de verdad, 500 intercalados aleatorios y comprobación de "aprobación válida" en Python:
def simular_intercalado(version, decision, llegada):
    # El plazo vence en t = 0; llegada es el segundo en que el webhook del botón escribe (None si nadie pulsa):
    estado, historial, visto = 'pendiente', [], None
    eventos = sorted([(0.0, 'reloj')] + ([(llegada, 'boton')] if llegada is not None else []))
    for t, quien in eventos:
        nuevo = 'caducada' if quien == 'reloj' else decision
        if quien == 'reloj' and visto is not None:
            continue                                        # la espera ya se reanudó: no hay caducidad
        if version == 'v1' or estado == 'pendiente':        # v1 escribe siempre; v2 solo si sigue pendiente
            historial.append((estado, nuevo))
            estado = nuevo
            if visto is None:
                visto = nuevo                               # lo primero que ocurre es lo que recibe el flujo
        elif visto is None:
            visto = estado
    decidir = decidir_publicacion_abierta if version == 'v1' else decidir_publicacion_cerrada
    publica = decidir(visto) == 'publicar'
    return {'publica_sin_aprobada': publica and visto != 'aprobada',
            'registro_contradice': estado != visto,
            'transicion_prohibida': any(not transicion_valida(a, d) for a, d in historial)}

INTERCALADOS = 500
decisiones = rng.choice(['aprobada', 'rechazada', None], size = INTERCALADOS, p = [0.6, 0.25, 0.15])
llegadas = rng.uniform(-10, 10, size = INTERCALADOS)           # segundos respecto del plazo
pruebas = []
for version in ['v1', 'v2']:
    tv = tabla_verdad[f'{version} correcta'].all()
    for d, t in zip(decisiones, llegadas):
        r = simular_intercalado(version, d, None if d is None else round(float(t), 3))
        pruebas.append({'version': version, 'tabla de verdad': tv, **r})
pruebas = pd.DataFrame(pruebas)
resumen = pruebas.groupby('version').agg(
    publica_sin_aprobada = ('publica_sin_aprobada', 'sum'), registro_contradice = ('registro_contradice', 'sum'),
    transicion_prohibida = ('transicion_prohibida', 'sum'))
resumen['casos fallidos'] = pruebas.assign(f = pruebas[['publica_sin_aprobada', 'registro_contradice', 'transicion_prohibida']]
                                            .any(axis = 1)).groupby('version')['f'].sum()
resumen['casos aprobados'] = INTERCALADOS - resumen['casos fallidos']
print('Decisiones simuladas:', pd.Series(decisiones).fillna('nadie pulsa').value_counts().to_dict())
print('Tabla de verdad completa: v1', bool(tabla_verdad['v1 correcta'].all()), '| v2', bool(tabla_verdad['v2 correcta'].all()))
print(resumen.to_string())
veredicto = {v: 'APROBADA' if fila['casos fallidos'] == 0 and tabla_verdad[f'{v} correcta'].all() else 'FALLA'
             for v, fila in resumen.iterrows()}
print('Veredicto de la suite:', veredicto)

# Generación del análisis posterior sin culpables en incidentes/2026-04-16_publicacion_sin_aprobacion.md en Python:
acciones = pd.DataFrame([
    ('Retirar las dos piezas y honrar el 2x1 a quien lo pida', 'corregir', 'Don Ernesto', '2026-04-18', '9 pays entregados y registrados'),
    ('Publicar una aclaración honesta en las dos redes', 'corregir', 'Valeria', '2026-04-17', 'Aclaración aprobada por Don Ernesto'),
    ('TL Publicación multired v2: solo "aprobada" publica', 'prevenir', 'Valeria', '2026-04-17', 'Bloque 9 en verde en cada cambio'),
    ('TL Aprobaciones v2: escritura condicional y estado terminal inmutable', 'prevenir', 'Valeria', '2026-04-20', '500 intercalados sin fallos'),
    ('Versión del contrato en la respuesta y lista cerrada de estados', 'prevenir', 'Valeria', '2026-04-20', 'Un estado nuevo detiene y avisa'),
    ('Alerta inmediata si una pieza sale sin "aprobada"', 'detectar', 'Valeria', '2026-04-21', 'Prueba con pieza caducada avisa en 1 min'),
    ('Aviso de decisión tardía a #alertas', 'detectar', 'Valeria', '2026-04-21', 'Botón pulsado tras el plazo avisa'),
    ('Revisión de contratos al cambiar un sub-workflow', 'prevenir', 'Don Ernesto', '2026-04-24', 'Lista firmada en el cambio siguiente'),
], columns = ['accion', 'tipo', 'dueno', 'fecha', 'verificacion'])
filas = linea[['hora_txt', 'fuente', 'evento']].values.tolist()
documento = '\n'.join([
    '# Análisis posterior sin culpables: publicación sin aprobación válida (16 de abril de 2026)',
    '', 'Incidente ficticio con fines didácticos. Sin datos personales de clientas.', '',
    '## Resumen',
    'Una promoción rechazada por Don Ernesto se publicó en Instagram y Facebook a las 20:00:01 y estuvo visible 42 minutos.',
    'La aprobación caducó un segundo antes de que llegara el rechazo, y el flujo publicaba cualquier estado distinto de "rechazada".', '',
    '## Impacto',
    f'- 2 publicaciones durante 42 min; 9 clientas pidieron el 2x1: {9 * TICKET_PAY} MXN ({9 * TICKET_PAY / MXN_POR_USD:.2f} USD).',
    '- Detección: una clienta a los 35 min; el sistema, a las 12 h (panel de la mañana).', '',
    '## Línea de tiempo'] + [f'- {h} | {f} | {e}' for h, f, e in filas] + ['',
    '## Causas',
    '- Disparador: carrera entre el reloj de caducidad y el webhook del botón (ventana de 4 s).',
    '- Causa: la salida por defecto del switch publicaba; el estado "caducada" (Día 74) no existía al diseñar el flujo (Día 72).',
    '- Contribuyentes: escrituras sin guardia; la base aceptó caducada -> rechazada; la prueba del Día 72 miraba que existiera una aprobación, no su estado.', '',
    '## Lo que salió bien',
    '- Don Ernesto decidió a tiempo y por el canal correcto.',
    '- Valeria retiró las piezas en 7 minutos desde el aviso de la clienta.',
    '- El registro común del Día 75 permitió reconstruir cada segundo.', '',
    '## Acciones'] + [f'- [{t}] {a} | {d} | {f} | {v}' for a, t, d, f, v in acciones.values])
ruta_doc = carpeta / 'incidentes' / '2026-04-16_publicacion_sin_aprobacion.md'
ruta_doc.parent.mkdir(exist_ok = True)
ruta_doc.write_text(documento + '\n', encoding = 'utf-8')
print(f'Escrito {ruta_doc.as_posix()} ({len(documento.splitlines())} líneas). Primeras líneas:')
print('\n'.join(documento.splitlines()[:16]))
print('Acciones por tipo:', acciones['tipo'].value_counts().to_dict(), '| por dueño:', acciones['dueno'].value_counts().to_dict())