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

# Importaciones base, semilla de la serie, fecha de la auditoría y carpeta del día en Python:
import warnings
warnings.filterwarnings('ignore')
import json
import math
import re
from collections import Counter, defaultdict
from datetime import date, timedelta
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle, Circle, Patch

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 170)
pd.set_option('display.max_colwidth', 44)
carpeta = Path('trigo_lento') / 'dia_80'
carpeta.mkdir(parents = True, exist_ok = True)
hoy = date(2026, 4, 21)
REVISION_MENSUAL, REVISION_TRIMESTRAL = date(2026, 5, 4), date(2026, 7, 6)    # calendario de gobierno del Día 79
DIAS = ['lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo']

def fecha_dia(n):                                         # fecha de publicación del Día n de la serie
    return date(2026, 2, 1) + timedelta(days = n - 1)

print('numpy', np.__version__, '| pandas', pd.__version__)
print(f'Auditoría: {DIAS[hoy.weekday()]} {hoy:%d/%m/%Y} | próxima revisión mensual: {REVISION_MENSUAL:%d/%m} | '
      f'trimestral (precios, permisos y credenciales): {REVISION_TRIMESTRAL:%d/%m}')

# Extracción de las credenciales referenciadas en los JSON exportados y unión con las cuentas humanas en Python:
def modulos_make(flujo):                                  # recorre módulos, rutas de routers y manejadores
    for m in flujo:
        yield m
        for manejador in m.get('onerror') or []:
            yield manejador
        for ruta in m.get('routes') or []:
            yield from modulos_make(ruta['flow'])

def leer_exportacion(ruta):
    datos = json.loads(ruta.read_text(encoding = 'utf-8'))
    for wf in (datos if isinstance(datos, list) else [datos]):
        if isinstance(wf, dict) and isinstance(wf.get('flow'), list):
            yield 'Make', wf
        elif isinstance(wf, dict) and isinstance(wf.get('nodes'), list) and 'connections' in wf:
            yield 'n8n', wf

VERSION = re.compile(r'\s+v(\d+(?:\.\d+)?)$')
def proceso_y_version(nombre):
    m = VERSION.search(nombre)
    return VERSION.sub('', nombre).strip(), tuple(int(x) for x in m.group(1).split('.')) if m else (1,)

# Los mismos criterios del Día 79: última versión de cada proceso de Trigo Lento, sin sustituidos ni retirados.
SUSTITUIDOS = {'TL Formulario a hoja', 'TL Pedidos WhatsApp'}
RETIRADOS = {'TL Importación histórica', 'TL Lote de importación'}
leidos = []
for ruta in sorted(Path('trigo_lento').glob('dia_*/flujos/*/*.json'), key = lambda r: (int(r.parts[1][4:]), r.name)):
    for plataforma, wf in leer_exportacion(ruta):
        if wf['name'].startswith('TL ') and not re.search(r'fragmento|borrador', wf['name']):
            proceso, version = proceso_y_version(wf['name'])
            leidos.append({'proceso': proceso, 'version': version, 'plataforma': plataforma, 'dia': int(ruta.parts[1][4:]),
                           'nombre': wf['name'], 'wf': wf})
exportes = pd.DataFrame(leidos)
ultimas = exportes.sort_values(['version', 'dia']).groupby('proceso').tail(1)
activos = ultimas[~ultimas.proceso.isin(SUSTITUIDOS | RETIRADOS)].sort_values('dia').reset_index(drop = True)

# Credenciales que nombran los nodos de n8n y conexiones que nombran los módulos de Make:
referencias = []
for fila in activos.itertuples():
    if fila.plataforma == 'n8n':
        for n in fila.wf['nodes']:
            for tipo, c in (n.get('credentials') or {}).items():
                referencias.append({'flujo': fila.nombre, 'plataforma': 'n8n', 'credencial': c['name'], 'tipo_nodo': tipo})
    else:
        for m in modulos_make(fila.wf['flow']):
            if '__IMTCONN__' in (m.get('parameters') or {}):
                referencias.append({'flujo': fila.nombre, 'plataforma': 'Make', 'credencial': 'conexión ' + m['module'].split(':')[0],
                                    'tipo_nodo': m['module']})
referencias = pd.DataFrame(referencias).drop_duplicates(['flujo', 'credencial'])
print(f'Flujos activos: {len(activos)} ({activos.plataforma.value_counts().to_dict()}) | referencias a credenciales: {len(referencias)} | '
      f'nombres distintos: {referencias.credencial.nunique()}')
print(referencias.groupby('credencial').flujo.agg(['count', lambda s: ', '.join(x.replace('TL ', '') for x in s)])
      .set_axis(['flujos', 'cuáles'], axis = 1).sort_values('flujos', ascending = False).to_string())

