@saulwade/swl-ses 1.8.0 → 2.0.0

package/hooks/{metricas-evolucion.js → lib/etapa-metricas.js}

@@ -1,376 +1,388 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: metricas-evolucion.js
- * Tipo: Stop (async: true — fire-and-forget)
- *
- * Cada sesión consolida métricas del ciclo de evolución y actualiza
- * .planning/evolution/metricas.json con:
- *   - nudges emitidos / accionados / pendientes (14d)
- *   - tasa de acción por tipo de nudge
- *   - instintos populados vs capacidad
- *   - evoluciones aplicadas (del log de /swl:evolucionar)
- *   - fallos vs éxitos de agentes en 14d
- *   - alertas persistentes activas
- *
- * Además dispara escalarSiAplica() del nudge-tracker.
- *
- * El hook nunca bloquea (siempre exit 0). Zero-deps.
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-let atomicWriteJSON;
-try {
-  ({ atomicWriteJSON } = require('./lib/atomic-write'));
-} catch {
-  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
-}
-
-let nudgeTracker;
-try {
-  nudgeTracker = require('./lib/nudge-tracker');
-} catch {
-  nudgeTracker = null;
-}
-
-const CWD = process.cwd();
-const DIR_EVOL = path.join(CWD, '.planning', 'evolution');
-const METRICAS_PATH = path.join(DIR_EVOL, 'metricas.json');
-const INSTINTOS_PROYECTO = path.join(CWD, 'instintos', 'proyecto.yaml');
-const INSTINTOS_GLOBAL = path.join(CWD, 'instintos', 'global.yaml');
-const INSTINTOS_PERFIL = path.join(CWD, 'instintos', 'perfil-usuario.yaml');
-const AGENTES_LOG = path.join(CWD, '.planning', 'auto-evolution', 'agentes.jsonl');
-const APRENDIZAJES = path.join(CWD, '.planning', 'APRENDIZAJES.md');
-const EVOLUCIONES_LOG = path.join(DIR_EVOL, 'evoluciones.jsonl');
-const MEMORY_USAGE_LOG = path.join(DIR_EVOL, 'memory-usage.jsonl');
-const FORMATO_VIOLACIONES_LOG = path.join(DIR_EVOL, 'formato-violaciones.jsonl');
-
-// ---------------------------------------------------------------------------
-// Utilidades
-// ---------------------------------------------------------------------------
-
-function ensureDir() {
-  try { fs.mkdirSync(DIR_EVOL, { recursive: true }); } catch { /* ignore */ }
-}
-
-function contarInstintos(archivo) {
-  try {
-    const c = fs.readFileSync(archivo, 'utf8');
-    const m = c.match(/^total_instintos:\s*(\d+)/m);
-    if (m) return parseInt(m[1], 10);
-    // Fallback: contar entries `- id:`
-    const entries = c.match(/^\s*- id:\s*\S+/gm);
-    return entries ? entries.length : 0;
-  } catch {
-    return 0;
-  }
-}
-
-function contarAprendizajes() {
-  try {
-    const c = fs.readFileSync(APRENDIZAJES, 'utf8');
-    const headers = c.match(/^##\s+\[\d{4}-\d{2}-\d{2}\]/gm);
-    return headers ? headers.length : 0;
-  } catch {
-    return 0;
-  }
-}
-
-function leerJsonl(p, dias = 14) {
-  try {
-    const limite = Date.now() - dias * 24 * 3600 * 1000;
-    return fs.readFileSync(p, 'utf8')
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map(l => { try { return JSON.parse(l); } catch { return null; } })
-      .filter(e => {
-        if (!e) return false;
-        const t = Date.parse(e.ts);
-        return Number.isFinite(t) && t >= limite;
-      });
-  } catch {
-    return [];
-  }
-}
-
-function resumenAgentes() {
-  const entries = leerJsonl(AGENTES_LOG, 14);
-  const porAgente = {};
-  for (const e of entries) {
-    if (!porAgente[e.agente]) porAgente[e.agente] = { runs: 0, fallos: 0, triviales: 0 };
-    if (e.trivial) porAgente[e.agente].triviales++;
-    else {
-      porAgente[e.agente].runs++;
-      if (e.status === 'failed') porAgente[e.agente].fallos++;
-    }
-  }
-  const totalRuns = entries.filter(e => !e.trivial).length;
-  const totalFallos = entries.filter(e => !e.trivial && e.status === 'failed').length;
-  return {
-    totalRuns,
-    totalFallos,
-    tasaExito: totalRuns > 0 ? Math.round((1 - totalFallos / totalRuns) * 1000) / 10 : null,
-    porAgente,
-  };
-}
-
-function resumenEvoluciones() {
-  const entries = leerJsonl(EVOLUCIONES_LOG, 30);
-  const aplicadas = entries.filter(e => e.tipo === 'aplicada').length;
-  const revertidas = entries.filter(e => e.tipo === 'revertida').length;
-  return {
-    aplicadas,
-    revertidas,
-    neta: aplicadas - revertidas,
-    rollbackRatio: aplicadas > 0 ? Math.round((revertidas / aplicadas) * 1000) / 10 : null,
-  };
-}
-
-/**
- * Métricas de calidad real (telemetría conductual, no estructural).
- *
- * Calculables desde fuentes ya disponibles en el sistema:
- *   - Tasa de fallos por tipo (tipo_fallo en agentes.jsonl).
- *   - Reintentos consecutivos del mismo agente sobre la misma tarea.
- *   - Latencia mediana y p95 por agente.
- *   - Rollback ratio (ya calculado en resumenEvoluciones).
- *
- * Pendientes de instrumentación (no se calculan aún — placeholder):
- *   - Precisión de routing por fase/dominio (requiere ground truth).
- *   - Utilidad de memoria recuperada (requiere feedback explícito).
- *   - Violaciones de formato post-ejecución (requiere validador post-ejec).
- */
-function resumenCalidad() {
-  const entries = leerJsonl(AGENTES_LOG, 14);
-  const noTriviales = entries.filter(e => !e.trivial);
-
-  // Tasa de fallos por tipo
-  const fallosPorTipo = {};
-  for (const e of noTriviales) {
-    if (e.status === 'failed' && e.tipo_fallo) {
-      fallosPorTipo[e.tipo_fallo] = (fallosPorTipo[e.tipo_fallo] || 0) + 1;
-    }
-  }
-
-  // Reintentos consecutivos: mismo agente + misma task_id en ventana de 30 min
-  const reintentos = {};
-  const VENTANA_REINTENTO_MS = 30 * 60 * 1000;
-  const sortedByTime = [...noTriviales].sort((a, b) => Date.parse(a.ts || 0) - Date.parse(b.ts || 0));
-  for (let i = 1; i < sortedByTime.length; i++) {
-    const prev = sortedByTime[i - 1];
-    const curr = sortedByTime[i];
-    if (prev.agente !== curr.agente) continue;
-    const taskPrev = prev.task_id || prev.taskId || null;
-    const taskCurr = curr.task_id || curr.taskId || null;
-    if (!taskPrev || taskPrev !== taskCurr) continue;
-    const dt = Date.parse(curr.ts) - Date.parse(prev.ts);
-    if (dt > 0 && dt < VENTANA_REINTENTO_MS) {
-      reintentos[curr.agente] = (reintentos[curr.agente] || 0) + 1;
-    }
-  }
-  const reintentosTotal = Object.values(reintentos).reduce((a, b) => a + b, 0);
-
-  // Latencia por agente (mediana + p95)
-  const latenciasPorAgente = {};
-  for (const e of noTriviales) {
-    if (typeof e.duracion_ms !== 'number') continue;
-    if (!latenciasPorAgente[e.agente]) latenciasPorAgente[e.agente] = [];
-    latenciasPorAgente[e.agente].push(e.duracion_ms);
-  }
-  const latencia = {};
-  for (const [ag, arr] of Object.entries(latenciasPorAgente)) {
-    arr.sort((a, b) => a - b);
-    const mediana = arr[Math.floor(arr.length / 2)];
-    const p95Idx = Math.min(arr.length - 1, Math.floor(arr.length * 0.95));
-    latencia[ag] = { medianaMs: mediana, p95Ms: arr[p95Idx], n: arr.length };
-  }
-
-  // Routing precision por celda (fase, dominio) — proxy basado en
-  // tasa de éxito del agente invocado en cada celda. Una celda con
-  // tasa baja sugiere routing impreciso.
-  const routingCells = {};
-  for (const e of noTriviales) {
-    if (!e.routed_phase || !e.routed_domain) continue;
-    const key = `${e.routed_phase}/${e.routed_domain}`;
-    if (!routingCells[key]) {
-      routingCells[key] = { runs: 0, fallos: 0, agentes: new Set() };
-    }
-    routingCells[key].runs += 1;
-    routingCells[key].agentes.add(e.agente);
-    if (e.status === 'failed') routingCells[key].fallos += 1;
-  }
-  const precisionRouting = {};
-  for (const [key, datos] of Object.entries(routingCells)) {
-    const tasaExito = datos.runs > 0
-      ? Math.round((1 - datos.fallos / datos.runs) * 1000) / 10
-      : null;
-    precisionRouting[key] = {
-      runs:      datos.runs,
-      fallos:    datos.fallos,
-      tasaExito: tasaExito,
-      agentes:   [...datos.agentes],
-    };
-  }
-
-  // Utilidad de memoria recuperada (proxy):
-  //   - Tasa de búsquedas con resultsCount > 0 vs total
-  //   - Tasa de búsquedas con ≥3 resultados (umbral de "útil de verdad")
-  //   - Distribución por operación (search/timeline/fetch)
-  const memoryEntries = leerJsonl(MEMORY_USAGE_LOG, 14);
-  const utilidadMemoria = {
-    totalInvocaciones: memoryEntries.length,
-    porOperacion: { search: 0, timeline: 0, fetch: 0 },
-    conResultados: 0,
-    conResultadosRicos: 0, // ≥3
-    tasaConResultados: null,
-    tasaResultadosRicos: null,
-  };
-  for (const e of memoryEntries) {
-    if (utilidadMemoria.porOperacion[e.op] !== undefined) {
-      utilidadMemoria.porOperacion[e.op] += 1;
-    }
-    const n = Number(e.resultsCount) || 0;
-    if (n > 0) utilidadMemoria.conResultados += 1;
-    if (n >= 3) utilidadMemoria.conResultadosRicos += 1;
-  }
-  if (utilidadMemoria.totalInvocaciones > 0) {
-    utilidadMemoria.tasaConResultados = Math.round(
-      (utilidadMemoria.conResultados / utilidadMemoria.totalInvocaciones) * 1000,
-    ) / 10;
-    utilidadMemoria.tasaResultadosRicos = Math.round(
-      (utilidadMemoria.conResultadosRicos / utilidadMemoria.totalInvocaciones) * 1000,
-    ) / 10;
-  }
-
-  // Violaciones de formato post-ejecución (cuando un agente termina, el
-  // hook validar-formato-post-subagente.js compara el output contra el
-  // schema declarado y registra violaciones).
-  const formatoEntries = leerJsonl(FORMATO_VIOLACIONES_LOG, 14);
-  const violacionesFormato = {
-    totalEvaluadas: 0,
-    totalViolaciones: 0,
-    porAgente: {},
-    tasaViolacion: null,
-  };
-  for (const e of formatoEntries) {
-    if (!e.agente) continue;
-    if (!violacionesFormato.porAgente[e.agente]) {
-      violacionesFormato.porAgente[e.agente] = { evaluadas: 0, violaciones: 0 };
-    }
-    violacionesFormato.porAgente[e.agente].evaluadas += 1;
-    violacionesFormato.totalEvaluadas += 1;
-    if (e.violation === true || (Array.isArray(e.errors) && e.errors.length > 0)) {
-      violacionesFormato.porAgente[e.agente].violaciones += 1;
-      violacionesFormato.totalViolaciones += 1;
-    }
-  }
-  if (violacionesFormato.totalEvaluadas > 0) {
-    violacionesFormato.tasaViolacion = Math.round(
-      (violacionesFormato.totalViolaciones / violacionesFormato.totalEvaluadas) * 1000,
-    ) / 10;
-  }
-
-  return {
-    fallosPorTipo,
-    reintentos: {
-      total: reintentosTotal,
-      porAgente: reintentos,
-      ventanaMin: 30,
-    },
-    latencia,
-    precisionRouting,
-    utilidadMemoria,
-    violacionesFormato,
-    pendientesInstrumentacion: [],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Entrypoint
-// ---------------------------------------------------------------------------
-
-let inputRaw = '';
-process.stdin.on('data', chunk => { inputRaw += chunk; });
-
-process.stdin.on('end', () => {
-  try {
-    ensureDir();
-
-    const nudges = nudgeTracker ? nudgeTracker.resumen({ dias: 14 }) : null;
-    if (nudgeTracker) {
-      try { nudgeTracker.escalarSiAplica({ threshold: 5 }); } catch { /* ignore */ }
-    }
-
-    const metricas = {
-      generado: new Date().toISOString(),
-      ventana_dias: 14,
-      nudges: nudges || { total: 0, accionados: 0, pendientes: 0 },
-      instintos: {
-        proyecto: contarInstintos(INSTINTOS_PROYECTO),
-        global:   contarInstintos(INSTINTOS_GLOBAL),
-        perfil:   contarInstintos(INSTINTOS_PERFIL),
-      },
-      aprendizajes_totales: contarAprendizajes(),
-      agentes: resumenAgentes(),
-      evoluciones: resumenEvoluciones(),
-      calidad: resumenCalidad(),
-    };
-
-    // Health score compuesto (0-100). Útil para dashboard.
-    metricas.health_score = calcularHealthScore(metricas);
-
-    atomicWriteJSON(METRICAS_PATH, metricas);
-  } catch {
-    // Nunca bloquear por error interno
-  }
-});
-
-/**
- * Health score compuesto del ciclo de evolución (0-100).
- *
- * Componentes (pesos):
- *   - Tasa de acción de nudges (30%): accionados / total
- *   - Densidad de instintos (20%): sum vs capacidad objetivo (20 proyecto + 5 global)
- *   - Tasa de éxito de agentes (30%): (runs - fallos) / runs
- *   - Evoluciones netas positivas (10%): aplicadas - revertidas
- *   - Ausencia de alertas persistentes (10%): -5pt por cada alerta activa
- */
-function calcularHealthScore(m) {
-  let score = 0;
-
-  // Nudges (30pt)
-  if (m.nudges.total > 0) {
-    score += Math.round(m.nudges.accionados / m.nudges.total * 30);
-  } else {
-    score += 15; // sin nudges = neutral
-  }
-
-  // Instintos (20pt) — objetivo: 20 proyecto + 5 global
-  const totalInst = m.instintos.proyecto + m.instintos.global;
-  const objetivo = 25;
-  score += Math.min(20, Math.round(totalInst / objetivo * 20));
-
-  // Agentes (30pt)
-  if (m.agentes.totalRuns > 0) {
-    score += Math.round(m.agentes.tasaExito / 100 * 30);
-  } else {
-    score += 15;
-  }
-
-  // Evoluciones (10pt)
-  if (m.evoluciones.aplicadas > 0) {
-    const netaRatio = Math.max(0, m.evoluciones.neta / m.evoluciones.aplicadas);
-    score += Math.round(netaRatio * 10);
-  } else {
-    score += 5;
-  }
-
-  // Alertas (10pt)
-  const alertas = (m.nudges.alertasActivas || []).length;
-  score += Math.max(0, 10 - alertas * 5);
-
-  return Math.min(100, Math.max(0, score));
-}
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: metricas-evolucion.js
+ * Tipo: Stop (async: true — fire-and-forget)
+ *
+ * Cada sesión consolida métricas del ciclo de evolución y actualiza
+ * .planning/evolution/metricas.json con:
+ *   - nudges emitidos / accionados / pendientes (14d)
+ *   - tasa de acción por tipo de nudge
+ *   - instintos populados vs capacidad
+ *   - evoluciones aplicadas (del log de /swl:evolucionar)
+ *   - fallos vs éxitos de agentes en 14d
+ *   - alertas persistentes activas
+ *
+ * Además dispara escalarSiAplica() del nudge-tracker.
+ *
+ * El hook nunca bloquea (siempre exit 0). Zero-deps.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+let atomicWriteJSON;
+try {
+  ({ atomicWriteJSON } = require('./atomic-write'));
+} catch {
+  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
+}
+
+let nudgeTracker;
+try {
+  nudgeTracker = require('./nudge-tracker');
+} catch {
+  nudgeTracker = null;
+}
+
+const CWD = process.cwd();
+const DIR_EVOL = path.join(CWD, '.planning', 'evolution');
+const METRICAS_PATH = path.join(DIR_EVOL, 'metricas.json');
+const INSTINTOS_PROYECTO = path.join(CWD, 'instintos', 'proyecto.yaml');
+const INSTINTOS_GLOBAL = path.join(CWD, 'instintos', 'global.yaml');
+const INSTINTOS_PERFIL = path.join(CWD, 'instintos', 'perfil-usuario.yaml');
+const AGENTES_LOG = path.join(CWD, '.planning', 'auto-evolution', 'agentes.jsonl');
+const APRENDIZAJES = path.join(CWD, '.planning', 'APRENDIZAJES.md');
+const EVOLUCIONES_LOG = path.join(DIR_EVOL, 'evoluciones.jsonl');
+const MEMORY_USAGE_LOG = path.join(DIR_EVOL, 'memory-usage.jsonl');
+const FORMATO_VIOLACIONES_LOG = path.join(DIR_EVOL, 'formato-violaciones.jsonl');
+
+// ---------------------------------------------------------------------------
+// Utilidades
+// ---------------------------------------------------------------------------
+
+function ensureDir() {
+  try { fs.mkdirSync(DIR_EVOL, { recursive: true }); } catch { /* ignore */ }
+}
+
+function contarInstintos(archivo) {
+  try {
+    const c = fs.readFileSync(archivo, 'utf8');
+    const m = c.match(/^total_instintos:\s*(\d+)/m);
+    if (m) return parseInt(m[1], 10);
+    // Fallback: contar entries `- id:`
+    const entries = c.match(/^\s*- id:\s*\S+/gm);
+    return entries ? entries.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function contarAprendizajes() {
+  try {
+    const c = fs.readFileSync(APRENDIZAJES, 'utf8');
+    const headers = c.match(/^##\s+\[\d{4}-\d{2}-\d{2}\]/gm);
+    return headers ? headers.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function leerJsonl(p, dias = 14) {
+  try {
+    const limite = Date.now() - dias * 24 * 3600 * 1000;
+    return fs.readFileSync(p, 'utf8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(e => {
+        if (!e) return false;
+        const t = Date.parse(e.ts);
+        return Number.isFinite(t) && t >= limite;
+      });
+  } catch {
+    return [];
+  }
+}
+
+function resumenAgentes() {
+  const entries = leerJsonl(AGENTES_LOG, 14);
+  const porAgente = {};
+  for (const e of entries) {
+    if (!porAgente[e.agente]) porAgente[e.agente] = { runs: 0, fallos: 0, triviales: 0 };
+    if (e.trivial) porAgente[e.agente].triviales++;
+    else {
+      porAgente[e.agente].runs++;
+      if (e.status === 'failed') porAgente[e.agente].fallos++;
+    }
+  }
+  const totalRuns = entries.filter(e => !e.trivial).length;
+  const totalFallos = entries.filter(e => !e.trivial && e.status === 'failed').length;
+  return {
+    totalRuns,
+    totalFallos,
+    tasaExito: totalRuns > 0 ? Math.round((1 - totalFallos / totalRuns) * 1000) / 10 : null,
+    porAgente,
+  };
+}
+
+function resumenEvoluciones() {
+  const entries = leerJsonl(EVOLUCIONES_LOG, 30);
+  const aplicadas = entries.filter(e => e.tipo === 'aplicada').length;
+  const revertidas = entries.filter(e => e.tipo === 'revertida').length;
+  return {
+    aplicadas,
+    revertidas,
+    neta: aplicadas - revertidas,
+    rollbackRatio: aplicadas > 0 ? Math.round((revertidas / aplicadas) * 1000) / 10 : null,
+  };
+}
+
+/**
+ * Métricas de calidad real (telemetría conductual, no estructural).
+ *
+ * Calculables desde fuentes ya disponibles en el sistema:
+ *   - Tasa de fallos por tipo (tipo_fallo en agentes.jsonl).
+ *   - Reintentos consecutivos del mismo agente sobre la misma tarea.
+ *   - Latencia mediana y p95 por agente.
+ *   - Rollback ratio (ya calculado en resumenEvoluciones).
+ *
+ * Pendientes de instrumentación (no se calculan aún — placeholder):
+ *   - Precisión de routing por fase/dominio (requiere ground truth).
+ *   - Utilidad de memoria recuperada (requiere feedback explícito).
+ *   - Violaciones de formato post-ejecución (requiere validador post-ejec).
+ */
+function resumenCalidad() {
+  const entries = leerJsonl(AGENTES_LOG, 14);
+  const noTriviales = entries.filter(e => !e.trivial);
+
+  // Tasa de fallos por tipo
+  const fallosPorTipo = {};
+  for (const e of noTriviales) {
+    if (e.status === 'failed' && e.tipo_fallo) {
+      fallosPorTipo[e.tipo_fallo] = (fallosPorTipo[e.tipo_fallo] || 0) + 1;
+    }
+  }
+
+  // Reintentos consecutivos: mismo agente + misma task_id en ventana de 30 min
+  const reintentos = {};
+  const VENTANA_REINTENTO_MS = 30 * 60 * 1000;
+  const sortedByTime = [...noTriviales].sort((a, b) => Date.parse(a.ts || 0) - Date.parse(b.ts || 0));
+  for (let i = 1; i < sortedByTime.length; i++) {
+    const prev = sortedByTime[i - 1];
+    const curr = sortedByTime[i];
+    if (prev.agente !== curr.agente) continue;
+    const taskPrev = prev.task_id || prev.taskId || null;
+    const taskCurr = curr.task_id || curr.taskId || null;
+    if (!taskPrev || taskPrev !== taskCurr) continue;
+    const dt = Date.parse(curr.ts) - Date.parse(prev.ts);
+    if (dt > 0 && dt < VENTANA_REINTENTO_MS) {
+      reintentos[curr.agente] = (reintentos[curr.agente] || 0) + 1;
+    }
+  }
+  const reintentosTotal = Object.values(reintentos).reduce((a, b) => a + b, 0);
+
+  // Latencia por agente (mediana + p95)
+  const latenciasPorAgente = {};
+  for (const e of noTriviales) {
+    if (typeof e.duracion_ms !== 'number') continue;
+    if (!latenciasPorAgente[e.agente]) latenciasPorAgente[e.agente] = [];
+    latenciasPorAgente[e.agente].push(e.duracion_ms);
+  }
+  const latencia = {};
+  for (const [ag, arr] of Object.entries(latenciasPorAgente)) {
+    arr.sort((a, b) => a - b);
+    const mediana = arr[Math.floor(arr.length / 2)];
+    const p95Idx = Math.min(arr.length - 1, Math.floor(arr.length * 0.95));
+    latencia[ag] = { medianaMs: mediana, p95Ms: arr[p95Idx], n: arr.length };
+  }
+
+  // Routing precision por celda (fase, dominio) — proxy basado en
+  // tasa de éxito del agente invocado en cada celda. Una celda con
+  // tasa baja sugiere routing impreciso.
+  const routingCells = {};
+  for (const e of noTriviales) {
+    if (!e.routed_phase || !e.routed_domain) continue;
+    const key = `${e.routed_phase}/${e.routed_domain}`;
+    if (!routingCells[key]) {
+      routingCells[key] = { runs: 0, fallos: 0, agentes: new Set() };
+    }
+    routingCells[key].runs += 1;
+    routingCells[key].agentes.add(e.agente);
+    if (e.status === 'failed') routingCells[key].fallos += 1;
+  }
+  const precisionRouting = {};
+  for (const [key, datos] of Object.entries(routingCells)) {
+    const tasaExito = datos.runs > 0
+      ? Math.round((1 - datos.fallos / datos.runs) * 1000) / 10
+      : null;
+    precisionRouting[key] = {
+      runs:      datos.runs,
+      fallos:    datos.fallos,
+      tasaExito: tasaExito,
+      agentes:   [...datos.agentes],
+    };
+  }
+
+  // Utilidad de memoria recuperada (proxy):
+  //   - Tasa de búsquedas con resultsCount > 0 vs total
+  //   - Tasa de búsquedas con ≥3 resultados (umbral de "útil de verdad")
+  //   - Distribución por operación (search/timeline/fetch)
+  const memoryEntries = leerJsonl(MEMORY_USAGE_LOG, 14);
+  const utilidadMemoria = {
+    totalInvocaciones: memoryEntries.length,
+    porOperacion: { search: 0, timeline: 0, fetch: 0 },
+    conResultados: 0,
+    conResultadosRicos: 0, // ≥3
+    tasaConResultados: null,
+    tasaResultadosRicos: null,
+  };
+  for (const e of memoryEntries) {
+    if (utilidadMemoria.porOperacion[e.op] !== undefined) {
+      utilidadMemoria.porOperacion[e.op] += 1;
+    }
+    const n = Number(e.resultsCount) || 0;
+    if (n > 0) utilidadMemoria.conResultados += 1;
+    if (n >= 3) utilidadMemoria.conResultadosRicos += 1;
+  }
+  if (utilidadMemoria.totalInvocaciones > 0) {
+    utilidadMemoria.tasaConResultados = Math.round(
+      (utilidadMemoria.conResultados / utilidadMemoria.totalInvocaciones) * 1000,
+    ) / 10;
+    utilidadMemoria.tasaResultadosRicos = Math.round(
+      (utilidadMemoria.conResultadosRicos / utilidadMemoria.totalInvocaciones) * 1000,
+    ) / 10;
+  }
+
+  // Violaciones de formato post-ejecución (cuando un agente termina, el
+  // hook validar-formato-post-subagente.js compara el output contra el
+  // schema declarado y registra violaciones).
+  const formatoEntries = leerJsonl(FORMATO_VIOLACIONES_LOG, 14);
+  const violacionesFormato = {
+    totalEvaluadas: 0,
+    totalViolaciones: 0,
+    porAgente: {},
+    tasaViolacion: null,
+  };
+  for (const e of formatoEntries) {
+    if (!e.agente) continue;
+    if (!violacionesFormato.porAgente[e.agente]) {
+      violacionesFormato.porAgente[e.agente] = { evaluadas: 0, violaciones: 0 };
+    }
+    violacionesFormato.porAgente[e.agente].evaluadas += 1;
+    violacionesFormato.totalEvaluadas += 1;
+    if (e.violation === true || (Array.isArray(e.errors) && e.errors.length > 0)) {
+      violacionesFormato.porAgente[e.agente].violaciones += 1;
+      violacionesFormato.totalViolaciones += 1;
+    }
+  }
+  if (violacionesFormato.totalEvaluadas > 0) {
+    violacionesFormato.tasaViolacion = Math.round(
+      (violacionesFormato.totalViolaciones / violacionesFormato.totalEvaluadas) * 1000,
+    ) / 10;
+  }
+
+  return {
+    fallosPorTipo,
+    reintentos: {
+      total: reintentosTotal,
+      porAgente: reintentos,
+      ventanaMin: 30,
+    },
+    latencia,
+    precisionRouting,
+    utilidadMemoria,
+    violacionesFormato,
+    pendientesInstrumentacion: [],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+/**
+ * Etapa de métricas del ciclo de evolución (sub-etapa de hooks/ciclo-evolucion.js).
+ * No consume la transcripción de stdin — solo lee archivos del proyecto.
+ * Best-effort: nunca lanza.
+ * @param {string} [_inputRaw] ignorado (firma uniforme con las otras etapas)
+ */
+function ejecutar(_inputRaw) {
+  try {
+    ensureDir();
+
+    const nudges = nudgeTracker ? nudgeTracker.resumen({ dias: 14 }) : null;
+    if (nudgeTracker) {
+      try { nudgeTracker.escalarSiAplica({ threshold: 5 }); } catch { /* ignore */ }
+    }
+
+    const metricas = {
+      generado: new Date().toISOString(),
+      ventana_dias: 14,
+      nudges: nudges || { total: 0, accionados: 0, pendientes: 0 },
+      instintos: {
+        proyecto: contarInstintos(INSTINTOS_PROYECTO),
+        global:   contarInstintos(INSTINTOS_GLOBAL),
+        perfil:   contarInstintos(INSTINTOS_PERFIL),
+      },
+      aprendizajes_totales: contarAprendizajes(),
+      agentes: resumenAgentes(),
+      evoluciones: resumenEvoluciones(),
+      calidad: resumenCalidad(),
+    };
+
+    // Health score compuesto (0-100). Útil para dashboard.
+    metricas.health_score = calcularHealthScore(metricas);
+
+    atomicWriteJSON(METRICAS_PATH, metricas);
+  } catch {
+    // Nunca bloquear por error interno
+  }
+}
+
+module.exports = { ejecutar, calcularHealthScore };
+
+// Ejecución directa (compat: sigue invocable standalone para diagnóstico).
+if (require.main === module) {
+  let inputRaw = '';
+  process.stdin.on('data', chunk => { inputRaw += chunk; });
+  process.stdin.on('end', () => ejecutar(inputRaw));
+}
+
+/**
+ * Health score compuesto del ciclo de evolución (0-100).
+ *
+ * Componentes (pesos):
+ *   - Tasa de acción de nudges (30%): accionados / total
+ *   - Densidad de instintos (20%): sum vs capacidad objetivo (20 proyecto + 5 global)
+ *   - Tasa de éxito de agentes (30%): (runs - fallos) / runs
+ *   - Evoluciones netas positivas (10%): aplicadas - revertidas
+ *   - Ausencia de alertas persistentes (10%): -5pt por cada alerta activa
+ */
+function calcularHealthScore(m) {
+  let score = 0;
+
+  // Nudges (30pt)
+  if (m.nudges.total > 0) {
+    score += Math.round(m.nudges.accionados / m.nudges.total * 30);
+  } else {
+    score += 15; // sin nudges = neutral
+  }
+
+  // Instintos (20pt) — objetivo: 20 proyecto + 5 global
+  const totalInst = m.instintos.proyecto + m.instintos.global;
+  const objetivo = 25;
+  score += Math.min(20, Math.round(totalInst / objetivo * 20));
+
+  // Agentes (30pt)
+  if (m.agentes.totalRuns > 0) {
+    score += Math.round(m.agentes.tasaExito / 100 * 30);
+  } else {
+    score += 15;
+  }
+
+  // Evoluciones (10pt)
+  if (m.evoluciones.aplicadas > 0) {
+    const netaRatio = Math.max(0, m.evoluciones.neta / m.evoluciones.aplicadas);
+    score += Math.round(netaRatio * 10);
+  } else {
+    score += 5;
+  }
+
+  // Alertas (10pt)
+  const alertas = (m.nudges.alertasActivas || []).length;
+  score += Math.max(0, 10 - alertas * 5);
+
+  return Math.min(100, Math.max(0, score));
+}