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

# Importaciones base, semilla de la serie y carpeta del laboratorio en Python:
import warnings
warnings.filterwarnings('ignore')
import hashlib
import json
import math
import re
import textwrap
import unicodedata
from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import FancyArrowPatch, FancyBboxPatch, Polygon

# Generador aleatorio con la semilla global de la serie:
rng = np.random.default_rng(2026)
pd.set_option('display.width', 140)
carpeta = Path('trigo_lento') / 'dia_70'
carpeta.mkdir(parents = True, exist_ok = True)
print('numpy', np.__version__, '| pandas', pd.__version__, '| carpeta:', carpeta.as_posix())

# Conjunto de referencia de 60 preguntas en JSON por línea, con huella para congelar la versión, en Python:
base = json.loads((carpeta / 'base_conocimiento.json').read_text(encoding = 'utf-8'))
HECHOS = {f"{p['pagina']}#{i}": h for p in base['paginas'] for i, h in enumerate(p['hechos'])}

# (pregunta, tipo, categoría, hecho que la responde o motivo, respuesta esperada); todas inventadas:
CASOS = [
    ('¿El pay de queso lleva gluten?', 'respondible', 'alergeno', 'ficha-pay-de-queso#0', 'Sí: gluten de trigo en la base, además de lácteos y huevo'),
    ('¿Las galletas de avena traen nueces?', 'respondible', 'alergeno', 'ficha-galletas-de-avena#0', 'No en la receta, pero pueden tener trazas de nuez'),
    ('¿El pastel de zanahoria trae nueces?', 'respondible', 'alergeno', 'ficha-pastel-de-zanahoria#0', 'Sí, nuez picada en el pan'),
    ('¿El pastel de chocolate tiene huevo?', 'respondible', 'alergeno', 'ficha-pastel-de-chocolate#0', 'Sí: gluten, huevo y lácteos; no lleva nuez'),
    ('¿El pan integral trae semillas de ajonjolí?', 'respondible', 'alergeno', 'ficha-pan-de-caja#0', 'Sí, semillas de ajonjolí por fuera'),
    ('¿Los panes para hamburguesa tienen leche?', 'respondible', 'alergeno', 'ficha-bollos#0', 'Sí, leche y ajonjolí'),
    ('¿Qué alérgenos manejan?', 'respondible', 'alergeno', 'alergenos-tabla#0', 'Gluten, huevo, lácteos, nuez y ajonjolí'),
    ('¿Puede haber rastros de nuez en cualquier pan?', 'respondible', 'alergeno', 'alergenos-trazas#0', 'Sí: el obrador es compartido'),
    ('¿Cuáles panes tienen huevo o lácteos?', 'respondible', 'alergeno', 'alergenos-huevo-lacteos#0', 'Concha, croissant, rol, galletas, pasteles y pay'),
    ('¿Las galletas de avena tienen gluten?', 'respondible', 'alergeno', 'ficha-galletas-de-avena#1', 'Sí: avena no certificada y harina de trigo'),
    ('¿Cuánto me dura el pay de queso en el refri?', 'respondible', 'producto', 'ficha-pay-de-queso#1', 'Hasta tres días refrigerado; no se congela'),
    ('¿Para cuántas personas alcanza el pay de queso?', 'respondible', 'producto', 'ficha-pay-de-queso#2', 'De 10 a 12 porciones; cuesta 380 pesos'),
    ('¿La hogaza es vegana?', 'respondible', 'producto', 'ficha-hogaza#0', 'No: harina de trigo, agua y sal'),
    ('¿Cómo guardo la hogaza para que no se endurezca?', 'respondible', 'producto', 'ficha-hogaza#1', 'Cuatro días envuelta en tela; se congela rebanada'),
    ('¿Cuántas hornadas de baguette hacen al día?', 'respondible', 'producto', 'ficha-baguette#0', 'Tres veces al día'),
    ('¿El croissant es de mantequilla de verdad?', 'respondible', 'producto', 'ficha-croissant#0', 'Mantequilla de vaca; se barniza con huevo'),
    ('¿Cuánto cuestan las galletas de avena?', 'respondible', 'producto', 'ficha-galletas-de-avena#2', '60 pesos el paquete de seis'),
    ('¿Le pueden escribir un mensaje al pastel de chocolate?', 'respondible', 'producto', 'ficha-pastel-de-chocolate#1', 'Hasta 30 caracteres en chocolate blanco'),
    ('¿De qué tamaño son los pasteles?', 'respondible', 'producto', 'faq-tamanos#0', '20 centímetros, de 10 a 12 porciones'),
    ('¿Cuántas horas fermenta la masa madre?', 'respondible', 'producto', 'faq-masa-madre#0', '18 horas'),
    ('¿Hasta cuándo puedo cancelar sin que me cobren?', 'respondible', 'politica', 'politica-cancelaciones#0', 'Hasta 48 horas antes; se devuelve el anticipo'),
    ('Si cancelo un día antes, ¿me devuelven el anticipo?', 'respondible', 'politica', 'politica-cancelaciones#1', 'Se conserva la mitad del anticipo'),
    ('¿Cuánto tengo que dejar de anticipo para un pastel?', 'respondible', 'politica', 'politica-anticipos#0', 'El 50 por ciento del precio'),
    ('¿Cuánto cobran por llevarlo a domicilio?', 'respondible', 'politica', 'politica-entregas#0', '60 pesos, en Narvarte y colonias vecinas'),
    ('¿Con cuántos días de anticipación pido un pastel?', 'respondible', 'politica', 'politica-anticipacion#0', 'Al menos 48 horas'),
    ('¿Hasta cuándo puedo pedir mi factura?', 'respondible', 'politica', 'politica-facturacion#0', 'Antes del último día del mes de la compra'),
    ('¿Cuánto tiempo tengo para reclamar un producto?', 'respondible', 'politica', 'politica-quejas#0', 'Dentro de las 24 horas, con fotografía'),
    ('¿Cómo pido acceso o cancelación de mis datos?', 'respondible', 'politica', 'politica-privacidad#0', 'Escribir a privacidad@ejemplo.com'),
    ('¿Aceptan cheques?', 'respondible', 'politica', 'politica-pagos#0', 'No; efectivo, tarjeta o transferencia'),
    ('¿Qué necesito para recoger mi encargo?', 'respondible', 'politica', 'faq-recoger#0', 'Sí, basta con el número'),
    ('¿Quién confirma los pedidos de WhatsApp?', 'respondible', 'politica', 'faq-whatsapp#0', 'Sí, el asistente atiende y una persona confirma'),
    ('¿El texto del pastel tiene costo?', 'respondible', 'politica', 'faq-texto-pastel#0', 'No, hasta 30 caracteres sin costo'),
    ('¿Qué horario tienen el domingo?', 'respondible', 'horario', 'faq-horario#0', 'De 8 a 14 horas'),
    ('¿Van a abrir el 1 de mayo?', 'respondible', 'horario', 'aviso-1-de-mayo#0', 'No; el sábado 2 abren de 8 a 14'),
    ('¿Hasta qué fecha encargo galletas para el Día del Niño?', 'respondible', 'horario', 'aviso-dia-del-nino#0', 'Hasta el 28 de abril'),
    ('¿Cuándo es lo último para encargar pastel del Día de las Madres?', 'respondible', 'horario', 'aviso-dia-de-las-madres#0', 'El 7 de mayo'),
    ('¿En qué horario entregan a domicilio?', 'respondible', 'horario', 'politica-entregas#0', 'De 9 a 19 horas'),
    ('¿En qué fechas tienen pan de muerto?', 'respondible', 'horario', 'aviso-pan-de-muerto#0', 'Del 15 de octubre al 2 de noviembre'),
    ('¿Qué días venden rosca de Reyes?', 'respondible', 'horario', 'aviso-rosca#0', 'Del 2 al 6 de enero'),
    ('¿A qué hora ponen el pan de ayer a mitad de precio?', 'respondible', 'horario', 'faq-pan-del-dia#0', 'Después de las 18 horas'),
    ('¿Tienen estacionamiento para clientes?', 'sin_respuesta', 'politica', '', 'No lo sé; le pregunto a una persona'),
    ('¿Aceptan pago con criptomonedas?', 'sin_respuesta', 'politica', '', 'No lo sé; le pregunto a una persona'),
    ('¿Dan clases de panadería?', 'sin_respuesta', 'politica', '', 'No lo sé; le pregunto a una persona'),
    ('¿Tienen pan keto o sin azúcar?', 'sin_respuesta', 'producto', '', 'No lo sé; le pregunto a una persona'),
    ('¿Cuántas calorías tiene un croissant?', 'sin_respuesta', 'producto', '', 'No lo sé; le pregunto a una persona'),
    ('¿Hacen pasteles de fondant con figuras?', 'sin_respuesta', 'producto', '', 'No lo sé; le pregunto a una persona'),
    ('¿Abren el 16 de septiembre?', 'sin_respuesta', 'horario', '', 'No lo sé; le pregunto a una persona'),
    ('¿Abren en la noche de Navidad?', 'sin_respuesta', 'horario', '', 'No lo sé; le pregunto a una persona'),
    ('¿El ajonjolí de los bollos es tostado?', 'sin_respuesta', 'alergeno', '', 'No lo sé; le pregunto a una persona'),
    ('¿Envían pan a Puebla por paquetería?', 'sin_respuesta', 'politica', '', 'No lo sé; le pregunto a una persona'),
    ('Mi pastel llegó aplastado y quiero que me lo repongan', 'escalar', 'politica', 'queja', 'Escalar a Valeria'),
    ('El repartidor llegó dos horas tarde, ¿con quién me quejo?', 'escalar', 'politica', 'queja', 'Escalar a Valeria'),
    ('La concha de hoy sabía rancia, no es la primera vez', 'escalar', 'producto', 'queja', 'Escalar a Valeria'),
    ('Me cobraron dos veces el anticipo, quiero mi reembolso', 'escalar', 'politica', 'reembolso', 'Escalar a Valeria'),
    ('Cancelé a tiempo y no me han devuelto el dinero', 'escalar', 'politica', 'reembolso', 'Escalar a Valeria'),
    ('Mi hijo es alérgico al cacahuate, ¿qué puede comer sin riesgo?', 'escalar', 'alergeno', 'alergeno_ambiguo', 'Escalar a Valeria'),
    ('Si le quito la nuez al rol de canela, ¿es seguro para un alérgico?', 'escalar', 'alergeno', 'alergeno_ambiguo', 'Escalar a Valeria'),
    ('Soy celiaca, ¿la hogaza tostada me hace daño?', 'escalar', 'alergeno', 'alergeno_ambiguo', 'Escalar a Valeria'),
    ('Quiero 40 conchas para el viernes', 'escalar', 'producto', 'mas_de_20', 'Escalar a Valeria'),
    ('Necesito 25 cajas surtidas para una boda', 'escalar', 'producto', 'mas_de_20', 'Escalar a Valeria'),
]
COMPORTAMIENTO = {'respondible': 'responder', 'sin_respuesta': 'no_lo_se', 'escalar': 'escalar'}
conjunto = pd.DataFrame(CASOS, columns = ['pregunta', 'tipo', 'categoria', 'referencia', 'respuesta_esperada'])
conjunto.insert(0, 'id', [f'R{i:02d}' for i in range(1, len(conjunto) + 1)])
conjunto['comportamiento'] = conjunto['tipo'].map(COMPORTAMIENTO)
conjunto['paginas_fuente'] = conjunto['referencia'].map(lambda r: [r.split('#')[0]] if '#' in r else [])
assert conjunto['referencia'][conjunto.tipo == 'respondible'].isin(HECHOS).all(), 'Hay respuestas sin hecho en la base'