# Inventario completo (los datos de dueño, cuenta, alcance y fechas los declaró Valeria; las fechas son el Día en que se creó):
INVENTARIO = [  # id, nombre, sistema, tipo, dueño, cuenta, alcance concedido, creada (Día o fecha), caducidad propia en días, dónde se guarda
    ('C01', 'Clave de Claude (producción)', 'Anthropic', 'clave de API', 'Valeria', 'negocio', 'espacio Default, sin tope propio', 2, None, 'credencial de n8n y llavero de Make'),
    ('C02', 'Clave de Claude (evaluación)', 'Anthropic', 'clave de API', 'Valeria', 'negocio', 'misma clave que C01', 70, None, 'credencial de n8n'),
    ('C03', 'Clave de Voyage AI', 'Voyage AI', 'clave de API', 'Valeria', 'negocio', 'embeddings', 68, None, 'variable de entorno del indexador'),
    ('C04', 'Token de usuario del sistema (Cloud API)', 'Meta', 'token OAuth', 'Valeria', 'negocio', 'mensajes, gestión y business_management', 48, 60, 'credencial de n8n'),
    ('C05', 'Secreto de la aplicación de Meta', 'Meta', 'secreto de firma', 'Valeria', 'negocio', 'firma X-Hub-Signature-256', 48, None, 'variable de entorno de n8n'),
    ('C06', 'Token del bot de Slack', 'Slack', 'token OAuth', 'Valeria', 'negocio', '7 alcances', 50, None, 'credencial de n8n'),
    ('C07', 'Secreto de firma de Slack', 'Slack', 'secreto de firma', 'Valeria', 'negocio', 'firma X-Slack-Signature', 50, None, 'variable de entorno de n8n'),
    ('C08', 'URL del webhook entrante de Slack', 'Slack', 'URL de webhook', 'Valeria', 'negocio', 'publicar en #alertas', 75, None, 'credencial de n8n'),
    ('C09', 'Integración de Notion', 'Notion', 'token de integración', 'Valeria', 'personal', '14 páginas del espacio', 68, None, 'variable de entorno del indexador'),
    ('C10', 'OAuth de Gmail (mayoristas)', 'Google', 'token OAuth', 'Valeria', 'negocio', 'gmail.modify', 47, None, 'credencial de n8n'),
    ('C11', 'OAuth de Google Sheets', 'Google', 'token OAuth', 'Valeria', 'negocio', 'drive.file', 22, None, 'conexión de Make y credencial de n8n'),
    ('C12', 'Token de página de Meta (Facebook e Instagram)', 'Meta', 'token OAuth', 'Valeria', 'negocio', '4 permisos de página', 72, 60, 'credencial de n8n'),
    ('C13', 'Token de LinkedIn (página)', 'LinkedIn', 'token OAuth', 'Valeria', 'personal', '3 alcances', 72, 60, 'credencial de n8n'),
    ('C14', 'Clave de FacturaFácil', 'FacturaFácil', 'clave de API', 'Valeria', 'negocio', 'emitir, consultar y cancelar', 40, None, 'credencial de n8n'),
    ('C15', 'Token del servidor MCP del inventario', 'servidor propio', 'token de servicio', 'Joaquín', 'negocio', '3 herramientas', 62, None, 'variable de entorno (MCP_TOKEN_OBRADOR)'),
    ('C16', 'Clave de API de n8n', 'n8n', 'clave de API', 'Valeria', 'negocio', 'API pública completa', 42, None, 'gestor de contraseñas'),
    ('C17', 'N8N_ENCRYPTION_KEY', 'n8n', 'clave de cifrado', 'Valeria', 'negocio', 'cifra todas las credenciales', 34, None, '.env del servidor y gestor (con huella)'),
    ('C18', 'Contraseñas de Postgres (4 roles)', 'Postgres', 'contraseña', 'Valeria', 'negocio', 'n8n, n8n_lectura, n8n_lotes, n8n_registro', 34, None, '.env y credenciales de n8n'),
    ('C19', 'Llave SSH del servidor', 'servidor', 'llave SSH', 'Valeria', 'negocio', 'root', 34, None, 'portátil de Valeria'),
    ('C20', 'Clave de API de Make', 'Make', 'clave de API', 'Valeria', 'negocio', '4 alcances', 42, None, 'gestor de contraseñas'),
    ('C21', 'Auth Token de Twilio', 'Twilio', 'clave de API', 'Valeria', 'negocio', 'enviar y recibir mensajes', 16, None, 'credencial de n8n y conexión de Make'),
    ('C22', 'Clave del formulario web', 'formulario', 'secreto de firma', 'Valeria', 'negocio', 'autenticar el webhook', 11, None, 'credencial de n8n y conexión de Make'),
    ('C23', 'Contraseña del correo de avisos (SMTP)', 'correo', 'contraseña', 'Valeria', 'negocio', 'enviar avisos internos', 18, None, 'credencial de n8n'),
    ('C24', 'Cuenta del proveedor del servidor', 'proveedor del servidor', 'contraseña', 'Valeria', 'negocio', 'crear y borrar servidores', 34, None, 'gestor de contraseñas'),
    ('C25', 'Cuenta del registrador del dominio', 'dominio', 'contraseña', 'Don Ernesto', 'personal', 'DNS y renovación', date(2019, 8, 15), None, 'libreta de Don Ernesto'),
    ('C26', 'Token del repositorio de flujos', 'GitHub', 'clave de API', 'Valeria', 'negocio', 'contents, workflows, metadata', 42, 90, 'gestor de contraseñas'),
]
inventario = pd.DataFrame(INVENTARIO, columns = ['id', 'nombre', 'sistema', 'tipo', 'dueno', 'cuenta', 'alcance', 'creada', 'caducidad', 'guardado'])
inventario['creada'] = inventario.creada.map(lambda d: d if isinstance(d, date) else fecha_dia(d))
inventario['rotada'] = pd.NaT                               # ninguna credencial tiene una rotación registrada
inventario['pista'] = inventario.id.map({'C01': 'a7Qx', 'C02': 'a7Qx'}).fillna('')   # últimos 4 caracteres que muestra la consola

# Unión: cada nombre de credencial de los JSON apunta a una fila del inventario:
MAPA = [(r'^(Claude|Anthropic)', 'C01'), (r'^Postgres', 'C18'), (r'^Twilio|conexión twilio', 'C21'), (r'^Gmail', 'C10'),
        (r'^Hojas? de Trigo|conexión google-sheets', 'C11'), (r'^Meta TL token de página', 'C12'), (r'^Slack bot', 'C06'),
        (r'^FacturaFácil', 'C14'), (r'Cloud API', 'C04'), (r'^LinkedIn', 'C13'), (r'^Correo de avisos', 'C23'),
        (r'^Clave del formulario', 'C22'), (r'conexión http', 'C01'), (r'conexión gmail|conexión google-email', 'C10')]
def identificar(nombre, flujo):
    ident = next((i for patron, i in MAPA if re.search(patron, nombre)), None)
    return 'C02' if ident == 'C01' and 'Evaluación' in flujo else ident
referencias['id'] = [identificar(c, f) for c, f in zip(referencias.credencial, referencias.flujo)]
sin_fila = referencias[referencias.id.isna()]
print('Referencias sin fila en el inventario:', sorted(sin_fila.credencial.unique()) or 'ninguna')
usos = referencias.groupby('id').flujo.agg(lambda s: sorted(set(s)))
inventario['flujos'] = inventario.id.map(usos).map(lambda v: v if isinstance(v, list) else [])
inventario['n_flujos'] = inventario.flujos.str.len()
inventario['nombres_n8n'] = inventario.id.map(referencias[referencias.plataforma == 'n8n'].groupby('id').credencial.nunique()).fillna(0).astype(int)
print(inventario[['id', 'nombre', 'tipo', 'n_flujos', 'nombres_n8n', 'dueno', 'cuenta', 'creada', 'caducidad', 'guardado']]
      .assign(creada = inventario.creada.map(lambda d: f'{d:%d/%m/%Y}'), caducidad = inventario.caducidad.map(lambda c: f'{int(c)} días' if pd.notna(c) else '')).to_string(index = False))
print(f'Credenciales: {len(inventario)} | en flujos: {int((inventario.n_flujos > 0).sum())} | de infraestructura y consolas: '
      f'{int((inventario.n_flujos == 0).sum())} | en cuentas personales: {int((inventario.cuenta == "personal").sum())} | '
      f'con dueño distinto de Valeria: {int((inventario.dueno != "Valeria").sum())}')
duplicadas = inventario[inventario.pista.ne('') & inventario.duplicated('pista', keep = False)]
print('Misma pista en la consola (misma clave):', ' = '.join(duplicadas.id), '->', ', '.join(f.replace('TL ', '') for f in duplicadas.flujos.sum()))
print(f'Flujos de n8n con credenciales de Postgres bajo {inventario.set_index("id").nombres_n8n["C18"]} nombres distintos; '
      f'Claude bajo {inventario.set_index("id").nombres_n8n["C01"] + inventario.set_index("id").nombres_n8n["C02"]}')
inventario.drop(columns = ['flujos']).assign(flujos = inventario.flujos.str.join('; ')).to_csv(carpeta / 'inventario_credenciales.csv', index = False)

