@saulwade/swl-ses 1.0.1 → 1.1.2

package/hooks/lib/text-similarity.js

@@ -0,0 +1,241 @@
+'use strict';
+
+/**
+ * text-similarity.js — utilidades para fuzzy matching en español.
+ *
+ * Cero dependencias. Compatible Node 18+.
+ *
+ * Funciones expuestas:
+ *   - quitarAcentos(texto): normaliza diacríticos preservando ñ
+ *   - tokenizar(texto): divide en palabras (≥1 char)
+ *   - stemES(palabra): stemmer ligero español (Porter-light)
+ *   - levenshtein(a, b): distancia de edición
+ *   - fuzzyContains(haystack, needle, opts): true si needle aparece de forma
+ *     aproximada en haystack
+ *
+ * Diseño:
+ *   - El stemmer remueve UN solo sufijo por palabra (no recursivo).
+ *   - Palabras de ≤3 chars no se stemean.
+ *   - El threshold de Levenshtein es adaptativo: 0 (≤3), 1 (4-7), 2 (8+).
+ *
+ * Origen: ADR 0013 sección 3B (mayo 2026).
+ */
+
+// ---------------------------------------------------------------------------
+// Normalización
+// ---------------------------------------------------------------------------
+
+const COMBINADORES_RE = /[̀-ͯ]/g;
+// ñ y Ñ en NFD se descomponen a n/N + U+0303. Usamos sentinels (caracteres
+// privados de uso +) para preservarlos sin colisión con texto real.
+const N_TILDE_NFD = /ñ/g;
+const N_TILDE_NFD_UPPER = /Ñ/g;
+const SENTINEL_LOWER = '';
+const SENTINEL_UPPER = '';
+
+/**
+ * Remueve acentos preservando ñ. Lowercase y uppercase.
+ * @param {string} texto
+ * @returns {string}
+ */
+function quitarAcentos(texto) {
+  if (!texto) return '';
+  return String(texto)
+    .normalize('NFD')
+    .replace(N_TILDE_NFD, SENTINEL_LOWER)
+    .replace(N_TILDE_NFD_UPPER, SENTINEL_UPPER)
+    .replace(COMBINADORES_RE, '')
+    .replace(new RegExp(SENTINEL_LOWER, 'g'), 'ñ')
+    .replace(new RegExp(SENTINEL_UPPER, 'g'), 'Ñ');
+}
+
+/**
+ * Divide texto en tokens (palabras) preservando solo letras y números.
+ * @param {string} texto
+ * @returns {string[]}
+ */
+function tokenizar(texto) {
+  if (!texto) return [];
+  const matches = String(texto).toLowerCase().match(/[a-záéíóúñü0-9]+/g);
+  return matches || [];
+}
+
+// ---------------------------------------------------------------------------
+// Stemmer Porter-light español
+// ---------------------------------------------------------------------------
+
+/**
+ * Sufijos ordenados de más largo a más corto. El primer match gana.
+ * Cada entry es [sufijo, longitudMinimaResto].
+ * Si la palabra tras quitar el sufijo es < longitudMinimaResto, no se aplica.
+ *
+ * Nota: el sufijo 's' tiene minResto=4 (no 3) para evitar que palabras como
+ * "tres" o "más" se stemmen a stems de 3 chars que generan falsos matches.
+ */
+const SUFIJOS_ES = [
+  // Verbos largos (gerundio + clítico)
+  ['iendolo', 4], ['iendola', 4], ['iendolos', 4], ['iendolas', 4],
+  ['andolo', 4], ['andola', 4], ['andolos', 4], ['andolas', 4],
+  // Sustantivos compuestos
+  ['amientos', 4], ['imientos', 4], ['amiento', 4], ['imiento', 4],
+  // Adjetivos -ación/-ición/-mente
+  ['aciones', 4], ['iciones', 4], ['acion', 4], ['icion', 4],
+  ['mente', 4],
+  // Plurales -dades / abstractos
+  ['idades', 4], ['idad', 4], ['dades', 4], ['dad', 3],
+  // Adjetivos -ico/a + plurales
+  ['icos', 3], ['icas', 3], ['ico', 3], ['ica', 3],
+  // Participios
+  ['ados', 3], ['adas', 3], ['ado', 3], ['ada', 3],
+  ['idos', 3], ['idas', 3], ['ido', 3], ['ida', 3],
+  // Gerundios
+  ['iendo', 3], ['ando', 3],
+  // Plurales / verbos comunes
+  ['ciones', 3], ['cion', 3],
+  // Infinitivos
+  ['ar', 3], ['er', 3], ['ir', 3],
+  // Plurales simples
+  ['es', 3], ['as', 3], ['os', 3],
+  ['s', 4],
+];
+
+/**
+ * Stemmer ligero para español. Remueve UN sufijo por palabra. No recursivo.
+ *
+ * @param {string} palabra
+ * @returns {string} stem normalizado (sin acentos, lowercase)
+ */
+function stemES(palabra) {
+  if (!palabra || palabra.length <= 3) {
+    return palabra ? quitarAcentos(palabra.toLowerCase()) : palabra;
+  }
+
+  const sin = quitarAcentos(palabra.toLowerCase());
+
+  for (const [sufijo, minResto] of SUFIJOS_ES) {
+    if (sin.endsWith(sufijo) && sin.length - sufijo.length >= minResto) {
+      return sin.slice(0, sin.length - sufijo.length);
+    }
+  }
+  return sin;
+}
+
+// ---------------------------------------------------------------------------
+// Distancia de Levenshtein (DP iterativa con dos filas)
+// ---------------------------------------------------------------------------
+
+/**
+ * Distancia de edición clásica. O(min(a,b)) memoria.
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (!a) return b.length;
+  if (!b) return a.length;
+
+  if (a.length > b.length) [a, b] = [b, a];
+
+  let prev = new Array(a.length + 1);
+  let curr = new Array(a.length + 1);
+
+  for (let i = 0; i <= a.length; i++) prev[i] = i;
+
+  for (let j = 1; j <= b.length; j++) {
+    curr[0] = j;
+    for (let i = 1; i <= a.length; i++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[i] = Math.min(
+        curr[i - 1] + 1,
+        prev[i] + 1,
+        prev[i - 1] + cost
+      );
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[a.length];
+}
+
+// ---------------------------------------------------------------------------
+// Fuzzy contains
+// ---------------------------------------------------------------------------
+
+/**
+ * Threshold de Levenshtein adaptativo según longitud de la palabra.
+ * @param {string} palabra
+ * @returns {number}
+ */
+function thresholdAdaptativo(palabra) {
+  if (palabra.length <= 3) return 0;
+  if (palabra.length <= 7) return 1;
+  return 2;
+}
+
+/**
+ * Verifica si `needle` aparece en `haystack` con tolerancia.
+ *
+ * Estrategia (orden):
+ *   1. Match exacto de substring sobre normalizado (sin acentos, lowercase).
+ *   2. Multi-token: cada token del needle debe matchear con algún token del
+ *      haystack vía exacto, stem o Levenshtein.
+ *
+ * @param {string} haystack
+ * @param {string} needle
+ * @param {object} [opts]
+ * @param {boolean} [opts.exact=false] - solo match exacto (sin fuzzy)
+ * @param {boolean} [opts.useStem=true] - aplicar stemming
+ * @param {number}  [opts.threshold=null] - override threshold
+ * @returns {boolean}
+ */
+function fuzzyContains(haystack, needle, opts = {}) {
+  const { exact = false, useStem = true, threshold = null } = opts;
+
+  if (!haystack || !needle) return false;
+
+  const haystackNorm = quitarAcentos(haystack.toLowerCase());
+  const needleNorm = quitarAcentos(needle.toLowerCase());
+
+  if (haystackNorm.includes(needleNorm)) return true;
+  if (exact) return false;
+
+  const needleTokens = tokenizar(needleNorm);
+  const haystackTokens = tokenizar(haystackNorm);
+
+  if (needleTokens.length === 0 || haystackTokens.length === 0) return false;
+
+  return needleTokens.every((nt) =>
+    haystackTokens.some((ht) => coincideToken(ht, nt, useStem, threshold))
+  );
+}
+
+/**
+ * Compara dos tokens individuales con tolerancia.
+ * @param {string} ht
+ * @param {string} nt
+ * @param {boolean} useStem
+ * @param {number|null} threshold
+ * @returns {boolean}
+ */
+function coincideToken(ht, nt, useStem, threshold) {
+  if (ht === nt) return true;
+
+  if (useStem) {
+    const sht = stemES(ht);
+    const snt = stemES(nt);
+    if (sht === snt && sht.length >= 3) return true;
+  }
+
+  const t = threshold !== null ? threshold : thresholdAdaptativo(nt);
+  if (t === 0) return false;
+  return levenshtein(ht, nt) <= t;
+}
+
+module.exports = {
+  quitarAcentos,
+  tokenizar,
+  stemES,
+  levenshtein,
+  fuzzyContains,
+  _internals: { thresholdAdaptativo, coincideToken, SUFIJOS_ES },
+};