# Una línea JSON por pregunta, con claves ordenadas, y la huella SHA-256 que congela la versión:
lineas = [json.dumps(fila, ensure_ascii = False, sort_keys = True) for fila in conjunto.to_dict('records')]
texto_jsonl = '\n'.join(lineas) + '\n'
huella = hashlib.sha256(texto_jsonl.encode('utf-8')).hexdigest()
(carpeta / 'referencia_v1.jsonl').write_text(texto_jsonl, encoding = 'utf-8')
(carpeta / 'referencia_v1.sha256').write_text(huella + '\n', encoding = 'utf-8')
print(f'Preguntas: {len(conjunto)} | huella de referencia_v1.jsonl: {huella[:16]}')
tabla_1 = pd.crosstab(conjunto['tipo'], conjunto['categoria'], margins = True, margins_name = 'total')
print(tabla_1.loc[['respondible', 'sin_respuesta', 'escalar', 'total']].to_string())
print('Motivos de escalado:', conjunto.loc[conjunto.tipo == 'escalar', 'referencia'].value_counts().to_dict())
print(lineas[1])

# Ejecución del agente del Día 69 sobre las 60 preguntas con Claude Haiku 5.5 en Python:
import anthropic

from agente_pedidos_v4 import SISTEMA_V4, BUSCAR_POLITICAS, buscar_politicas   # Día 69, sin cambios

ESCALADO = 'Le comunico con una persona del equipo'       # frase fija del prompt para quejas y casos delicados
cliente = anthropic.Anthropic()                            # lee ANTHROPIC_API_KEY del entorno
texto = (carpeta / 'referencia_v1.jsonl').read_text(encoding = 'utf-8')
assert hashlib.sha256(texto.encode('utf-8')).hexdigest() == huella, 'El conjunto cambió: no es la versión v1'
casos = [json.loads(linea) for linea in texto.splitlines()]

def correr_caso(caso, max_iteraciones = 3):
    mensajes = [{'role': 'user', 'content': caso['pregunta']}]
    fragmentos, entrada, salida = [], 0, 0
    for _ in range(max_iteraciones):
        r = cliente.messages.create(
            model = 'claude-haiku-5-5', max_tokens = 400, system = SISTEMA_V4,   # la misma configuración que producción
            tools = [BUSCAR_POLITICAS], messages = mensajes, output_config = {'effort': 'low'})
        entrada, salida = entrada + r.usage.input_tokens, salida + r.usage.output_tokens
        if r.stop_reason in ('refusal', 'max_tokens'):
            break
        mensajes.append({'role': 'assistant', 'content': r.content})
        if r.stop_reason != 'tool_use':
            break
        resultados = []
        for b in r.content:
            if b.type == 'tool_use':
                encontrado = buscar_politicas(**b.input)
                fragmentos += json.loads(encontrado)
                resultados.append({'type': 'tool_result', 'tool_use_id': b.id, 'content': encontrado})
        mensajes.append({'role': 'user', 'content': resultados})               # todos en un solo mensaje
    respuesta = ''.join(b.text for b in r.content if b.type == 'text')
    if r.stop_reason == 'refusal' or ESCALADO in respuesta:
        conducta = 'escalar'
    elif respuesta.startswith('No lo sé'):
        conducta = 'no_lo_se'
    else:
        conducta = 'responder'
    return {'id': caso['id'], 'modelo': r.model, 'stop_reason': r.stop_reason,
            'estado': 'truncada' if r.stop_reason == 'max_tokens' else 'ok',
            'conducta': conducta, 'respuesta': respuesta,
            'citas': re.findall(r'\[fuente: ([a-z0-9-]+)\]', respuesta),
            'recuperadas': list(dict.fromkeys(f['pagina'] for f in fragmentos)), 'fragmentos': fragmentos,
            'tokens_entrada': entrada, 'tokens_salida': salida}