# Estado de rotación frente a la política por tipo y alertas de caducidad a 30 días en Python:
POLITICA = {'clave de API': 90, 'token de servicio': 90, 'token de integración': 90, 'secreto de firma': 180, 'URL de webhook': 180,
            'contraseña': 180, 'llave SSH': 365, 'clave de cifrado': None, 'token OAuth': None}   # None: caducidad propia o del proveedor
inventario['ultimo_cambio'] = inventario.rotada.fillna(pd.Series(pd.to_datetime(inventario.creada))).dt.date
inventario['dias'] = (hoy - inventario.ultimo_cambio).map(lambda d: d.days)
inventario['plazo'] = [int(c) if pd.notna(c) else POLITICA[t] for t, c in zip(inventario.tipo, inventario.caducidad)]
inventario['vence'] = [u + timedelta(days = int(p)) if pd.notna(p) else None for u, p in zip(inventario.ultimo_cambio, inventario.plazo)]

def estado(v, tipo):
    if v is None:
        return 'sin rotación programada' if tipo == 'clave de cifrado' else 'renovado por el proveedor'
    if v < hoy:
        return 'vencida'
    if v <= hoy + timedelta(days = 30):
        return 'por vencer (30 días)'
    if v <= REVISION_TRIMESTRAL:
        return 'antes de la revisión trimestral'
    return 'vigente'
inventario['estado'] = [estado(v, t) for v, t in zip(inventario.vence, inventario.tipo)]
inventario['ultimo'] = inventario.ultimo_cambio.map(lambda d: f'{d:%d/%m/%Y}')
inventario['vence_txt'] = inventario.vence.map(lambda d: f'{d:%d/%m/%Y}' if d else '')
orden_estado = ['vencida', 'por vencer (30 días)', 'antes de la revisión trimestral', 'vigente', 'renovado por el proveedor', 'sin rotación programada']
tabla = inventario.sort_values(['estado', 'dias'], key = lambda s: s.map(orden_estado.index) if s.name == 'estado' else -s)
print(tabla[['id', 'nombre', 'tipo', 'ultimo', 'dias', 'plazo', 'vence_txt', 'estado']].assign(plazo = tabla.plazo.map(lambda p: f'{int(p)}' if pd.notna(p) else '')).to_string(index = False))
print('Por estado:', inventario.estado.value_counts().reindex(orden_estado).fillna(0).astype(int).to_dict())
print(f'Rotaciones registradas: {int(inventario.rotada.notna().sum())} de {len(inventario)} | mediana de días desde el último cambio: '
      f'{inventario.dias.median():.0f} | máximo: {inventario.dias.max()} ({inventario.loc[inventario.dias.idxmax(), "nombre"]})')
urgentes = inventario[inventario.estado.isin(['vencida', 'por vencer (30 días)'])]
print('Atender antes del', f'{REVISION_MENSUAL:%d/%m}:', '; '.join(f'{i} {n} ({v})' for i, n, v in zip(urgentes.id, urgentes.nombre, urgentes.vence_txt)))

COLOR_TIPO = {'clave de API': '#2a78d6', 'token OAuth': '#7b4fc9', 'secreto de firma': '#eb6834', 'contraseña': '#c0392b',
              'llave SSH': '#6b5b3e', 'clave de cifrado': '#1f8a5b', 'token de integración': '#b04bb3', 'token de servicio': '#b04bb3',
              'URL de webhook': '#8a8a8a'}
dib = inventario.sort_values('dias', ascending = True).reset_index(drop = True)
fig, ax = plt.subplots(figsize = (11, 8.6))
ys = np.arange(len(dib))
ax.barh(ys, dib.dias.clip(upper = 400), color = [COLOR_TIPO[t] for t in dib.tipo], height = 0.62)
for y, f in zip(ys, dib.itertuples()):
    if pd.notna(f.plazo):
        ax.plot([f.plazo, f.plazo], [y - 0.38, y + 0.38], color = '#c0392b' if f.dias > f.plazo else '#34332f', lw = 2.2)
    etiqueta = f'{f.dias} d' + (f' (>{f.dias - 400} recortado)' if f.dias > 400 else '') + (f', caduca el {f.vence:%d/%m}' if pd.notna(f.caducidad) else '')
    ax.text(max(min(f.dias, 400), f.plazo if pd.notna(f.plazo) else 0) + 4, y, etiqueta, va = 'center', fontsize = 8.6, color = '#34332f')
ax.set_yticks(ys, [f'{i} {n[:38]}' for i, n in zip(dib.id, dib.nombre)], fontsize = 8.8)
ax.axvline(30, color = '#c9c7c1', ls = ':', lw = 1)
ax.set_xlim(0, 470)
ax.set_xlabel('Días desde la creación o la última rotación (barra); marca vertical: plazo de la política o caducidad propia')
ax.set_title('26 credenciales de Trigo Lento: ninguna rotada; una vencida y tres por vencer en 30 días', fontsize = 12.5)
ax.legend(handles = [Patch(color = c, label = t) for t, c in COLOR_TIPO.items()], frameon = False, fontsize = 8.5, loc = 'lower right', ncol = 2)
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# Alcances concedidos frente a necesarios como diferencia de conjuntos por credencial en Python:
PAGINAS_NOTION = ['Base de conocimiento', 'Calendario editorial', 'Políticas', 'Fichas de producto', 'Avisos', 'Preguntas frecuentes',
                  'Proveedores', 'Horarios del personal', 'Nómina', 'Facturas 2025', 'Contratos', 'Actas de reuniones',
                  'Ideas de temporada', 'Mantenimiento del horno']
ALCANCES = {  # id: (concedidos, necesarios)
    'C01': ({'llamar a la API', 'espacio Default sin tope propio', 'uso en producción', 'uso en evaluación'},
            {'llamar a la API', 'espacio produccion con tope de 10.50 USD', 'uso en producción'}),
    'C04': ({'whatsapp_business_messaging', 'whatsapp_business_management', 'business_management'},
            {'whatsapp_business_messaging', 'whatsapp_business_management'}),
    'C06': ({'chat:write', 'chat:write.public', 'channels:read', 'channels:history', 'users:read', 'files:write', 'commands'},
            {'chat:write', 'channels:read', 'channels:history', 'commands'}),
    'C09': (set(PAGINAS_NOTION), {'Base de conocimiento', 'Calendario editorial'}),
    'C10': ({'leer', 'crear borradores', 'enviar', 'etiquetar', 'mover a la papelera'}, {'leer', 'crear borradores'}),
    'C11': ({'drive.file'}, {'drive.file'}),
    'C12': ({'pages_manage_posts', 'instagram_content_publish', 'pages_read_engagement', 'pages_manage_metadata'},
            {'pages_manage_posts', 'instagram_content_publish', 'pages_read_engagement'}),
    'C13': ({'w_organization_social', 'r_organization_social', 'r_organization_admin'}, {'w_organization_social'}),
    'C14': ({'emitir', 'consultar', 'cancelar'}, {'emitir', 'consultar'}),
    'C15': ({'consultar_existencias', 'consultar_consumo', 'registrar_movimiento'}, {'consultar_existencias', 'consultar_consumo'}),
    'C18': ({f'escritura en {f}' for f in ['Facturación', 'Slack operaciones', 'Alertas de flujos', 'Métricas de atención', 'Monitor de plantillas', 'Consulta de inventario']},
            {'escritura en Facturación', 'escritura en Slack operaciones', 'lectura en Alertas de flujos', 'lectura en Métricas de atención',
             'lectura en Monitor de plantillas', 'lectura en Consulta de inventario'}),
    'C19': ({'root'}, {'usuario con sudo'}),
    'C20': ({'scenarios:read', 'scenarios:write', 'connections:read', 'teams:write'}, {'scenarios:read'}),
    'C26': ({'contents:write', 'workflows:write', 'metadata:read'}, {'contents:write', 'metadata:read'}),
}
filas = []
for i, (concedidos, necesarios) in ALCANCES.items():
    sobran, faltan = concedidos - necesarios, necesarios - concedidos
    filas.append({'id': i, 'credencial': inventario.set_index('id').nombre[i][:34], 'concedidos': len(concedidos), 'necesarios': len(necesarios),
                  'sobran': len(sobran), 'faltan': len(faltan), 'indice': len(concedidos & necesarios) / len(concedidos),
                  'detalle': ', '.join(sorted(sobran))[:60]})