package/hooks/metricas-evolucion.js

@@ -45,6 +45,8 @@ const INSTINTOS_PERFIL = path.join(CWD, 'instintos', 'perfil-usuario.yaml');
 const AGENTES_LOG = path.join(CWD, '.planning', 'auto-evolucion', '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
@@ -119,7 +121,171 @@ 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 };
+  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: [],
+  };
 }
 
 // ---------------------------------------------------------------------------
@@ -150,6 +316,7 @@ process.stdin.on('end', () => {
       aprendizajes_totales: contarAprendizajes(),
       agentes: resumenAgentes(),
       evoluciones: resumenEvoluciones(),
+      calidad: resumenCalidad(),
     };
 
     // Health score compuesto (0-100). Útil para dashboard.

package/hooks/monitor-contexto.js

@@ -6,10 +6,23 @@
  * Tipo: PostToolUse
  *
  * Lee el archivo bridge generado por linea-estado.js y emite advertencias
- * cuando el contexto estimado supera umbrales críticos:
+ * cuando el contexto estimado supera umbrales críticos.
  *
- *   ≤ 35% restante (uso ≥ 65%): WARNING  — evitar trabajo complejo
- *   ≤ 25% restante (uso ≥ 75%): CRITICAL — detenerse, guardar estado, compactar
+ * Umbrales por defecto (calibrados con evidencia empírica de
+ * github.com/anthropics/claude-code issue #34685 — degradación detectable
+ * ~20%, auto-compactación de Claude Code dispara ~40%, sweet spot 40-50%):
+ *
+ *   ≥ 40%: WARNING  — degradación detectable, evitar trabajo complejo
+ *   ≥ 55%: CRITICAL — detenerse, guardar estado, compactar
+ *   ≥ 35% en punto natural: sugerencia de compactación proactiva
+ *
+ * Override por env var (útil para experimentos o sesiones cortas):
+ *   SWL_CTX_WARNING       (default 40)
+ *   SWL_CTX_CRITICAL      (default 55)
+ *   SWL_CTX_PROACTIVA     (default 35)
+ *
+ * Histórico: hasta v1.1.0 los umbrales eran 65/75/50. Se bajaron en v1.1.1
+ * tras analizar el issue #34685 que documenta degradación al 20-40%.
  *
  * Debounce: solo emite aviso cada N_DEBOUNCE invocaciones de herramienta.
  * La escalación de severidad (pasar de WARNING a CRITICAL) bypasea el debounce.
@@ -28,11 +41,46 @@ const { phase1_PruneToolResults, shouldCompress } = require('./lib/context-compr
 // Constantes de configuración
 // ---------------------------------------------------------------------------
 
+/**
+ * Lee un umbral numérico desde env var con default. Inválido o fuera de rango
+ * (0-99) → usar default.
+ */
+function umbralEnv(nombre, def) {
+  const valor = parseInt(process.env[nombre] || '', 10);
+  if (Number.isFinite(valor) && valor >= 0 && valor < 100) return valor;
+  return def;
+}
+
+/**
+ * Resuelve los tres umbrales aplicando defaults y validando el invariante de
+ * ordenamiento: PROACTIVA < WARNING < CRITICAL.
+ *
+ * Si los env vars violan el orden (p.ej. WARNING=80 y CRITICAL=50, que haría
+ * CRITICAL inalcanzable lógicamente) o PROACTIVA >= WARNING (haciendo la
+ * sugerencia proactiva inalcanzable), se descarta la configuración inválida
+ * y se usan los defaults para los tres. La fallback es silenciosa porque el
+ * hook nunca debe romper el flujo principal.
+ */
+function resolverUmbrales() {
+  const defaults = { proactiva: 35, warning: 40, critical: 55 };
+
+  const proactiva = umbralEnv('SWL_CTX_PROACTIVA', defaults.proactiva);
+  const warning   = umbralEnv('SWL_CTX_WARNING',   defaults.warning);
+  const critical  = umbralEnv('SWL_CTX_CRITICAL',  defaults.critical);
+
+  if (proactiva < warning && warning < critical) {
+    return { proactiva, warning, critical };
+  }
+  return defaults;
+}
+
+const UMBRALES = resolverUmbrales();
+
 /** Porcentaje de USO a partir del cual se emite WARNING. */
-const UMBRAL_WARNING  = 65;
+const UMBRAL_WARNING  = UMBRALES.warning;
 
 /** Porcentaje de USO a partir del cual se emite CRITICAL. */
-const UMBRAL_CRITICAL = 75;
+const UMBRAL_CRITICAL = UMBRALES.critical;
 
 /**
  * Número de invocaciones de herramienta entre avisos consecutivos del mismo nivel.
@@ -44,7 +92,7 @@ const N_DEBOUNCE = 5;
 const N_COMPACTACION_PROACTIVA = 40;
 
 /** Umbral de uso para activar compactacion proactiva (antes del warning). */
-const UMBRAL_COMPACTACION_PROACTIVA = 50;
+const UMBRAL_COMPACTACION_PROACTIVA = UMBRALES.proactiva;
 
 /**
  * Ruta del archivo de estado interno de este monitor.

package/hooks/preservar-estado-pre-compact.js

@@ -22,6 +22,16 @@
 const fs   = require('fs');
 const path = require('path');
 
+// Atomic write para backups pre-compact (.planning/backups/). Si la
+// compactación interrumpe el backup a media escritura, perdemos el snapshot
+// que precisamente protege el estado pre-compact.
+let atomicWriteJSON;
+try {
+  ({ atomicWriteJSON } = require('./lib/atomic-write'));
+} catch {
+  atomicWriteJSON = (p, o) => fs.writeFileSync(p, JSON.stringify(o, null, 2), 'utf8');
+}
+
 const CWD = process.cwd();
 
 // ---------------------------------------------------------------------------
@@ -124,7 +134,7 @@ process.stdin.on('end', () => {
 
       const ts = new Date().toISOString().replace(/[:.]/g, '-');
       const backupPath = path.join(backupDir, `${nombre}-pre-compact-${ts}.json`);
-      fs.writeFileSync(backupPath, JSON.stringify(datos, null, 2));
+      atomicWriteJSON(backupPath, datos);
 
       // Generar resumen para re-inyección
       if (nombre === 'execution-state') {

package/hooks/risk-scoring.js

@@ -29,6 +29,15 @@ const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
 
+// Atomic write para AUDITORIA.md (creación inicial del log de seguridad).
+// El append posterior usa appendFileSync (seguro). Fallback defensivo.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(__dirname, 'lib', 'atomic-write.js')));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
+
 // Cargar el motor de scoring desde lib/ relativo al directorio de este script
 const { calcularRiskScore, UMBRALES_DEFAULT } = require(
   path.join(__dirname, 'lib', 'risk-engine.js')
@@ -122,7 +131,7 @@ function trackHighOverride(score, factors, toolName) {
       } else {
         const dir = path.dirname(auditPath);
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(auditPath, `# Registro de Auditoría\n\nRegistro automático de operaciones de alto riesgo generado por \`risk-scoring.js\`.\n${auditEntry}`);
+        atomicWriteSync(auditPath, `# Registro de Auditoría\n\nRegistro automático de operaciones de alto riesgo generado por \`risk-scoring.js\`.\n${auditEntry}`, 'utf8');
       }
       state.auditWritten = true;
     } catch { /* no bloquear por fallo de audit */ }

package/hooks/tracking-costos.js

@@ -24,6 +24,15 @@ const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
 
+// Escritura atómica para METRICAS.md (archivo persistente en .planning/).
+// El bridge en /tmp queda en writeFileSync simple — es ephemeral por diseño.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require('./lib/atomic-write'));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
+
 // ---------------------------------------------------------------------------
 // Dependencias internas
 // ---------------------------------------------------------------------------
@@ -552,7 +561,7 @@ function escribirMetrics(estado, presupuesto) {
       fs.mkdirSync(dir, { recursive: true });
     }
     const contenido = generarMetrics(estado, presupuesto);
-    fs.writeFileSync(RUTA_METRICS, contenido, 'utf8');
+    atomicWriteSync(RUTA_METRICS, contenido, 'utf8');
   } catch (err) {
     // Error al escribir METRICAS.md — ignorar silenciosamente
   }