with open(carpeta / 'corrida_300_real.jsonl', 'w', encoding = 'utf-8') as f:
    for caso in casos:                                      # una fila por caso, escrita al terminar cada uno
        fila = correr_caso(caso)
        f.write(json.dumps(fila, ensure_ascii = False) + '\n')
        print(fila['id'], fila['conducta'], fila['citas'], fila['tokens_entrada'], fila['tokens_salida'])

# Salida de ejemplo (puede variar):
# R01 responder ['ficha-pay-de-queso'] 2104 96
# R02 responder ['ficha-galletas-de-avena', 'alergenos-trazas'] 2231 118
# R03 responder ['ficha-pastel-de-zanahoria'] 2087 84
# ...
# R41 no_lo_se [] 1958 31
# R51 escalar [] 1172 42
# ...
# R60 escalar [] 1190 47

# Corrida simulada del agente con el índice de 300 tokens y métricas deterministas en Python:
VACIAS = set('el la los las un una unos unas de del al a en y o u que se su sus con por para es son lo le les '
             'como mas pero sin si no ya hay muy cada todo toda todos este esta esto mi me tiene tienen puedo '
             'puede cual cuanto cuanta cuantos cuantas hasta desde sobre entre'.split())

def normalizar(texto):
    # Minúsculas, sin acentos, sin palabras vacías y con un recorte simple del plural (Día 68):
    texto = unicodedata.normalize('NFD', texto.lower())
    texto = ''.join(c for c in texto if unicodedata.category(c) != 'Mn')
    palabras = [p for p in re.findall(r'[a-z0-9]+', texto) if p not in VACIAS]
    return [p[:-1] if p.endswith('s') and len(p) > 4 else p for p in palabras]

def construir_paginas(base, rng, palabras_por_pagina = 900):
    # Cada página: sus hechos repartidos entre frases de relleno hasta unas 900 palabras (~1 200 tokens).
    frases = {}
    for p in base['paginas']:
        lista, pendientes = [(p['titulo'] + '.', None)], list(enumerate(p['hechos']))
        while sum(len(f.split()) for f, _ in lista) < palabras_por_pagina:
            if pendientes and rng.random() < 0.12:
                i, h = pendientes.pop(0)
                lista.append((h, f"{p['pagina']}#{i}"))
            else:
                lista.append((base['relleno'][rng.integers(len(base['relleno']))], None))
        frases[p['pagina']] = lista + [(h, f"{p['pagina']}#{i}") for i, h in pendientes]
    return frases

def fragmentar(frases, tam_tokens, tokens_por_palabra = 4 / 3):
    # Ventana deslizante con solape de un sexto; un hecho cuenta solo si el fragmento lo trae COMPLETO.
    tam = round(tam_tokens / tokens_por_palabra)
    paso = round(tam_tokens * 5 / 6 / tokens_por_palabra)
    filas = []
    for pagina, lista in frases.items():
        palabras, marcas = [], []
        for frase, hecho in lista:
            n = len(frase.split())
            palabras += frase.split()
            marcas += [(hecho, j, n) for j in range(n)]
        for inicio in range(0, max(len(palabras) - (tam - paso), 1), paso):
            trozo = marcas[inicio:inicio + tam]
            completos = {h for h, j, n in trozo if h and j == 0} & {h for h, j, n in trozo if h and j == n - 1}
            filas.append({'pagina': pagina, 'texto': ' '.join(palabras[inicio:inicio + tam]),
                          'hechos': sorted(completos)})
    return pd.DataFrame(filas)

def indexar(frases, tam_tokens):
    fr = fragmentar(frases, tam_tokens)
    docs = [normalizar(t) for t in fr['texto']]
    vocab = {w: i for i, w in enumerate(sorted({w for d in docs for w in d}))}
    df = np.zeros(len(vocab))
    for d in docs:
        for w in set(d):
            df[vocab[w]] += 1
    idf = np.log((1 + len(docs)) / (1 + df)) + 1
    return fr, vocab, idf, vectorizar(fr['texto'], vocab, idf)

def vectorizar(textos, vocab, idf):
    m = np.zeros((len(textos), len(vocab)))
    for i, t in enumerate(textos):
        for w in normalizar(t):
            if w in vocab:
                m[i, vocab[w]] += 1
    m = np.log1p(m) * idf
    return m / np.maximum(np.linalg.norm(m, axis = 1, keepdims = True), 1e-12)

# Supuestos declarados del agente simulado (no son mediciones de Claude):
UMBRAL = 0.265                    # similitud mínima para responder (Día 69)
P_ACIERTA = {1: 0.96, 2: 0.88, 3: 0.75, 4: 0.75}   # según el lugar del fragmento con el hecho
P_CITA_BIEN = {True: 0.97, False: 0.75}  # según si el primer fragmento es de la página correcta
P_CALLA_SIN_HECHO = 0.45          # sin el hecho, dice "no lo sé" en vez de inventar
P_CALLA_SIN_BASE = 0.60           # pasa el umbral sin tener respuesta y aun así se abstiene
P_ESCALA = {'queja': 0.95, 'reembolso': 0.95, 'alergeno_ambiguo': 0.70, 'mas_de_20': 0.85}
P_ESCALA_DE_MAS = 0.03            # escala una pregunta que podía responder
azar = rng.random((len(conjunto), 3))   # números comunes: los mismos para cualquier índice

def correr_agente(conjunto, frases, tam_tokens, azar, k = 4):
    fr, vocab, idf, matriz = indexar(frases, tam_tokens)
    filas = []
    for c, (u1, u2, u3) in zip(conjunto.itertuples(), azar):
        sim = matriz @ vectorizar([c.pregunta], vocab, idf)[0]
        top = fr.iloc[np.argsort(-sim, kind = 'stable')[:k]]
        mejor, recuperadas = float(sim.max()), list(dict.fromkeys(top['pagina']))
        lugares = [i + 1 for i, hs in enumerate(top['hechos']) if c.referencia in hs]
        tiene_hecho = bool(lugares)
        otra = next((p for p in recuperadas if p not in c.paginas_fuente), recuperadas[0])
        conducta, correcta, cita, fidelidad = 'responder', False, otra, 0
        if c.tipo == 'escalar':
            conducta = 'escalar' if u1 < P_ESCALA[c.referencia] else 'responder'
            correcta = conducta == 'escalar'
        elif c.tipo == 'respondible' and u3 < P_ESCALA_DE_MAS:
            conducta = 'escalar'
        elif mejor < UMBRAL:
            conducta = 'no_lo_se'
            correcta = c.tipo == 'sin_respuesta'
        elif c.tipo == 'sin_respuesta':
            conducta = 'no_lo_se' if u1 < P_CALLA_SIN_BASE else 'responder'
            correcta = conducta == 'no_lo_se'
        elif tiene_hecho:
            correcta = u1 < P_ACIERTA[lugares[0]]
            cita = c.paginas_fuente[0] if u2 < P_CITA_BIEN[recuperadas[0] in c.paginas_fuente] else otra
            fidelidad = 2 if correcta and cita in c.paginas_fuente else (1 if correcta else 0)
        elif u1 < P_CALLA_SIN_HECHO:
            conducta = 'no_lo_se'
        filas.append({'id': c.id, 'tipo': c.tipo, 'categoria': c.categoria, 'conducta': conducta,
                      'correcta': correcta, 'cita': cita if conducta == 'responder' else '',
                      'recuperadas': recuperadas, 'lugar': lugares[0] if lugares else None,
                      'hecho_en_top3': any(c.referencia in hs for hs in top['hechos'][:3]),
                      'mejor': round(mejor, 3), 'fidelidad': fidelidad if conducta == 'responder' else None})
    return pd.DataFrame(filas)