alcances = pd.DataFrame(filas).sort_values(['sobran', 'id'], ascending = [False, True])
print(alcances.to_string(index = False, formatters = {'indice': '{:.2f}'.format}))
print(f'Credenciales con alcances revisables: {len(alcances)} | permisos sobrantes: {alcances.sobran.sum()} | faltantes (cambios de rol): '
      f'{alcances.faltan.sum()} | con mínimo privilegio exacto: {int((alcances.sobran == 0).sum())} | índice medio: {alcances.indice.mean():.2f}')
print('Páginas de Notion que la integración ve sin necesitarlas:', ', '.join(sorted(ALCANCES['C09'][0] - ALCANCES['C09'][1])))

# Matriz de controles de las cuentas humanas de las consolas y mapa de calor en Python:
CUENTAS = [  # consola, titular, cuenta del negocio, doble factor, tipo de segundo factor, códigos de recuperación guardados, segundo administrador
    ('Meta Business Suite', 'Valeria', 1, 1, 'aplicación', 1, 1),
    ('Consola de Claude', 'Valeria', 1, 1, 'aplicación', 1, 0),
    ('Slack', 'Valeria', 1, 1, 'aplicación', 0, 1),
    ('Notion', 'Valeria', 0, 0, 'ninguno', 0, 0),
    ('Google (cuenta técnica)', 'Valeria', 1, 1, 'llave física', 1, 0),
    ('Proveedor del servidor', 'Valeria', 1, 1, 'SMS', 0, 0),
    ('Registrador del dominio', 'Don Ernesto', 0, 0, 'ninguno', 0, 0),
    ('GitHub', 'Valeria', 1, 1, 'aplicación', 1, 0),
    ('Make', 'Valeria', 1, 1, 'aplicación', 0, 0),
    ('FacturaFácil', 'Valeria', 1, 1, 'SMS', 0, 0),
    ('Voyage AI', 'Valeria', 1, 0, 'ninguno', 0, 0),
    ('LinkedIn (administrador de la página)', 'Valeria', 0, 1, 'SMS', 0, 0),
]
cuentas = pd.DataFrame(CUENTAS, columns = ['consola', 'titular', 'negocio', 'doble_factor', 'tipo', 'recuperacion', 'segundo_admin'])
VALOR_TIPO = {'llave física': 1.0, 'aplicación': 1.0, 'SMS': 0.5, 'ninguno': 0.0}   # NIST 800-63B-4: el SMS es el factor más débil
cuentas['factor_fuerte'] = cuentas.tipo.map(VALOR_TIPO)
CONTROLES = ['negocio', 'doble_factor', 'factor_fuerte', 'recuperacion', 'segundo_admin']
cuentas['puntos'] = cuentas[CONTROLES].sum(axis = 1)
print(cuentas[['consola', 'titular', 'negocio', 'doble_factor', 'tipo', 'recuperacion', 'segundo_admin', 'puntos']].to_string(index = False))
print('Cumplimiento por control:', {c: f'{cuentas[c].sum():.1f} de {len(cuentas)}' for c in CONTROLES})
print('Segundo factor por tipo:', cuentas.tipo.value_counts().to_dict(), '| consolas con 5 de 5:', int((cuentas.puntos == 5).sum()),
      '| con 2 o menos:', ', '.join(cuentas.consola[cuentas.puntos <= 2]))
print(f'Puntuación media: {cuentas.puntos.mean():.2f} de 5 | si Valeria no estuviera, consolas con otra persona que pueda entrar: '
      f'{int(cuentas.segundo_admin.sum())} de {len(cuentas)}')

matriz = cuentas[CONTROLES].to_numpy()
ETIQ = ['Cuenta del\nnegocio', 'Doble factor\nactivo', 'Segundo factor\nfuerte', 'Códigos de\nrecuperación', 'Segundo\nadministrador']
fig, ax = plt.subplots(figsize = (9.5, 6.8))
ax.imshow(matriz, cmap = plt.cm.RdYlGn, vmin = -0.15, vmax = 1.15, aspect = 'auto')
for i in range(len(cuentas)):
    for j, c in enumerate(CONTROLES):
        v = matriz[i, j]
        texto = cuentas.tipo[i] if c == 'factor_fuerte' else ('sí' if v == 1 else 'no')
        ax.text(j, i, texto, ha = 'center', va = 'center', fontsize = 9, color = '#34332f')
ax.set_xticks(range(len(CONTROLES)), ETIQ, fontsize = 9.5)
ax.set_yticks(range(len(cuentas)), [f'{c} ({p:.1f})' for c, p in zip(cuentas.consola, cuentas.puntos)], fontsize = 9.5)
ax.set_xticks(np.arange(-0.5, len(CONTROLES)), minor = True)
ax.set_yticks(np.arange(-0.5, len(cuentas)), minor = True)
ax.grid(which = 'minor', color = 'white', lw = 2)
ax.tick_params(which = 'minor', length = 0)
ax.set_title('Controles de las 12 consolas de Trigo Lento (puntos de 5 entre paréntesis)', fontsize = 12.5)
plt.tight_layout()
plt.show()

