@saulwade/swl-ses 2.5.3 → 2.6.0

package/scripts/rotar-audit-logs.js

@@ -24,6 +24,19 @@
 const fs = require('fs');
 const path = require('path');
 const zlib = require('zlib');
+// Escritura atómica (CLAUDE.md § Code style): truncar el archivo de auditoría
+// con writeFileSync plano puede corromperlo si la rotación se interrumpe a
+// mitad (nemesis iter-1 S3-4). Require tolerante: repo madre vs destino aplanado.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(__dirname, '..', 'hooks', 'lib', 'atomic-write.js')));
+} catch {
+  try {
+    ({ atomicWriteSync } = require(path.join(__dirname, 'atomic-write.js')));
+  } catch {
+    atomicWriteSync = (ruta, contenido) => fs.writeFileSync(ruta, contenido);
+  }
+}
 
 const ARGS = process.argv.slice(2);
 const DRY_RUN = ARGS.includes('--dry-run');
@@ -38,7 +51,9 @@ const ARCHIVOS = [
   { nombre: 'audit-merkle', ruta: path.join(RAIZ, 'audit-merkle.jsonl'), campoTs: 'ts' },
 ];
 
-const DESTINO_DIR = path.join(RAIZ, 'archivo', 'audit');
+// Canónico post-ADR-0031: dirs runtime de .planning/ en inglés ('archive',
+// no 'archivo'). El shim del instalador § 6c-bis migra los dirs viejos.
+const DESTINO_DIR = path.join(RAIZ, 'archive', 'audit');
 
 function ahoraMs() {
   return Date.now();
@@ -85,7 +100,10 @@ function appendGzipped(destinoPath, lineas) {
 
 function escribirActivo(ruta, lineas) {
   const contenido = lineas.length > 0 ? lineas.join('\n') + '\n' : '';
-  fs.writeFileSync(ruta, contenido, { encoding: 'utf8' });
+  // Atómico: si el proceso muere a mitad, el archivo activo queda íntegro
+  // (la versión previa o la nueva completa, nunca truncado). Los .gz de los
+  // grupos-mes se escriben ANTES de esta truncación (orden en rotarArchivo).
+  atomicWriteSync(ruta, contenido);
 }
 
 function rotarArchivo(spec) {
@@ -133,6 +151,34 @@ function rotarArchivo(spec) {
       const destinoPath = path.join(DESTINO_DIR, `${spec.nombre}-${mesKey}.jsonl.gz`);
       appendGzipped(destinoPath, lineas);
     }
+    // Checkpoint de cadena Merkle (nemesis iter-1 S3-5): tras truncar, el
+    // archivo activo empieza en una entrada cuyo `prev` apunta a una entrada
+    // ya archivada (no al génesis). Persistir ese `prev` como `hashInicial`
+    // permite a verificarCadena(activo, {hashInicial}) validar el activo como
+    // continuación de la cadena archivada, sin falso positivo de rotura.
+    // Solo aplica a archivos encadenados (la primera retenida trae `prev`).
+    if (retenidas.length > 0) {
+      // leerJSONL ya parseó cada registro en `.obj` — sin re-parse.
+      const primeraRetenida = retenidas[0].obj;
+      if (primeraRetenida && typeof primeraRetenida.prev === 'string') {
+        const checkpointPath = path.join(DESTINO_DIR, `.checkpoint-${spec.nombre}.json`);
+        // `hashInicial` = prev de la 1a retenida = hash de la ÚLTIMA archivada.
+        // NOTA para un consumidor productivo: este checkpoint es un ANCLA de
+        // conveniencia, NO una raíz de confianza. verificarCadena(activo,
+        // {hashInicial}) prueba la consistencia INTERNA del activo, no que
+        // continúe la cadena archivada — para eso el consumidor debe recomputar
+        // el hash de la última entrada del .gz y compararlo con este hashInicial
+        // (re-auditoría nemesis iter-2). Coherente con el modelo pre-existente
+        // (SHA256 sin clave, sin raíz publicada).
+        atomicWriteSync(checkpointPath, JSON.stringify({
+          archivo: spec.nombre,
+          hashInicial: primeraRetenida.prev,
+          archivadas: archivadas.length,
+          // Fecha LOCAL (no UTC) — clase C1.
+          rotado: new Date().toLocaleDateString('sv'),
+        }, null, 2) + '\n');
+      }
+    }
     escribirActivo(spec.ruta, retenidas.map((r) => r.raw));
   }
 

package/scripts/run-eval.js

@@ -138,4 +138,5 @@ if (require.main === module) {
 
 module.exports = {
   ejecutarEval,
+  main,
 };

package/scripts/run-skill-evals.js

@@ -15,8 +15,10 @@
  *   node scripts/run-skill-evals.js <nombre-skill>                  — imprime plan
  *   node scripts/run-skill-evals.js <nombre-skill> --json           — plan JSON
  *   node scripts/run-skill-evals.js <nombre-skill> --record-baseline --score=N
- *   node scripts/run-skill-evals.js <nombre-skill> --record-after --score=N \
- *       [--hypothesis="razon-causal"] [--check-invariants]
+ *   node scripts/run-skill-evals.js <nombre-skill> --emitir-evaluacion \
+ *       --score=N --producido-por=<actor> [--badge=B]               — artefacto de procedencia
+ *   node scripts/run-skill-evals.js <nombre-skill> --record-after \
+ *       [--hypothesis="razon-causal"] [--check-invariants] [--evaluacion=<path>]
  *   node scripts/run-skill-evals.js <nombre-skill> --record-revert --score=N
  *   node scripts/run-skill-evals.js --list                          — lista skills con evals
  *
@@ -25,16 +27,31 @@
  *   --check-invariants valida safety invariants declarados en el frontmatter
  *                    antes de aceptar el commit (operador Commit §3.2.2).
  *
+ * Anti-gaming (DT-AGP-SCORE-AUTODECLARADO, cerrada 2026-07-10 — regla
+ * `seguridad-agentes.md § Anti-gaming`): el score que APRUEBA una evolución
+ * (--record-after) NO se acepta de un flag arbitrario. Debe venir de un
+ * artefacto de evaluación con procedencia (.planning/evolution/evaluaciones/
+ * <target>.json) emitido por /swl:evaluar-skill vía --emitir-evaluacion:
+ * fechado, con `producido_por` ≠ target, y fresco (≤7 días). Si además se
+ * pasa --score, debe COINCIDIR con el del artefacto. Todo evento registra el
+ * actor que produjo el score — el evaluado nunca aprueba su propia evidencia.
+ *
  * Zero-deps.
  */
 
-const fs   = require('fs');
-const path = require('path');
+const fs     = require('fs');
+const path   = require('path');
+const crypto = require('crypto');
 const { validarInvariantesDeAgente } = require('./lib/agp-frontmatter');
 
 const CWD = process.cwd();
 const EVOL_DIR = path.join(CWD, '.planning', 'evolution');
 const EVOL_LOG = path.join(EVOL_DIR, 'evoluciones.jsonl');
+const EVALUACIONES_DIR = path.join(EVOL_DIR, 'evaluaciones');
+
+/** Ventana de frescura del artefacto de evaluación (ms): 7 días. Una
+ * evaluación más vieja no puede aprobar una mutación nueva — se re-corre. */
+const FRESCURA_EVALUACION_MS = 7 * 24 * 3600 * 1000;
 
 function ensureDir(d) { try { fs.mkdirSync(d, { recursive: true }); } catch { /* ignore */ } }
 
@@ -49,6 +66,36 @@ function resolverEvals(nombre) {
   return null;
 }
 
+/** Resuelve el archivo de contenido del target (SKILL.md o el .md del agente). */
+function resolverContenidoTarget(nombre) {
+  const candidatos = [
+    path.join(CWD, 'habilidades', nombre, 'SKILL.md'),
+    path.join(CWD, 'agentes', `${nombre}.md`),
+  ];
+  for (const c of candidatos) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+/**
+ * SHA256 del contenido evaluado (EOL normalizado — CRLF/LF no cambia el hash,
+ * clase C2). Liga el artefacto de evaluación a la versión EXACTA evaluada: si
+ * el skill/agente muta en la ventana de frescura entre --emitir-evaluacion y
+ * --record-after, el hash deja de coincidir y la aprobación se rechaza
+ * (cierra la ventana TOCTOU del anti-gaming, nemesis iter-1 S3-2).
+ */
+function hashContenidoTarget(nombre) {
+  const ruta = resolverContenidoTarget(nombre);
+  if (!ruta) return null;
+  try {
+    const txt = fs.readFileSync(ruta, 'utf8').replace(/\r\n/g, '\n');
+    return crypto.createHash('sha256').update(txt).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
 function listarSkillsConEvals() {
   const out = [];
   try {
@@ -107,6 +154,171 @@ function registrarEvento(tipo, detalles) {
   }
 }
 
+/**
+/** Escritura atómica de JSON con require tolerante (repo madre vs destino). */
+function escribirJSONAtomico(ruta, obj) {
+  let atomicWriteJSON = null;
+  try {
+    ({ atomicWriteJSON } = require(path.join(__dirname, '..', 'hooks', 'lib', 'atomic-write.js')));
+  } catch {
+    try { ({ atomicWriteJSON } = require(path.join(__dirname, 'atomic-write.js'))); } catch { /* fallback abajo */ }
+  }
+  if (atomicWriteJSON) atomicWriteJSON(ruta, obj);
+  else fs.writeFileSync(ruta, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * Marca un artefacto de evaluación como consumido tras un --record-after
+ * exitoso: una evaluación aprueba UNA aplicación. Impide el replay del mismo
+ * artefacto para inflar el contador de evoluciones (nemesis iter-1 S3-1).
+ */
+function marcarEvaluacionConsumida(ruta) {
+  try {
+    const art = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+    art.consumido_en = new Date().toISOString();
+    escribirJSONAtomico(ruta, art);
+  } catch (e) {
+    // Fail-loud (regla anti-fallback-silencioso): si el marcado falla (disco
+    // lleno, permisos), el evento `aplicada` YA quedó registrado y el artefacto
+    // sigue sin `consumido_en` → replayable. Avisar en vez de tragarlo, para
+    // que el usuario borre el artefacto a mano (re-auditoría nemesis iter-2).
+    process.stderr.write(
+      `[run-skill-evals] AVISO: no se pudo marcar el artefacto como consumido (${e.message}).\n` +
+      `  El artefacto ${ruta} sigue siendo replayable — bórralo manualmente para evitar un doble --record-after.\n`
+    );
+  }
+}
+
+/**
+ * Escribe el artefacto de evaluación con procedencia (modo --emitir-evaluacion).
+ * Lo invoca /swl:evaluar-skill al cerrar su reporte; es la ÚNICA fuente
+ * válida del score que --record-after acepta.
+ */
+function emitirEvaluacion({ target, score, badge, producidoPor }) {
+  ensureDir(EVALUACIONES_DIR);
+  const ruta = path.join(EVALUACIONES_DIR, `${target}.json`);
+
+  // Emisión concurrente (nemesis iter-1 S3-7): si ya existe un artefacto para
+  // este target emitido hace segundos (otra evaluación en curso, regla
+  // sesiones-paralelas), avisar antes de sobrescribirlo — el last-write-wins
+  // silencioso podía tirar una evaluación fresca justo antes de leerse.
+  try {
+    if (fs.existsSync(ruta)) {
+      const previo = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+      const edadMs = Date.now() - Date.parse(previo.fecha || '');
+      if (Number.isFinite(edadMs) && edadMs >= 0 && edadMs < 10_000) {
+        process.stderr.write(
+          `[run-skill-evals] AVISO: sobrescribiendo un artefacto de evaluación de "${target}" ` +
+          `emitido hace ${(edadMs / 1000).toFixed(1)}s (posible evaluación concurrente). ` +
+          `Verifica que no haya dos /swl:evaluar-skill corriendo sobre el mismo target.\n`
+        );
+      }
+    }
+  } catch { /* artefacto ilegible: se sobrescribe sin aviso */ }
+
+  const artefacto = {
+    target,
+    score,
+    badge: badge || null,
+    producido_por: producidoPor,
+    fecha: new Date().toISOString(),
+    hash_contenido: hashContenidoTarget(target),
+  };
+  escribirJSONAtomico(ruta, artefacto);
+  return { ruta, artefacto };
+}
+
+/**
+ * Carga y valida el artefacto de evaluación para --record-after.
+ * Devuelve { ok, artefacto?, ruta?, error?, codigo? } — codigo 8 = artefacto
+ * ausente/inválido/vencido/auto-calificado; el caller decide el exit.
+ */
+function cargarEvaluacion(target, rutaOverride) {
+  const ruta = rutaOverride
+    ? path.resolve(CWD, rutaOverride)
+    : path.join(EVALUACIONES_DIR, `${target}.json`);
+
+  if (!fs.existsSync(ruta)) {
+    return {
+      ok: false,
+      codigo: 8,
+      error: `FAIL: --record-after exige un artefacto de evaluación con procedencia y no existe:\n` +
+             `  ${path.relative(CWD, ruta)}\n` +
+             `Genéralo corriendo /swl:evaluar-skill ${target} (emite el artefacto vía --emitir-evaluacion).\n` +
+             `El score que aprueba una evolución no puede declararlo el propio evaluado (DT-AGP-SCORE-AUTODECLARADO).`,
+    };
+  }
+
+  let artefacto;
+  try {
+    artefacto = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+  } catch (e) {
+    return { ok: false, codigo: 8, error: `FAIL: artefacto de evaluación ilegible (${e.message}): ${ruta}` };
+  }
+
+  if (artefacto.target !== target) {
+    return { ok: false, codigo: 8, error: `FAIL: el artefacto de evaluación es de "${artefacto.target}", no de "${target}".` };
+  }
+  const scoreArtefacto = Number(artefacto.score);
+  if (!Number.isFinite(scoreArtefacto) || scoreArtefacto < 0 || scoreArtefacto > 100) {
+    return { ok: false, codigo: 8, error: `FAIL: score inválido en el artefacto de evaluación: ${artefacto.score}` };
+  }
+  const productor = String(artefacto.producido_por || '').trim();
+  if (!productor) {
+    return { ok: false, codigo: 8, error: 'FAIL: el artefacto de evaluación no declara `producido_por` — sin procedencia no hay aprobación.' };
+  }
+  if (productor === target) {
+    return {
+      ok: false,
+      codigo: 8,
+      error: `FAIL: auto-calificación rechazada — el artefacto declara producido_por="${productor}" igual al target evaluado.\n` +
+             `La evidencia que aprueba una evolución debe venir de un actor independiente (regla seguridad-agentes § Anti-gaming).`,
+    };
+  }
+  const fecha = Date.parse(artefacto.fecha || '');
+  if (!Number.isFinite(fecha)) {
+    return { ok: false, codigo: 8, error: 'FAIL: el artefacto de evaluación no tiene `fecha` válida.' };
+  }
+  if (Date.now() - fecha > FRESCURA_EVALUACION_MS) {
+    return {
+      ok: false,
+      codigo: 8,
+      error: `FAIL: artefacto de evaluación vencido (viejo, >7 días: ${artefacto.fecha}).\n` +
+             `Re-corre /swl:evaluar-skill ${target} — una evaluación vieja no aprueba una mutación nueva.`,
+    };
+  }
+
+  // Anti-replay: una evaluación aprueba UNA aplicación. Si ya se consumió
+  // en un --record-after previo, rechazar (nemesis iter-1 S3-1) — evita que
+  // el mismo artefacto infle el contador de evoluciones.
+  if (artefacto.consumido_en) {
+    return {
+      ok: false,
+      codigo: 8,
+      error: `FAIL: el artefacto de evaluación ya se consumió (${artefacto.consumido_en}).\n` +
+             `Una evaluación aprueba una sola aplicación — re-corre /swl:evaluar-skill ${target}.`,
+    };
+  }
+
+  // Binding de contenido: el artefacto aprueba la versión EXACTA que se evaluó.
+  // Si el target mutó entre --emitir-evaluacion y --record-after, el hash no
+  // coincide y la aprobación se rechaza (cierra la ventana TOCTOU, nemesis S3-2).
+  // Se exige cuando el artefacto lo declara Y el contenido del target resuelve.
+  if (artefacto.hash_contenido) {
+    const hashActual = hashContenidoTarget(target);
+    if (hashActual && hashActual !== artefacto.hash_contenido) {
+      return {
+        ok: false,
+        codigo: 8,
+        error: `FAIL: el contenido de "${target}" cambió tras la evaluación (hash no coincide).\n` +
+               `El artefacto aprueba una versión distinta a la actual — re-corre /swl:evaluar-skill ${target}.`,
+      };
+    }
+  }
+
+  return { ok: true, artefacto, ruta };
+}
+
 // Nota: el parser YAML y el validador de safety invariants (AGP Commit operator)
 // viven en scripts/lib/agp-frontmatter.js para reutilizarse desde tests y hooks.
 
@@ -122,11 +334,18 @@ const flags = {
   recordAfter: argv.includes('--record-after'),
   recordRevert: argv.includes('--record-revert'),
   checkInvariants: argv.includes('--check-invariants'),
+  emitirEvaluacion: argv.includes('--emitir-evaluacion'),
 };
 const scoreArg = argv.find(a => a.startsWith('--score='));
 const score = scoreArg ? parseFloat(scoreArg.split('=')[1]) : null;
 const hypothesisArg = argv.find(a => a.startsWith('--hypothesis='));
 const hypothesis = hypothesisArg ? hypothesisArg.slice('--hypothesis='.length) : null;
+const producidoPorArg = argv.find(a => a.startsWith('--producido-por='));
+const producidoPor = producidoPorArg ? producidoPorArg.slice('--producido-por='.length).trim() : null;
+const badgeArg = argv.find(a => a.startsWith('--badge='));
+const badge = badgeArg ? badgeArg.slice('--badge='.length) : null;
+const evaluacionArg = argv.find(a => a.startsWith('--evaluacion='));
+const evaluacionPath = evaluacionArg ? evaluacionArg.slice('--evaluacion='.length) : null;
 const nombre = argv.find(a => !a.startsWith('--'));
 
 if (flags.list) {
@@ -172,8 +391,35 @@ if (errors.length) {
   process.exit(4);
 }
 
+// Modo --emitir-evaluacion: /swl:evaluar-skill persiste aquí el artefacto de
+// procedencia que --record-after exigirá (DT-AGP-SCORE-AUTODECLARADO).
+if (flags.emitirEvaluacion) {
+  if (score === null || Number.isNaN(score) || score < 0 || score > 100) {
+    console.error('FAIL: --emitir-evaluacion requiere --score=N (0-100)');
+    process.exit(5);
+  }
+  if (!producidoPor) {
+    console.error('FAIL: --emitir-evaluacion requiere --producido-por=<actor> (comando/agente que corrió la evaluación).');
+    console.error('      Sin procedencia declarada el artefacto no puede aprobar evoluciones.');
+    process.exit(5);
+  }
+  const { ruta } = emitirEvaluacion({ target: nombre, score, badge, producidoPor });
+  registrarEvento('evaluacion', {
+    target: nombre,
+    score,
+    badge: badge || null,
+    producido_por: producidoPor,
+    evaluacion_path: path.relative(CWD, ruta),
+  });
+  console.log(`evaluación emitida: target=${nombre} score=${score} producido_por=${producidoPor}`);
+  console.log(`artefacto: ${path.relative(CWD, ruta)}`);
+  process.exit(0);
+}
+
 if (flags.recordBaseline || flags.recordAfter || flags.recordRevert) {
-  if (score === null || Number.isNaN(score)) {
+  // El score de --record-after viene del artefacto de evaluación (abajo);
+  // baseline y revert siguen requiriendo --score explícito.
+  if (!flags.recordAfter && (score === null || Number.isNaN(score))) {
     console.error('FAIL: --record-* requiere --score=N (0-100)');
     process.exit(5);
   }
@@ -181,6 +427,25 @@ if (flags.recordBaseline || flags.recordAfter || flags.recordRevert) {
              : flags.recordAfter    ? 'aplicada'
              :                         'revertida';
 
+  // Anti-gaming (--record-after): el score que aprueba la evolución se lee
+  // del artefacto con procedencia; un --score explícito debe COINCIDIR.
+  let evaluacion = null;
+  if (flags.recordAfter) {
+    const carga = cargarEvaluacion(nombre, evaluacionPath);
+    if (!carga.ok) {
+      console.error(carga.error);
+      process.exit(carga.codigo);
+    }
+    evaluacion = carga;
+    const scoreArtefacto = Number(carga.artefacto.score);
+    if (score !== null && !Number.isNaN(score) && Math.abs(score - scoreArtefacto) > 0.01) {
+      console.error(`FAIL: --score=${score} discrepa del artefacto de evaluación (${scoreArtefacto}).`);
+      console.error(`      El número que se registra es el del artefacto — no se acepta un score paralelo.`);
+      process.exit(9);
+    }
+  }
+  const scoreEfectivo = flags.recordAfter ? Number(evaluacion.artefacto.score) : score;
+
   let invariantes_ok = null;
   if (flags.checkInvariants && (flags.recordAfter || flags.recordRevert)) {
     const resultado = validarInvariantesDeAgente(nombre);
@@ -192,7 +457,7 @@ if (flags.recordBaseline || flags.recordAfter || flags.recordRevert) {
       }
       registrarEvento(tipo, {
         target: nombre,
-        score,
+        score: scoreEfectivo,
         evals_total: data.evals.length,
         evals_path: path.relative(CWD, evalsPath),
         hypothesis,
@@ -206,18 +471,32 @@ if (flags.recordBaseline || flags.recordAfter || flags.recordRevert) {
 
   const payload = {
     target: nombre,
-    score,
+    score: scoreEfectivo,
     evals_total: data.evals.length,
     evals_path: path.relative(CWD, evalsPath),
   };
   if (hypothesis) payload.hypothesis = hypothesis;
   if (invariantes_ok !== null) payload.invariantes_ok = invariantes_ok;
+  if (evaluacion) {
+    // Procedencia del score (DT-AGP-SCORE-AUTODECLARADO): quién lo produjo
+    // y de qué artefacto sale — el detector de validar.js exige estos campos
+    // en toda entrada `aplicada`.
+    payload.producido_por = evaluacion.artefacto.producido_por;
+    payload.evaluacion_path = path.relative(CWD, evaluacion.ruta);
+    payload.evaluacion_fecha = evaluacion.artefacto.fecha;
+  }
 
   const ok = registrarEvento(tipo, payload);
   if (ok) {
+    // Consumir el artefacto tras un --record-after exitoso: una evaluación
+    // aprueba UNA aplicación (anti-replay, nemesis S3-1).
+    if (flags.recordAfter && evaluacion) {
+      marcarEvaluacionConsumida(evaluacion.ruta);
+    }
     const sufijo = hypothesis ? ` hypothesis="${hypothesis.slice(0, 40)}${hypothesis.length > 40 ? '...' : ''}"` : '';
     const invSufijo = invariantes_ok === true ? ' invariantes_ok=true' : '';
-    console.log(`registrado: ${tipo} score=${score} target=${nombre}${sufijo}${invSufijo}`);
+    const procSufijo = evaluacion ? ` producido_por=${evaluacion.artefacto.producido_por}` : '';
+    console.log(`registrado: ${tipo} score=${scoreEfectivo} target=${nombre}${sufijo}${invSufijo}${procSufijo}`);
     process.exit(0);
   } else {
     process.exit(6);

package/scripts/smoke-test.js

@@ -53,9 +53,10 @@ function archivosEsperadosEnPerfil(perfil) {
   for (const modKey of modulosPerfil) {
     const mod = modulos.modulos[modKey];
     if (!mod) continue;
-    // Módulos tipo 'scripts' son herramientas de desarrollo del repo; el instalador
-    // NO los copia al runtime del usuario. Omitir del smoke test.
-    if (mod.tipo === "scripts") continue;
+    // Histórico: los módulos tipo 'scripts' se OMITÍAN del smoke — ese punto
+    // ciego escondió que el instalador depositaba sus archivos (incluidos
+    // hooks y comandos) en rutas.base (DT-MODULOS-TIPO-SCRIPTS, 2026-07-10).
+    // Hoy no queda ningún módulo tipo 'scripts'; todos se verifican.
     for (const a of mod.archivos || []) archivos.add(a);
   }
   return archivos;
@@ -98,12 +99,19 @@ function traducirRuta(rel) {
       .replace(/^reglas\//, "rules/");
   }
   if (rel.startsWith("hooks/lib/")) {
-    // El instalador aplana hooks/lib/X.js → hooks/X.js en el destino.
-    return rel.replace(/^hooks\/lib\//, "hooks/");
+    // El instalador preserva el subárbol lib/ (contrato require('./lib/X')
+    // de los hooks — el aplanado dejaba esos require muertos en installs
+    // frescos; restaurado 2026-07-10).
+    return rel;
   }
-  // Archivos scripts/ declarados en módulos de tipo 'hooks' (ej. hooks-observabilidad,
-  // hooks-multica). El instalador toma path.basename y los coloca en rutas.hooks,
-  // aplanando scripts/lib/X.js y scripts/X.py a hooks/X.*.
+  // scripts/lib/* se une al MISMO lib/ de hooks (los fallbacks tolerantes
+  // de check-update/session-briefing esperan './lib/X'). Preserva subdirs
+  // (lib/ciclo-autonomo/...).
+  if (rel.startsWith("scripts/lib/")) {
+    return "hooks/lib/" + rel.slice("scripts/lib/".length);
+  }
+  // Resto de scripts/ declarados en módulos de hooks: aplanados por basename
+  // en la raíz de hooks (rotar-audit-logs.js, *.py, etc.).
   if (rel.startsWith("scripts/")) {
     return "hooks/" + path.posix.basename(rel);
   }