def metricas(r, conjunto):
    resp = r[r.tipo == 'respondible']
    contestadas = resp[resp.conducta == 'responder']
    fuentes = conjunto.set_index('id')['paginas_fuente']
    cita_ok = contestadas.apply(lambda f: f.cita in fuentes[f.id] and f.cita in f.recuperadas, axis = 1)
    escaladas = r[r.conducta == 'escalar']
    return {'exactitud': (resp.correcta.sum(), len(resp)),
            'fidelidad': ((contestadas.fidelidad == 2).sum(), len(contestadas)),
            'citas_correctas': (cita_ok.sum(), len(contestadas)),
            'no_lo_se_correcto': (((r.tipo == 'sin_respuesta') & (r.conducta == 'no_lo_se')).sum(),
                                  (r.tipo == 'sin_respuesta').sum()),
            'no_lo_se_incorrecto': ((resp.conducta == 'no_lo_se').sum(), len(resp)),
            'precision_escalado': ((escaladas.tipo == 'escalar').sum(), len(escaladas)),
            'exhaustividad_escalado': (((r.tipo == 'escalar') & (r.conducta == 'escalar')).sum(),
                                       (r.tipo == 'escalar').sum())}

def wilson(x, n, z = 1.96):
    # Intervalo de Wilson al 95 % (se explica en la sección de incertidumbre):
    p = x / n
    centro = (p + z**2 / (2 * n)) / (1 + z**2 / n)
    margen = z / (1 + z**2 / n) * math.sqrt(p * (1 - p) / n + z**2 / (4 * n**2))
    return centro - margen, centro + margen

frases = construir_paginas(base, rng)
resultados = correr_agente(conjunto, frases, 300, azar)
resultados.to_json(carpeta / 'corrida_300.jsonl', orient = 'records', lines = True, force_ascii = False)
m300 = metricas(resultados, conjunto)
for nombre, (x, n) in m300.items():
    print(f'{nombre:<24}{x:>3} de {n:<3} = {x / n:.3f}')

# Comprobación del medidor: un oráculo debe sacar 1.0 y un agente que siempre responde "" debe sacar 0.0.
oraculo = resultados.assign(conducta = conjunto['comportamiento'], correcta = True, fidelidad = 2,
                            cita = conjunto['paginas_fuente'].map(lambda p: p[0] if p else ''),
                            recuperadas = conjunto['paginas_fuente'])
nulo = resultados.assign(conducta = 'responder', correcta = False, fidelidad = 0, cita = '')
print('Oráculo:', [float(round(x / n, 2)) for x, n in metricas(oraculo, conjunto).values()])
print('Nulo:   ', [float(round(x / max(n, 1), 2)) for x, n in metricas(nulo, conjunto).values()])

# Exactitud y citas correctas por categoría, con su intervalo de Wilson:
filas = []
for cat in ['alergeno', 'horario', 'politica', 'producto']:
    sub = resultados[(resultados.tipo == 'respondible') & (resultados.categoria == cat)]
    contestadas = sub[sub.conducta == 'responder']
    fuentes = conjunto.set_index('id')['paginas_fuente']
    citas = sum(f.cita in fuentes[f.id] for f in contestadas.itertuples())
    for metrica, x, n in [('exactitud', sub.correcta.sum(), len(sub)), ('citas correctas', citas, len(contestadas))]:
        bajo, alto = wilson(x, n)
        filas.append({'categoria': cat, 'metrica': metrica, 'x': x, 'n': n, 'p': x / n, 'bajo': bajo, 'alto': alto})
por_categoria = pd.DataFrame(filas)
print(por_categoria.round(3).to_string(index = False))

fig, ax = plt.subplots(figsize = (8.2, 4.6))
nombres_cat = {'alergeno': 'Alérgenos', 'horario': 'Horarios', 'politica': 'Políticas', 'producto': 'Productos'}
for j, (metrica, color) in enumerate([('exactitud', '#2a78d6'), ('citas correctas', '#7b4fc9')]):
    d = por_categoria[por_categoria.metrica == metrica].reset_index(drop = True)
    xs = np.arange(len(d)) + (j - 0.5) * 0.36
    ax.bar(xs, d['p'], width = 0.34, color = color, label = metrica)
    ax.errorbar(xs, d['p'], yerr = [d['p'] - d['bajo'], d['alto'] - d['p']], fmt = 'none', ecolor = '#2b2a28',
                capsize = 4, lw = 1.2)
    for x, f in zip(xs, d.itertuples()):
        ax.text(x, 0.03, f'{f.x}/{f.n}', ha = 'center', color = 'white', fontsize = 9)
ax.axhline(0.90, color = '#d03b3b', ls = '--', lw = 1.2)
ax.text(-0.55, 0.92, 'umbral 0.90', color = '#d03b3b', fontsize = 9)
ax.set_xticks(range(4), [nombres_cat[c] for c in por_categoria.categoria.unique()])
ax.set_ylim(0, 1.25)
ax.set_ylabel('Proporción (intervalo de Wilson al 95 %)')
ax.set_title('Agente con fragmentos de 300 tokens: métricas por categoría', fontsize = 13)
ax.legend(frameon = False, loc = 'upper center', ncol = 2)
ax.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# Juez con rúbrica explícita y salida estructurada con Claude Haiku 5.5 en Python:
import random
from typing import Literal
import anthropic
from pydantic import BaseModel, Field

class Veredicto(BaseModel):
    exactitud: Literal[0, 1]
    fidelidad: Literal[0, 1, 2]
    afirmaciones_sin_respaldo: list[str] = Field(description = 'Frases de la respuesta sin fragmento que las respalde')
    motivo: str = Field(description = 'Una sola frase que justifica las dos notas')

RUBRICA = """Usted califica respuestas del asistente automático de una panadería.
Exactitud (0 o 1): 1 si la respuesta dice lo mismo que la referencia en lo esencial y tiene la conducta esperada
(responder, decir "No lo sé" o pasar con una persona); 0 en cualquier otro caso.
Fidelidad (0, 1 o 2): 2 si cada afirmación está respaldada por algún fragmento; 1 si alguna afirmación no tiene
respaldo pero no contradice los fragmentos; 0 si alguna afirmación es falsa o contradice los fragmentos.
No premie la longitud, el tono ni la seguridad con que se escribe. En alérgenos, una respuesta que omite una traza
o un ingrediente declarado tiene exactitud 0. Si la conducta esperada es no_lo_se o escalar, ignore los fragmentos.
<ejemplo>Referencia: "Hasta tres días refrigerado". Respuesta: "Dura hasta tres días en refrigeración
[fuente: ficha-pay-de-queso]". Notas: exactitud 1, fidelidad 2.</ejemplo>
<ejemplo>Referencia: "No en la receta, pero pueden tener trazas de nuez". Respuesta: "No llevan nuez".
Notas: exactitud 0, fidelidad 1: omite las trazas.</ejemplo>
<ejemplo>Conducta esperada: no_lo_se. Respuesta: "Sí, tenemos estacionamiento". Notas: exactitud 0, fidelidad 0.</ejemplo>"""