# Hallazgos con probabilidad, impacto, severidad y plazo de corrección calculado en Python:
HALLAZGOS = [  # id, descripción, evidencia, probabilidad, impacto, dueño
    ('H01', 'El token de la Cloud API caduca el 19/05 y nadie tiene un recordatorio ni un procedimiento', 'Tabla 1: C04 creado el 20/03 con 60 días', 5, 4, 'Valeria'),
    ('H02', 'El dominio está en la cuenta personal de Don Ernesto, sin doble factor y con contraseña de 2019', 'Bloque 5: registrador, 0 de 5 controles', 3, 5, 'Don Ernesto'),
    ('H03', 'Una sola clave de Claude para producción y evaluación, en el espacio Default sin tope propio', 'Bloque 2: pista a7Qx en C01 y C02; 10 flujos', 3, 4, 'Valeria'),
    ('H04', 'La integración de Notion es de la cuenta personal de Valeria y ve 14 páginas, incluida Nómina', 'Bloque 4: 12 páginas sobrantes', 3, 4, 'Valeria'),
    ('H05', 'Ninguna credencial se ha rotado desde que se creó', 'Bloque 3: 0 rotaciones de 26', 3, 3, 'Valeria'),
    ('H06', 'La llave SSH vive solo en el portátil de Valeria y 10 consolas no tienen segundo administrador', 'Bloque 5: segundo administrador en 2 de 12', 2, 4, 'Valeria'),
    ('H07', 'Segundo factor por SMS en 3 consolas y ninguno en Notion, el dominio y Voyage AI', 'Bloque 5: factor fuerte en 6 de 12', 3, 3, 'Valeria'),
    ('H08', 'Gmail concedido con gmail.modify cuando bastan leer y crear borradores', 'Bloque 4: C10, 3 capacidades sobrantes', 2, 3, 'Valeria'),
    ('H09', 'La credencial Postgres TL escribe en 4 flujos que solo leen', 'Bloque 4: C18', 2, 3, 'Valeria'),
    ('H10', 'El Auth Token de Twilio sigue vivo en 3 flujos cuyo proveedor se retiró el Día 79', 'Bloque 2: C21 en 3 flujos', 2, 2, 'Valeria'),
    ('H11', 'Códigos de recuperación guardados solo en 4 de 12 consolas', 'Bloque 5', 2, 3, 'Valeria'),
    ('H12', 'Exportaciones antiguas con un identificador real de conexión de Make y URLs de webhook de prueba', 'Bloque 7', 2, 2, 'Valeria'),
    ('H13', 'El bot de Slack tiene 3 alcances de más (files:write, users:read, chat:write.public)', 'Bloque 4: C06', 1, 2, 'Valeria'),
    ('H14', 'El token de LinkedIn depende de la cuenta personal de Valeria como administradora', 'Bloque 5: LinkedIn, cuenta personal', 2, 3, 'Valeria'),
]
PLAZOS = {'crítica': 1, 'alta': 7, 'media': 30, 'baja': 90}
def severidad(r):
    return 'crítica' if r >= 15 else 'alta' if r >= 9 else 'media' if r >= 4 else 'baja'
hallazgos = pd.DataFrame(HALLAZGOS, columns = ['id', 'descripcion', 'evidencia', 'P', 'I', 'dueno'])
hallazgos['R'] = hallazgos.P * hallazgos.I
hallazgos['severidad'] = hallazgos.R.map(severidad)
hallazgos['plazo_dias'] = hallazgos.severidad.map(PLAZOS)
hallazgos['limite'] = hallazgos.plazo_dias.map(lambda d: hoy + timedelta(days = d))
hallazgos['estado'] = 'abierto'
hallazgos = hallazgos.sort_values(['R', 'I', 'id'], ascending = [False, False, True]).reset_index(drop = True)
print(hallazgos[['id', 'descripcion', 'P', 'I', 'R', 'severidad', 'plazo_dias', 'limite', 'dueno']]
      .assign(descripcion = hallazgos.descripcion.str[:58], limite = hallazgos.limite.map(lambda d: f'{d:%d/%m}')).to_string(index = False))
print('Por severidad:', hallazgos.severidad.value_counts().reindex(PLAZOS).fillna(0).astype(int).to_dict(),
      f'| riesgo total: {hallazgos.R.sum()} | antes de la revisión mensual ({REVISION_MENSUAL:%d/%m}): {int((hallazgos.limite <= REVISION_MENSUAL).sum())} hallazgos')
print('Hoy mismo (24 horas):', ', '.join(hallazgos.id[hallazgos.severidad == 'crítica']), '| esta semana:', ', '.join(hallazgos.id[hallazgos.severidad == 'alta']))

ZONAS = {'baja': '#d8ead3', 'media': '#fff2cc', 'alta': '#f9cb9c', 'crítica': '#ea9999'}
fig, ax = plt.subplots(figsize = (8.6, 7))
for p in range(1, 6):
    for i in range(1, 6):
        ax.add_patch(Rectangle((p - 0.5, i - 0.5), 1, 1, facecolor = ZONAS[severidad(p * i)], edgecolor = 'white', lw = 2))
        ax.text(p + 0.42, i - 0.42, str(p * i), ha = 'right', va = 'bottom', fontsize = 8, color = '#8a8a8a')
grupos = hallazgos.groupby(['P', 'I']).id.agg(list)
for (p, i), ids in grupos.items():
    for k, ident in enumerate(ids):
        ang = 2 * math.pi * k / len(ids)
        r = 0 if len(ids) == 1 else 0.24
        x, y = p + r * math.cos(ang), i + r * math.sin(ang)
        ax.add_patch(Circle((x, y), 0.17, facecolor = '#34332f', edgecolor = 'white', lw = 1.2, zorder = 3))
        ax.text(x, y, ident[1:], ha = 'center', va = 'center', fontsize = 8, color = 'white', fontweight = 'bold', zorder = 4)
ax.set_xlim(0.5, 5.5)
ax.set_ylim(0.5, 5.5)
ax.set_xticks(range(1, 6), ['1 remota', '2 poco probable', '3 posible', '4 probable', '5 casi segura'], fontsize = 9)
ax.set_yticks(range(1, 6), ['1 menor', '2 limitado', '3 moderado', '4 grave', '5 crítico'], fontsize = 9)
ax.set_xlabel('Probabilidad en los próximos 12 meses')
ax.set_ylabel('Impacto en clientes, dinero y datos')
for s, c in ZONAS.items():
    ax.scatter([], [], marker = 's', s = 100, color = c, label = f'{s} ({PLAZOS[s]} {"día" if PLAZOS[s] == 1 else "días"})')
ax.legend(loc = 'upper left', frameon = False, fontsize = 9, title = 'Severidad y plazo', title_fontsize = 9)
ax.set_title('Matriz de riesgo de los 14 hallazgos (número = H)', fontsize = 12.5)
plt.tight_layout()
plt.show()

# Búsqueda de secretos filtrados con expresiones regulares y entropía en exportaciones, registro y repositorio en Python:
PATRONES = {
    'clave de Anthropic': r'sk-ant-[A-Za-z0-9_\-]{20,}',
    'token de Slack': r'xox[abpr]-[A-Za-z0-9\-]{10,}',
    'URL de webhook de Slack': r'https://hooks\.slack\.com/services/T[A-Z0-9]+/B[A-Z0-9]+/[A-Za-z0-9]+',
    'token de Meta': r'\bEAA[A-Za-z0-9]{20,}',
    'token de Notion': r'\b(?:ntn_|secret_)[A-Za-z0-9]{20,}',
    'token de GitHub': r'\b(?:ghp_|github_pat_)[A-Za-z0-9_]{20,}',
    'cabecera de autenticación': r'"(?:x-api-key|authorization|X-API-Key)"\s*,\s*"value"\s*:\s*"([^"{]{8,})"',
    'conexión real de Make': r'"__IMTCONN__"\s*:\s*([1-9]\d*)',
    'URL de webhook de n8n': r'https?://[\w.\-]+/webhook(?:-test)?/[\w\-]+',
}
CANDIDATO = re.compile(r'(?<![A-Za-z0-9+/=_\-])[A-Za-z0-9+/=_\-]{32,}(?![A-Za-z0-9+/=_\-])')

def entropia(s):                                          # bits por carácter (Shannon)
    cuenta = Counter(s)
    return -sum(c / len(s) * math.log2(c / len(s)) for c in cuenta.values())

def enmascarar(v):
    return v[:6] + '…' + v[-3:] + f' ({len(v)} caracteres)' if len(v) > 12 else v[:3] + '…'

def clasificar(valor):
    if 'EJEMPLO-NO-REAL' in valor or 'EJEMPLO' in valor or 'ejemplo' in valor or re.fullmatch(r'[0.\-A-Fa-f]*0{6,}[0-9A-Fa-f\-]*', valor):
        return 'de ejemplo (publicable)'
    return 'a revisar'

RUTAS = [Path('trigo_lento') / 'dia_42' / 'exportaciones', Path('trigo_lento') / 'dia_42' / 'flujos-trigo-lento',
         Path('trigo_lento') / 'dia_42' / 'historial', Path('trigo_lento') / 'dia_43' / 'repositorio',
         Path('trigo_lento') / 'dia_75' / 'registro_ejecuciones.csv'] + sorted(Path('trigo_lento').glob('dia_*/flujos'))
EXT = {'.json', '.csv', '.md', '.txt', '.sh', '.yml', '.yaml', '.env'}
archivos = sorted({a for r in RUTAS for a in ([r] if r.is_file() else r.rglob('*')) if a.is_file() and a.suffix.lower() in EXT})
coincidencias = []
for a in archivos:
    texto = a.read_text(encoding = 'utf-8', errors = 'ignore')
    for nombre, patron in PATRONES.items():
        for m in re.finditer(patron, texto):
            valor = m.group(1) if m.groups() else m.group(0)
            coincidencias.append({'archivo': a.as_posix().replace('trigo_lento/', ''), 'tipo': nombre, 'valor': valor, 'clase': clasificar(valor)})
    for m in CANDIDATO.finditer(texto):
        v = m.group(0)
        if entropia(v) >= 4.2 and not v.startswith('Salted__') and not re.fullmatch(r'[0-9a-f\-]+', v):
            coincidencias.append({'archivo': a.as_posix().replace('trigo_lento/', ''), 'tipo': 'cadena de alta entropía', 'valor': v, 'clase': clasificar(v)})
hallados = pd.DataFrame(coincidencias).drop_duplicates(['archivo', 'tipo', 'valor'])
print(f'Archivos revisados: {len(archivos)} ({sum(a.stat().st_size for a in archivos) / 1e6:.1f} MB) | coincidencias distintas: {len(hallados)}')
print(pd.crosstab(hallados.tipo, hallados.clase).to_string())
revisar = hallados[hallados.clase == 'a revisar']
print(f'A revisar: {len(revisar)} en {revisar.archivo.nunique()} archivos')
for f in revisar.itertuples():
    print(f'  {f.archivo}: {f.tipo}: {enmascarar(f.valor)}')
print(f'El registro de ejecuciones ({sum(1 for _ in open("trigo_lento/dia_75/registro_ejecuciones.csv", encoding = "utf-8")) - 1} filas): '
      f'{len(hallados[hallados.archivo.str.contains("registro")])} coincidencias')
print(f'Entropía de referencia: "{enmascarar("sk-ant-api03-EJEMPLO-NO-REAL-0000000000000000")}" = '
      f'{entropia("sk-ant-api03-EJEMPLO-NO-REAL-0000000000000000"):.2f} bits; identificador hexadecimal de 32 = {entropia("0b1c000000004000800000000000a1f3"):.2f}; '
      f'32 caracteres aleatorios de base64 = {entropia("".join(rng.choice(list("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), 32))):.2f}')

# Simulacro de restauración del ecosistema en un servidor nuevo, sin mirar el servidor viejo, en Bash:
set -euo pipefail
# 1. Aprovisionar el servidor desde la consola del proveedor (la cuenta del negocio, no la de una persona)
#    y entrar con la llave SSH que guarda el gestor de contraseñas:
ssh -i ~/.ssh/tl_restauracion root@203.0.113.10      # dirección de documentación (RFC 5737), no la real

# 2. Docker, docker compose y la carpeta del proyecto desde el repositorio de configuración:
curl -fsSL https://get.docker.com | sh
git clone https://github.com/trigo-lento/flujos-trigo-lento.git /opt/trigo_lento
cd /opt/trigo_lento

# 3. Postgres solo: cargar la copia cifrada de las 2:00 sin que n8n escriba todavía:
docker compose up -d postgres
rclone copy externo:tl-respaldos/diaria/n8n_2026-04-21.dump.gpg .
gpg --batch --passphrase-file /root/.frase_respaldo -d n8n_2026-04-21.dump.gpg > n8n.dump
docker compose exec -T postgres pg_restore -U n8n -d n8n --clean --if-exists --no-owner < n8n.dump

# 4. La clave de cifrado sale del gestor de secretos, nunca del servidor caído, y se comprueba su huella:
export N8N_ENCRYPTION_KEY="$(op read 'op://Trigo Lento/N8N_ENCRYPTION_KEY/password')"
printf '%s' "$N8N_ENCRYPTION_KEY" | sha256sum | cut -c1-12         # debe coincidir con la huella anotada: 8e7272254ab0
printf 'N8N_ENCRYPTION_KEY=%s\n' "$N8N_ENCRYPTION_KEY" >> .env
docker compose up -d n8n

# 5. Credenciales (cifradas, de la exportación de hoy) y workflows (de la etiqueta del repositorio):
docker compose exec -u node n8n n8n import:credentials --separate --input=/home/node/.n8n/respaldos/2026-04-21/credenciales/
docker compose exec -u node n8n n8n import:workflow --separate --input=/home/node/.n8n/repositorio/flujos/n8n/
# import:workflow deja los workflows desactivados: se reactivan los 23 del inventario del Día 79.

# 6. La base del negocio vuelve de la copia de las 2:00:
rclone copy externo:tl-respaldos/diaria/trigo_lento_2026-04-21.sqlite.gpg .
gpg --batch --passphrase-file /root/.frase_respaldo -d trigo_lento_2026-04-21.sqlite.gpg > /opt/trigo_lento/datos/trigo_lento.sqlite