cliente = anthropic.Anthropic()

def juzgar(caso, salida, semilla):
    fragmentos = list(salida['fragmentos'])
    random.Random(semilla).shuffle(fragmentos)            # orden aleatorio contra el sesgo de posición
    contenido = (f"<pregunta>{caso['pregunta']}</pregunta>\n<conducta_esperada>{caso['comportamiento']}"
                 f"</conducta_esperada>\n<referencia>{caso['respuesta_esperada']}</referencia>\n"
                 f"<fragmentos>{json.dumps(fragmentos, ensure_ascii = False)}</fragmentos>\n"
                 f"<respuesta>{salida['respuesta']}</respuesta>")
    r = cliente.messages.parse(
        model = 'claude-haiku-5-5', max_tokens = 400, system = RUBRICA,
        messages = [{'role': 'user', 'content': contenido}],
        output_config = {'effort': 'low'}, output_format = Veredicto)
    if r.stop_reason != 'end_turn' or r.parsed_output is None:
        return None                                       # sin veredicto: la pregunta se revisa a mano
    return r.parsed_output

# Antes de confiar en el juez: tres respuestas que debe reprobar siempre.
caso = casos[1]                                           # R02, galletas de avena y nuez
for prueba in ['', 'No lo sé; le pregunto a una persona.', 'El pastel de chocolate cuesta 460 pesos.']:
    v = juzgar(caso, {'respuesta': prueba, 'fragmentos': []}, semilla = 0)
    print(repr(prueba[:30]), '->', v.exactitud if v else 'sin veredicto')

salidas = {json.loads(l)['id']: json.loads(l) for l in open(carpeta / 'corrida_300_real.jsonl', encoding = 'utf-8')}
veredictos = {c['id']: juzgar(c, salidas[c['id']], semilla = i) for i, c in enumerate(casos)}
print(veredictos['R02'])

# Salida de ejemplo (puede variar):
# '' -> 0
# 'No lo sé; le pregunto a una pe' -> 0
# 'El pastel de chocolate cuesta ' -> 0
# exactitud=1 fidelidad=2 afirmaciones_sin_respaldo=[] motivo='Dice que la receta no lleva nuez, advierte de
# las trazas por el obrador compartido y cita la ficha de las galletas.'

# Kappa de Cohen escrita a mano y matriz de confusión del juez frente a Valeria en Python:
# Valeria califica a ciegas las 60 respuestas (1 = conducta correcta). El juez se simula con
# tasas declaradas: aprueba el 30 % de lo malo y rechaza el 7 % de lo bueno (supuestos).
valeria = resultados['correcta'].astype(int).to_numpy()
juez = np.where(valeria == 1, (rng.random(len(valeria)) >= 0.07).astype(int),
                (rng.random(len(valeria)) < 0.30).astype(int))

def kappa_cohen(a, b):
    n = len(a)
    p_o = (a == b).mean()                                     # acuerdo observado
    p_e = sum((a == c).mean() * (b == c).mean() for c in (0, 1))   # acuerdo esperado por azar
    return p_o, p_e, (p_o - p_e) / (1 - p_e)

p_o, p_e, kappa = kappa_cohen(valeria, juez)
matriz_conf = pd.crosstab(pd.Series(valeria, name = 'Valeria'), pd.Series(juez, name = 'juez'))
print(matriz_conf.rename(index = {1: 'Valeria: buena', 0: 'Valeria: mala'},
                         columns = {1: 'juez: buena', 0: 'juez: mala'}).to_string())
print(f'p_o = {p_o:.3f} | p_e = {p_e:.3f} | kappa = {kappa:.3f}')
malas = valeria == 0
print(f'El juez aprueba {juez[malas].sum()} de {malas.sum()} respuestas malas ({juez[malas].mean():.0%})')
alerg = (resultados.categoria == 'alergeno').to_numpy()
print(f'En alérgenos: {((juez == 1) & malas & alerg).sum()} respuestas malas aprobadas por el juez '
      f'de {(malas & alerg).sum()} malas')

fig, ax = plt.subplots(figsize = (5.6, 4.6))
valores = matriz_conf.loc[[1, 0], [1, 0]].to_numpy()
ax.imshow(valores, cmap = 'Blues', vmin = 0, vmax = valores.max() * 1.15)
for i in range(2):
    for j in range(2):
        ax.text(j, i, valores[i, j], ha = 'center', va = 'center', fontsize = 18,
                color = 'white' if valores[i, j] > valores.max() / 2 else '#2b2a28')
ax.set_xticks([0, 1], ['buena', 'mala'])
ax.set_yticks([0, 1], ['buena', 'mala'])
ax.set_xlabel('Calificación del juez (Haiku 5.5, simulado)')
ax.set_ylabel('Calificación de Valeria')
ax.set_title(f'Juez frente a Valeria en 60 respuestas: kappa = {kappa:.3f}', fontsize = 12)
plt.tight_layout()
plt.show()

# Intervalos de Wilson al 95 % por métrica y tamaño de muestra necesario en Python:
UMBRALES = {'exactitud': 0.90, 'fidelidad': 0.90, 'citas_correctas': 0.90, 'no_lo_se_correcto': 0.80,
            'no_lo_se_incorrecto': 0.10, 'precision_escalado': 0.80, 'exhaustividad_escalado': 0.90}
filas = []
for nombre, (x, n) in m300.items():
    bajo, alto = wilson(x, n)
    filas.append({'metrica': nombre, 'x': x, 'n': n, 'estimacion': x / n, 'bajo': bajo, 'alto': alto,
                  'ancho': alto - bajo, 'umbral': UMBRALES[nombre]})
tabla_3 = pd.DataFrame(filas).set_index('metrica')
print(tabla_3.round(3).to_string())
print('Ejemplo de la ficha, 36 de 40:', np.round(wilson(36, 40), 3), '| 8 de 10:', np.round(wilson(8, 10), 3))

# ¿Cuántas preguntas respondibles harían falta para que 0.90 y 0.93 no se solapen?
for n in [40, 100, 400, 800, 1200, 1600]:
    alto_90, bajo_93 = wilson(0.90 * n, n)[1], wilson(0.93 * n, n)[0]
    print(f'n = {n:>3}: techo de 0.90 = {alto_90:.3f} | piso de 0.93 = {bajo_93:.3f} | '
          f'{"se distinguen" if alto_90 < bajo_93 else "se solapan"}')

# Reindexado con fragmentos de 150, 300 y 600 tokens, corrida pareada y McNemar exacto en Python:
def mcnemar_exacto(b, c):
    # b: empeoran, c: mejoran. Binomial(b + c, 1/2) a dos colas sobre las preguntas que cambian:
    n = b + c
    if n == 0:
        return 1.0
    return min(1.0, 2 * sum(math.comb(n, i) for i in range(min(b, c) + 1)) / 2**n)

corridas = {tam: (resultados if tam == 300 else correr_agente(conjunto, frases, tam, azar))
            for tam in [150, 300, 600]}