# 7. El webhook de Meta apunta al servidor nuevo y el DNS cambia (TTL de 3600 s: hasta una hora de propagación):
curl -s -X POST "https://graph.facebook.com/v24.0/APP_ID/subscriptions" \
  -d "object=whatsapp_business_account&callback_url=https://n8n.trigolento.example/webhook/pedidos-whatsapp-v2" \
  -d "verify_token=$(op read 'op://Trigo Lento/Meta verify token/password')&access_token=$(op read 'op://Trigo Lento/Meta app token/password')"

# 8. Pruebas de humo, sin escribir a ningún cliente (número de prueba y webhook de salud):
curl -s https://n8n.trigolento.example/webhook/salud-tl
python -I -X utf8 pruebas/prueba_de_humo.py --numero "+52 55 0000 0001"

# Salida de ejemplo (puede variar):
# 8e7272254ab0
# Successfully imported 21 credentials.
# Successfully imported 23 workflows.
# {"success":true}
# {"estado":"ok","workflows_activos":23,"ultima_ejecucion":"2026-04-21T12:49:03-06:00"}
# Prueba de humo: 6 de 6 comprobaciones correctas en 27 min (pedido de prueba, factura de prueba, Slack, Notion, Gmail borrador, informe)

# Simulacro cronometrado: fases con tiempo objetivo y medido, RTO, RPO y el escenario de la clave perdida en Python:
FASES = [  # fase, objetivo (min), medido (min), incidencia registrada por Valeria
    ('1. Aprovisionar el servidor nuevo', 20, 22, ''),
    ('2. Instalar Docker y docker compose', 15, 17, ''),
    ('3. Restaurar Postgres desde la copia cifrada', 10, 9, ''),
    ('4. Colocar N8N_ENCRYPTION_KEY y comprobar su huella', 15, 12, 'la huella coincidió a la primera'),
    ('5. Importar credenciales y workflows del repositorio', 10, 19, '23 workflows llegaron desactivados: reactivarlos a mano'),
    ('6. Restaurar trigo_lento.sqlite', 5, 6, ''),
    ('7. Apuntar el webhook de Meta y el DNS', 30, 58, 'TTL del DNS de 3600 s: 41 min de propagación'),
    ('8. Pruebas de humo', 20, 27, 'firma rechazada: secreto de la aplicación pegado con un espacio al final'),
]
RTO_OBJETIVO, RPO_OBJETIVO = 240, 24 * 60                 # minutos
ultima_copia, inicio_simulacro = 2 * 60, 10 * 60          # 02:00 y 10:00 en minutos del día
simulacro = pd.DataFrame(FASES, columns = ['fase', 'objetivo', 'medido', 'incidencia'])
simulacro['desvio'] = simulacro.medido - simulacro.objetivo
simulacro['fin_objetivo'] = simulacro.objetivo.cumsum()
simulacro['fin_medido'] = simulacro.medido.cumsum()
print(simulacro[['fase', 'objetivo', 'medido', 'desvio', 'incidencia']].to_string(index = False))
rto_medido = int(simulacro.medido.sum())
print(f'Plan: {simulacro.objetivo.sum()} min | medido: {rto_medido} min ({rto_medido // 60} h {rto_medido % 60} min) | RTO objetivo: {RTO_OBJETIVO} min | '
      f'holgura: {RTO_OBJETIVO - rto_medido} min | cumplido: {rto_medido <= RTO_OBJETIVO}')
print(f'Fases con desvío mayor del 50 %: {", ".join(simulacro.fase[simulacro.desvio > 0.5 * simulacro.objetivo].str[:1])} | '
      f'el DNS explica el {simulacro.desvio.max() / simulacro.desvio.clip(lower = 0).sum():.0%} del retraso')
rpo_medido = inicio_simulacro - ultima_copia
print(f'RPO: última copia a las 02:00, caída simulada a las 10:00: {rpo_medido / 60:.0f} h perdidas de ejecuciones y encargos | objetivo {RPO_OBJETIVO // 60} h | '
      f'workflows: 0 h (exportados tras cada cambio)')
# Si N8N_ENCRYPTION_KEY se hubiera perdido: ninguna credencial se abre y hay que volver a emitirlas todas.
credenciales_n8n = int(referencias[referencias.plataforma == 'n8n'].credencial.nunique())
MINUTOS_REEMISION = {'token OAuth': 20, 'clave de API': 10, 'contraseña': 8, 'secreto de firma': 12, 'URL de webhook': 5, 'token de servicio': 10, 'token de integración': 10}
en_n8n = inventario[inventario.guardado.str.contains('credencial de n8n')]
reemision = int(sum(MINUTOS_REEMISION[t] for t in en_n8n.tipo))
sin_fase_4 = rto_medido - 12
print(f'Clave perdida: {credenciales_n8n} credenciales de n8n ({len(en_n8n)} secretos distintos) por reemitir: {reemision} min de trámites + '
      f'{sin_fase_4} min del resto = {reemision + sin_fase_4} min ({(reemision + sin_fase_4) / 60:.1f} h): RTO incumplido en {reemision + sin_fase_4 - RTO_OBJETIVO} min')

fig, ax = plt.subplots(figsize = (11.5, 5.8))
ys = np.arange(len(simulacro))
for y, f in zip(ys, simulacro.itertuples()):
    ax.barh(y - 0.19, f.objetivo, left = f.fin_objetivo - f.objetivo, height = 0.36, color = '#c9c7c1', label = 'plan' if y == 0 else None)
    ax.barh(y + 0.19, f.medido, left = f.fin_medido - f.medido, height = 0.36,
            color = '#c0392b' if f.desvio > 0.5 * f.objetivo else '#2a78d6', label = 'medido' if y == 0 else None)
    ax.text(f.fin_medido + 2, y + 0.19, f'{f.medido} min' + (f' (+{f.desvio})' if f.desvio > 0 else ''), va = 'center', fontsize = 8.8)
ax.axvline(RTO_OBJETIVO, color = '#c0392b', ls = '--', lw = 1.6)
ax.text(RTO_OBJETIVO + 3, 0.6, f'RTO objetivo:\n{RTO_OBJETIVO} min', fontsize = 9.5, color = '#c0392b', va = 'center')
ax.axvline(rto_medido, color = '#2a78d6', ls = ':', lw = 1.4)
ax.text(rto_medido + 3, 2.4, f'medido:\n{rto_medido} min', fontsize = 9.5, color = '#2a78d6', va = 'center')
ax.set_yticks(ys, simulacro.fase, fontsize = 9.5)
ax.invert_yaxis()
ax.set_xlim(0, 275)
ax.set_xlabel('Minutos desde el inicio del simulacro (martes 21 de abril, 10:00)')
ax.set_title('Simulacro de restauración: 125 min planeados y 170 medidos', fontsize = 12.5)
ax.scatter([], [], marker = 's', s = 80, color = '#c0392b', label = 'desvío mayor del 50 %')
ax.legend(frameon = False, loc = 'center right', fontsize = 9)
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# Pérdida esperada de encargos según el intervalo de copia, analítica y simulada, en Python:
ENCARGOS_DIA, APERTURA, CIERRE, MINUTOS_RECAPTURA = 18, 7, 20, 6
POLITICAS = {'diaria a las 2:00': [2], 'cada 6 horas (2, 8, 14, 20)': [2, 8, 14, 20],
             'cada hora en horario de atención': [2] + list(range(7, 21))}

def solape(a, b, lo, hi):                                 # horas del intervalo (a, b] que caen dentro de [lo, hi)
    return max(0.0, min(b, hi) - max(a, lo))

def perdida_analitica(copias):
    # Caída en un instante t uniforme del día; se pierden los encargos llegados desde la última copia c,
    # que puede ser de ayer (c - 24): la llegada es uniforme entre las 7:00 y las 20:00 de cada día.
    tasa = ENCARGOS_DIA / (CIERRE - APERTURA)
    instantes = np.arange(0, 24, 1 / 60)
    total = 0.0
    for t in instantes:
        c = max([x for x in copias if x <= t] or [max(copias) - 24])
        total += tasa * (solape(c, t, APERTURA, CIERRE) + solape(c, t, APERTURA - 24, CIERRE - 24))
    return total / len(instantes)

def perdida_simulada(copias, dias = 50_000):
    perdidas = np.empty(dias)
    for k in range(dias):
        llegadas = np.concatenate([rng.uniform(APERTURA, CIERRE, rng.poisson(ENCARGOS_DIA)) - 24,   # ayer
                                   rng.uniform(APERTURA, CIERRE, rng.poisson(ENCARGOS_DIA))])        # hoy
        t = rng.uniform(0, 24)
        ultima = max([c for c in copias if c <= t] or [max(copias) - 24])
        perdidas[k] = ((llegadas > ultima) & (llegadas <= t)).sum()
    return perdidas.mean(), np.percentile(perdidas, 95)

filas = []
for nombre, copias in POLITICAS.items():
    media, p95 = perdida_simulada(copias)
    filas.append({'política': nombre, 'copias al día': len(copias), 'analítica': perdida_analitica(copias), 'simulada': media,
                  'p95': p95, 'minutos de recaptura': media * MINUTOS_RECAPTURA})
perdidas = pd.DataFrame(filas)
print(perdidas.to_string(index = False, formatters = {'analítica': '{:.3f}'.format, 'simulada': '{:.3f}'.format, 'p95': '{:.0f}'.format,
                                                     'minutos de recaptura': '{:.1f}'.format}))
print(f'Fórmula del plan para la copia diaria: (18 · 13 / 2 + 6 · 18) / 24 = {(18 * 13 / 2 + 6 * 18) / 24:.3f}; '
      f'cada hora en atención: 13 / 24 · 0.5 · 18 / 13 = {13 / 24 * 0.5 * 18 / 13:.3f}')
print(f'Copia cada hora de 7:00 a 20:00: {len(POLITICAS["cada hora en horario de atención"]) - 1} copias más al día; '
      f'tamaño por copia del Día 35: 16.2 MB; espacio adicional con retención de 7 días: {13 * 7 * 16.2 / 1000:.2f} GB')

# Generación de auditoria_seguridad_2026-04.md con el resumen de una página y los hallazgos ordenados en Python:
proxima_auditoria = date(2026, 10, 5)                      # primer lunes de octubre: seis meses, con la revisión trimestral de julio en medio
resumen = [
    '# Auditoría de seguridad del ecosistema de Trigo Lento (abril de 2026)', '',
    f'Fecha: {hoy:%d/%m/%Y}. Auditora: Valeria Ortiz. Alcance: {len(inventario)} credenciales, {len(cuentas)} consolas, '
    f'{len(activos)} flujos activos, copias y restauración. Criterio: código de honor, controles de los días 17, 35 y 64 y CIS Controls v8.1.', '',
    '## Resumen para Don Ernesto', '',
    f'- Llaves de la casa: {len(inventario)}. Las contamos todas; {int((inventario.cuenta == "personal").sum())} están a nombre de una persona y no del negocio.',
    f'- Ninguna llave se ha cambiado desde que se hizo; una está vencida (el dominio, de 2019) y {int((inventario.estado == "por vencer (30 días)").sum())} vencen en 30 días.',
    f'- Hay {alcances.sobran.sum()} permisos que abren puertas que no usamos; se cierran sin que nada deje de funcionar.',
    f'- Hallazgos: {len(hallazgos)} ({hallazgos.severidad.value_counts().get("crítica", 0)} críticos, se atienden hoy; '
    f'{hallazgos.severidad.value_counts().get("alta", 0)} altos, esta semana).',
    f'- Si el servidor desapareciera, el ecosistema vuelve en {rto_medido // 60} h {rto_medido % 60} min (probado hoy); se perderían como máximo las ejecuciones desde las 2:00.',
    f'- Próxima auditoría completa: {proxima_auditoria:%d/%m/%Y}; revisión de permisos y credenciales: {REVISION_TRIMESTRAL:%d/%m/%Y}.', '',
    '## Hallazgos por severidad', '',
    '| Id | Hallazgo | Evidencia | P | I | Severidad | Límite | Dueño | Estado |', '|---|---|---|---|---|---|---|---|---|',
]
for h in hallazgos.itertuples():
    resumen.append(f'| {h.id} | {h.descripcion} | {h.evidencia} | {h.P} | {h.I} | {h.severidad} | {h.limite:%d/%m/%Y} | {h.dueno} | {h.estado} |')
resumen += ['', '## Simulacro de restauración', '', '| Fase | Objetivo (min) | Medido (min) | Incidencia |', '|---|---|---|---|']
resumen += [f'| {f.fase} | {f.objetivo} | {f.medido} | {f.incidencia or "ninguna"} |' for f in simulacro.itertuples()]
resumen += ['', f'RTO: {rto_medido} min medido frente a {RTO_OBJETIVO} objetivo. RPO: {rpo_medido // 60} h medido frente a {RPO_OBJETIVO // 60} h objetivo.', '',
            '## Inventario de credenciales', '', 'Ver `inventario_credenciales.csv` (sin valores; solo nombres, dueños, alcances y fechas).', '',
            '## Calendario', '', f'- {REVISION_MENSUAL:%d/%m/%Y}: comprobar el cierre de los hallazgos críticos y altos.',
            f'- {REVISION_TRIMESTRAL:%d/%m/%Y}: revisión trimestral de precios, permisos y credenciales (Día 79).',
            f'- {proxima_auditoria:%d/%m/%Y}: auditoría completa con simulacro de restauración.']
ruta_informe = carpeta / 'auditoria_seguridad_2026-04.md'
ruta_informe.write_text('\n'.join(resumen) + '\n', encoding = 'utf-8')
print(f'{ruta_informe.as_posix()}: {len(resumen)} líneas, {ruta_informe.stat().st_size} bytes')
print('\n'.join(resumen[:12]))
print('...')
print('\n'.join(resumen[14:18]))
secretos_en_informe = sum(len(re.findall(p, ruta_informe.read_text(encoding = 'utf-8'))) for p in PATRONES.values())
print(f'Secretos en el informe según los patrones del Bloque 7: {secretos_en_informe}')