filas = []
for tam, r in corridas.items():
    m = metricas(r, conjunto)
    resp = (r.tipo == 'respondible').to_numpy()
    antes, despues = resultados['correcta'].to_numpy(), r['correcta'].to_numpy()
    empeoran, mejoran = (antes & ~despues), (~antes & despues)
    filas.append({'tokens': tam, 'fragmentos': len(fragmentar(frases, tam)),
                  'exactitud': m['exactitud'][0] / m['exactitud'][1],
                  'citas_correctas': m['citas_correctas'][0] / m['citas_correctas'][1],
                  'recall@3': r.loc[resp, 'hecho_en_top3'].mean(),
                  'mejoran': int(mejoran.sum()), 'empeoran': int(empeoran.sum()),
                  'p_mcnemar': mcnemar_exacto(int(empeoran.sum()), int(mejoran.sum())),
                  'alergenos_que_empeoran': int((empeoran & alerg).sum())})
tabla_4 = pd.DataFrame(filas).set_index('tokens')
print(tabla_4.round(3).to_string())
print('Comprobación de la ficha, 7 empeoran y 2 mejoran:', round(mcnemar_exacto(7, 2), 3))
r150 = corridas[150]
cambios = conjunto.assign(antes = resultados.correcta, con_150 = r150.correcta)
print(cambios.loc[cambios.antes != cambios.con_150, ['id', 'categoria', 'pregunta', 'antes', 'con_150']]
      .to_string(index = False))

fig, (ax1, ax2) = plt.subplots(1, 2, figsize = (10.5, 4.4), gridspec_kw = {'width_ratios': [1, 1.4]})
otros = tabla_4.drop(index = 300)
xs = np.arange(len(otros))
ax1.bar(xs - 0.18, otros['mejoran'], width = 0.34, color = '#1f9d55', label = 'mejoran')
ax1.bar(xs + 0.18, -otros['empeoran'], width = 0.34, color = '#d03b3b', label = 'empeoran')
for x, f in zip(xs, otros.itertuples()):
    ax1.text(x - 0.18, f.mejoran + 0.2, f.mejoran, ha = 'center', fontsize = 10)
    ax1.text(x + 0.18, -f.empeoran - 0.7, f.empeoran, ha = 'center', fontsize = 10)
    ax1.text(x, -max(otros['empeoran']) - 2.2, f'p = {f.p_mcnemar:.3f}', ha = 'center', fontsize = 9,
             color = '#52514e')
ax1.axhline(0, color = '#2b2a28', lw = 1)
ax1.set_xticks(xs, [f'{t} tokens' for t in otros.index])
ax1.set_ylim(-max(otros['empeoran']) - 3, max(otros['mejoran']) + 2)
ax1.set_ylabel('Preguntas respecto de 300 tokens')
ax1.set_title('Cambios pareados', fontsize = 12)
ax1.legend(frameon = False, loc = 'upper right')
ax1.spines[['top', 'right']].set_visible(False)
for metrica, color in [('exactitud', '#2a78d6'), ('citas_correctas', '#7b4fc9'), ('recall@3', '#eb6834')]:
    ax2.plot(tabla_4.index, tabla_4[metrica], marker = 'o', lw = 2, color = color,
             label = metrica.replace('_', ' '))
ax2.axhline(0.90, color = '#8a8986', ls = ':', lw = 1.2)
ax2.set_xticks(tabla_4.index, [f'{t}' for t in tabla_4.index])
ax2.set_xlabel('Tamaño de fragmento (tokens)')
ax2.set_ylim(0.5, 1.02)
ax2.set_title('Métricas por configuración', fontsize = 12)
ax2.legend(frameon = False, loc = 'lower right')
ax2.spines[['top', 'right']].set_visible(False)
plt.tight_layout()
plt.show()

# Puerta de regresión: tres cerrojos y veredicto por configuración en Python:
def puerta(fila, base_exactitud, umbral_citas = 0.85):
    motivos = []
    if fila['alergenos_que_empeoran'] > 0:
        motivos.append(f"{int(fila['alergenos_que_empeoran'])} pregunta(s) de alérgenos empeoran")
    if (base_exactitud - fila['exactitud']) * 40 > 1 + 1e-9:
        motivos.append(f"la exactitud baja {round((base_exactitud - fila['exactitud']) * 40)} preguntas")
    if fila['citas_correctas'] < umbral_citas:
        motivos.append(f"citas correctas {fila['citas_correctas']:.3f} < {umbral_citas}")
    return ('bloqueado: ' + '; '.join(motivos)) if motivos else 'aprobado'

base_exactitud = tabla_4.loc[300, 'exactitud']
for tam, fila in tabla_4.iterrows():
    if tam != 300:
        print(f'{tam} tokens -> {puerta(fila, base_exactitud)}')

# Coste de una corrida completa con Haiku 5.5 (agente y juez) y con Opus 5.5 como juez:
PRECIOS = {'claude-haiku-5-5': (0.10, 0.50), 'claude-opus-5-5': (4.00, 20.00)}   # USD por millón
coste = lambda modelo, entrada, salida, n = 60: n * (entrada * PRECIOS[modelo][0] + salida * PRECIOS[modelo][1]) / 1e6
agente = coste('claude-haiku-5-5', 2000, 250)
juez_haiku, juez_opus = coste('claude-haiku-5-5', 3000, 300), coste('claude-opus-5-5', 3000, 300)
print(f'Corrida: agente {agente:.4f} + juez Haiku {juez_haiku:.4f} = {agente + juez_haiku:.4f} USD '
      f'| con juez Opus: {agente + juez_opus:.4f} USD')
corridas_mes = 4 + 4                       # cada lunes más unos cuatro cambios de prompt, índice o modelo
print(f'{corridas_mes} corridas al mes: {corridas_mes * (agente + juez_haiku):.2f} USD con Haiku '
      f'| {corridas_mes * (agente + juez_opus):.2f} USD con juez Opus')

{
  "name": "TL Evaluación del agente v1",
  "nodes": [
    {
      "parameters": {"inputSource": "jsonExample", "jsonExample": "{\n  \"motivo\": \"cambio de prompt, índice o modelo\",\n  \"version\": \"v4.1\"\n}"},
      "id": "0b1c7000-0000-4000-8000-000000000001",
      "name": "Cambio publicado",
      "type": "n8n-nodes-base.executeWorkflowTrigger",
      "typeVersion": 1.1,
      "position": [0, -240]
    },
    {
      "parameters": {},
      "id": "0b1c7000-0000-4000-8000-000000000002",
      "name": "Al pulsar Probar",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [0, 0]
    },
    {
      "parameters": {"rule": {"interval": [{"field": "cronExpression", "expression": "0 7 * * 1"}]}},
      "id": "0b1c7000-0000-4000-8000-000000000003",
      "name": "Lunes 7:00",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [0, 240]
    },
    {
      "parameters": {"operation": "executeQuery", "query": "SELECT r.id, r.pregunta, r.tipo, r.categoria, r.comportamiento, r.respuesta_esperada, r.paginas_fuente FROM referencia r JOIN versiones_referencia v ON v.version = r.version WHERE r.version = 'v1' AND v.huella = $1 ORDER BY r.id;", "options": {"queryReplacement": "={{ [$env.TL_HUELLA_REFERENCIA] }}"}},
      "id": "0b1c7000-0000-4000-8000-000000000004",
      "name": "Leer conjunto v1",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2.6,
      "position": [240, 0],
      "credentials": {"postgres": {"id": "0000000000000070", "name": "Postgres TL evaluación (solo lectura)"}}
    },
    {
      "parameters": {"batchSize": 1, "options": {}},
      "id": "0b1c7000-0000-4000-8000-000000000005",
      "name": "Pregunta por pregunta",
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 3,
      "position": [480, 0]
    },
    {
      "parameters": {"workflowId": {"__rl": true, "value": "Ag7kRt2mWq9pLs4V", "mode": "list", "cachedResultName": "TL Agente de pedidos v4 (modo prueba)"}, "workflowInputs": {"mappingMode": "defineBelow", "value": {"texto": "={{ $json.pregunta }}", "sesion": "={{ 'eval_' + $json.id }}", "modelo": "claude-haiku-5-5", "modo_prueba": "true"}, "matchingColumns": [], "schema": [{"id": "texto", "displayName": "texto", "required": false, "defaultMatch": false, "display": true, "canBeUsedToMatch": true, "type": "string", "removed": false}, {"id": "sesion", "displayName": "sesion", "required": false, "defaultMatch": false, "display": true, "canBeUsedToMatch": true, "type": "string", "removed": false}, {"id": "modelo", "displayName": "modelo", "required": false, "defaultMatch": false, "display": true, "canBeUsedToMatch": true, "type": "string", "removed": false}, {"id": "modo_prueba", "displayName": "modo_prueba", "required": false, "defaultMatch": false, "display": true, "canBeUsedToMatch": true, "type": "string", "removed": false}], "attemptToConvertTypes": false, "convertFieldsToString": false}, "options": {"waitForSubWorkflow": true}},
      "id": "0b1c7000-0000-4000-8000-000000000006",
      "name": "Agente en modo prueba",
      "type": "n8n-nodes-base.executeWorkflow",
      "typeVersion": 1.2,
      "position": [720, 200]
    },
    {
      "parameters": {"jsCode": "const caso = $('Pregunta por pregunta').item.json;\nconst r = $json;\nconst fragmentos = [...(r.fragmentos || [])].sort(() => Math.random() - 0.5);\nconst sistema = 'Usted califica respuestas del asistente de una panadería contra una respuesta de referencia. Califique exactitud (0 o 1) y fidelidad (0, 1 o 2): 2 si cada afirmación está respaldada por un fragmento, 1 si alguna no lo está pero no es falsa, 0 si alguna es falsa o inventada. No premie la longitud ni el tono. Si la conducta esperada es no_lo_se o escalar, la exactitud es 1 solo si la respuesta hace eso.';\nconst usuario = '<pregunta>' + caso.pregunta + '</pregunta>\\n<conducta_esperada>' + caso.comportamiento + '</conducta_esperada>\\n<referencia>' + caso.respuesta_esperada + '</referencia>\\n<fragmentos>' + JSON.stringify(fragmentos) + '</fragmentos>\\n<respuesta>' + String(r.respuesta || '') + '</respuesta>';\nconst esquema = {type: 'object', additionalProperties: false, required: ['exactitud', 'fidelidad', 'afirmaciones_sin_respaldo', 'motivo'], properties: {exactitud: {type: 'integer', enum: [0, 1]}, fidelidad: {type: 'integer', enum: [0, 1, 2]}, afirmaciones_sin_respaldo: {type: 'array', items: {type: 'string'}}, motivo: {type: 'string'}}};\nreturn [{ json: { id: caso.id, caso, agente: r, cuerpo: { model: 'claude-haiku-5-5', max_tokens: 400, output_config: { effort: 'low', format: { type: 'json_schema', schema: esquema } }, system: sistema, messages: [{ role: 'user', content: usuario }] } } }];"},
      "id": "0b1c7000-0000-4000-8000-000000000007",
      "name": "Armar juicio",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [960, 200]
    },
    {
      "parameters": {"method": "POST", "url": "https://api.anthropic.com/v1/messages", "authentication": "genericCredentialType", "genericAuthType": "httpHeaderAuth", "sendHeaders": true, "headerParameters": {"parameters": [{"name": "anthropic-version", "value": "2023-06-01"}]}, "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify($json.cuerpo) }}", "options": {"timeout": 60000, "response": {"response": {"fullResponse": true, "neverError": true}}}},
      "id": "0b1c7000-0000-4000-8000-000000000008",
      "name": "Juez Haiku 5.5",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [1200, 200],
      "credentials": {"httpHeaderAuth": {"id": "0000000000000040", "name": "Claude x-api-key TL"}}
    },
    {
      "parameters": {"jsCode": "const filas = $('Juez Haiku 5.5').all().map((it, i) => { const j = it.json; const a = $('Armar juicio').all()[i].json; let v = null; if (j.statusCode === 200 && j.body.stop_reason === 'end_turn') { v = JSON.parse(j.body.content.find(b => b.type === 'text').text); } return { id: a.id, caso: a.caso, agente: a.agente, veredicto: v }; });\nconst wilson = (x, n, z = 1.96) => { const p = x / n, c = (p + z*z/(2*n)) / (1 + z*z/n), m = z / (1 + z*z/n) * Math.sqrt(p*(1-p)/n + z*z/(4*n*n)); return [c - m, c + m]; };\nconst resp = filas.filter(f => f.caso.tipo === 'respondible');\nconst contestadas = resp.filter(f => f.agente.conducta === 'responder');\nconst citaOk = contestadas.filter(f => f.caso.paginas_fuente.includes(f.agente.cita) && (f.agente.recuperadas || []).includes(f.agente.cita)).length;\nconst sinJuez = filas.filter(f => !f.veredicto).length;\nconst exactas = resp.filter(f => f.veredicto && f.veredicto.exactitud === 1).length;\nconst m = { exactitud: [exactas, resp.length], citas_correctas: [citaOk, contestadas.length], sin_juez: sinJuez };\nconst alergenosMal = resp.filter(f => f.caso.categoria === 'alergeno' && (!f.veredicto || f.veredicto.exactitud === 0)).map(f => f.id);\nconst ic = wilson(exactas, resp.length);\nconst bloqueado = alergenosMal.length > 0 || citaOk / Math.max(contestadas.length, 1) < 0.85 || sinJuez > 0;\nreturn [{ json: { metricas: m, ic_exactitud: ic, alergenos_mal: alergenosMal, veredicto: bloqueado ? 'bloqueado' : 'aprobado', revisar_a_mano: filas.filter(f => f.caso.categoria === 'alergeno' || f.caso.tipo === 'escalar').map(f => f.id) } }];"},
      "id": "0b1c7000-0000-4000-8000-000000000009",
      "name": "Calcular métricas",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [720, -200]
    },
    {
      "parameters": {"operation": "executeQuery", "query": "INSERT INTO evaluaciones (flujo, momento, version_referencia, metricas, veredicto) VALUES ('TL Evaluación del agente v1', now(), 'v1', $1::jsonb, $2);", "options": {"queryReplacement": "={{ [JSON.stringify($json.metricas), $json.veredicto] }}"}},
      "id": "0b1c7000-0000-4000-8000-000000000010",
      "name": "Guardar corrida",
      "type": "n8n-nodes-base.postgres",
      "typeVersion": 2.6,
      "position": [960, -200],
      "credentials": {"postgres": {"id": "0000000000000043", "name": "Postgres TL registro"}}
    },
    {
      "parameters": {"method": "POST", "url": "https://slack.com/api/chat.postMessage", "authentication": "genericCredentialType", "genericAuthType": "httpHeaderAuth", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({channel: $env.TL_SLACK_CANAL_OPERACION, text: 'Evaluación del agente: ' + $('Calcular métricas').first().json.veredicto, blocks: [{type: 'section', text: {type: 'mrkdwn', text: '*Evaluación del agente (referencia v1):* ' + $('Calcular métricas').first().json.veredicto + '\\nExactitud: ' + $('Calcular métricas').first().json.metricas.exactitud.join(' de ') + '\\nAlérgenos con fallo: ' + ($('Calcular métricas').first().json.alergenos_mal.join(', ') || 'ninguno')}}, {type: 'context', elements: [{type: 'mrkdwn', text: 'Calificación automática con juez calibrado. Las preguntas de alérgenos y de escalado las revisa una persona antes de aprobar.'}]}]}) }}", "options": {"timeout": 10000}},
      "id": "0b1c7000-0000-4000-8000-000000000011",
      "name": "Publicar en Slack",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [1200, -200],
      "credentials": {"httpHeaderAuth": {"id": "0000000000000050", "name": "Slack bot TL"}}
    }
  ],
  "connections": {
    "Cambio publicado": {"main": [[{"node": "Leer conjunto v1", "type": "main", "index": 0}]]},
    "Al pulsar Probar": {"main": [[{"node": "Leer conjunto v1", "type": "main", "index": 0}]]},
    "Lunes 7:00": {"main": [[{"node": "Leer conjunto v1", "type": "main", "index": 0}]]},
    "Leer conjunto v1": {"main": [[{"node": "Pregunta por pregunta", "type": "main", "index": 0}]]},
    "Pregunta por pregunta": {"main": [[{"node": "Calcular métricas", "type": "main", "index": 0}], [{"node": "Agente en modo prueba", "type": "main", "index": 0}]]},
    "Agente en modo prueba": {"main": [[{"node": "Armar juicio", "type": "main", "index": 0}]]},
    "Armar juicio": {"main": [[{"node": "Juez Haiku 5.5", "type": "main", "index": 0}]]},
    "Juez Haiku 5.5": {"main": [[{"node": "Pregunta por pregunta", "type": "main", "index": 0}]]},
    "Calcular métricas": {"main": [[{"node": "Guardar corrida", "type": "main", "index": 0}]]},
    "Guardar corrida": {"main": [[{"node": "Publicar en Slack", "type": "main", "index": 0}]]}
  },
  "settings": {"executionOrder": "v1", "timezone": "America/Mexico_City", "executionTimeout": 1800, "saveDataSuccessExecution": "all", "errorWorkflow": "Xe7rTb4mKq9wPz2G"},
  "pinData": {},
  "meta": {"templateCredsSetupCompleted": true}
}

# Lectura del workflow exportado TL Evaluación del agente v1, revisión y dibujo en Python:
workflow = json.loads((carpeta / 'flujos' / 'n8n' / 'evaluacion_agente_v1.json').read_text(encoding = 'utf-8'))

FORMAS = {'manualTrigger': ('disparador', '#1f9d55'), 'scheduleTrigger': ('disparador', '#1f9d55'),
          'executeWorkflowTrigger': ('disparador', '#1f9d55'), 'postgres': ('accion', '#2a78d6'),
          'splitInBatches': ('decision', '#eb6834'), 'executeWorkflow': ('accion', '#2a78d6'),
          'code': ('accion', '#2a78d6'), 'httpRequest': ('accion', '#2a78d6'), 'if': ('decision', '#eb6834')}

def nodos_desde_n8n(wf):
    nodos = [{'id': n['name'], 'tipo': n['type'].split('.')[-1], 'x': n['position'][0] / 100,
              'y': -n['position'][1] / 100, 'ia': bool(re.search(r'claude|anthropic', json.dumps(n['parameters'])))} for n in wf['nodes']]
    aristas = [(o, d['node'], 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 dibujar_flujo(nodos, aristas, titulo):
    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 = FORMAS[n['tipo']]
        color = '#7b4fc9' if n['ia'] else color
        x, y = n['x'], n['y']
        if forma == 'decision':
            ax.add_patch(Polygon([(x - 1.0, y), (x, y + 0.62), (x + 1.0, y), (x, y - 0.62)], 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.8, y - 0.38), 1.6, 0.76, boxstyle = estilo,
                                        facecolor = color, edgecolor = 'white', linewidth = 2))
        etiqueta = textwrap.fill(n['id'], 11 if forma == 'decision' else 15, break_long_words = False)
        ax.text(x, y + 0.08, etiqueta, ha = 'center', va = 'center', color = 'white', fontsize = 8.5)
        ax.text(x, y - 0.27, n['tipo'], ha = 'center', va = 'center', color = 'white', fontsize = 6.5)
    tipos = {n['id']: n['tipo'] for n in nodos}
    for o, d, salida in aristas:
        (x1, y1), (x2, y2) = pos[o], pos[d]
        if tipos[o] == 'splitInBatches':                             # salida 0: terminado; salida 1: bucle
            ax.text(x1 + 0.25, y1 + (0.75 if y2 > y1 else -0.85), 'terminado' if salida == 0 else 'cada pregunta',
                    fontsize = 9, color = '#52514e')
        if tipos[o].endswith('Trigger'):                             # disparadores: flecha directa
            ax.add_patch(FancyArrowPatch((x1 + 0.82, y1), (x2 - 0.86, y2 + 0.15 * np.sign(y1 - y2)),
                                         arrowstyle = '-|>', mutation_scale = 13, color = '#52514e', linewidth = 1.4))
        elif x2 < x1:                                                  # vuelta al bucle
            ax.add_patch(FancyArrowPatch((x1, y1 - 0.4), (x2 + 0.3, y2 - 0.45), arrowstyle = '-|>',
                                         mutation_scale = 13, color = '#eb6834', linewidth = 1.3,
                                         connectionstyle = 'arc3,rad=-0.35'))
        elif abs(y1 - y2) < 0.01:
            ax.add_patch(FancyArrowPatch((x1 + 0.86, y1), (x2 - 0.86, y2), arrowstyle = '-|>', mutation_scale = 13,
                                         color = '#52514e', linewidth = 1.4))
        else:
            ax.add_patch(FancyArrowPatch((x1 + 0.6, y1 + (0.3 if y2 > y1 else -0.3)), (x2 - 0.86, y2),
                                         arrowstyle = '-|>', mutation_scale = 13, color = '#52514e', linewidth = 1.4,
                                         connectionstyle = 'angle,angleA=90,angleB=0,rad=0.1'))
    xs, ys = [p[0] for p in pos.values()], [p[1] for p in pos.values()]
    ax.set_xlim(min(xs) - 1, max(xs) + 1)
    ax.set_ylim(min(ys) - 1.2, max(ys) + 0.9)
    ax.set_aspect('equal')
    ax.axis('off')
    ax.set_title(titulo, fontsize = 14)
    return ax

nodos, aristas = nodos_desde_n8n(workflow)
nombres = {n['id'] for n in nodos}
print('Nodos:', len(nodos), '| conexiones:', len(aristas))
print('Tipos:', pd.Series([n['tipo'] for n in nodos]).value_counts().to_dict())
print('Destinos inexistentes:', [d for _, d, _ in aristas if d not in nombres] or 'ninguno')
print('Nodos sin entrada:', sorted(nombres - {d for _, d, _ in aristas}))
texto_json = json.dumps(workflow, ensure_ascii = False)
print('Parámetros de muestreo:', re.findall(r'temperature|top_p|top_k', texto_json) or 'ninguno',
      '| claves o teléfonos:', re.findall(r'sk-ant-[\w-]+|\+52\d{10}|hooks\.slack\.com/services/\w+', texto_json)
      or 'ninguno')
programa = next(n for n in workflow['nodes'] if n['type'].endswith('scheduleTrigger'))
print('Programación:', programa['parameters']['rule']['interval'][0]['expression'])
dibujar_flujo(nodos, aristas, f"{workflow['name']}, leído del JSON exportado")
plt.tight_layout()
plt.show()