@saulwade/swl-ses 2.5.3 → 2.6.1

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);
   }

package/scripts/tui/pantallas/install-wizard.js

@@ -10,10 +10,10 @@
  *   1. Runtime destino (Claude/Codex/OpenCode/etc.)
  *   2. Perfil (core / backend-python / fullstack-* / completo / ...)
  *   3. Scope (proyecto / global)
- *   4. Flags adicionales (with-mcp, dry-run)
- *   5. Stacks de lenguajes (solo si perfil = completo)
- *   6. Preview del plan
- *   7. Confirmación final
+ *   4. Flags adicionales (with-mcp, dry-run, solo-hooks)
+ *   5. Módulos opt-in (fuera de todos los perfiles — DT-MODULOS-OPT-IN)
+ *   6. Stacks de lenguajes (solo si perfil = completo)
+ *   7. Preview del plan + confirmación final
  *
  * Devuelve el objeto de opciones para `scripts/instalador.js` o null si el
  * usuario canceló en cualquier paso.
@@ -112,12 +112,43 @@ const FLAGS = [
     descripcion: 'Útil para inspeccionar qué se haría sin tocar el filesystem.',
     preseleccionado: false,
   },
+  {
+    valor: 'solo-hooks',
+    etiqueta: 'Solo hooks (telemetría de proyecto, sin copiar componentes)',
+    descripcion: 'Registra los hooks del scope GLOBAL en el settings.json de ESTE proyecto — evita duplicar agentes/comandos en la UI. Ignora perfil, scope y módulos. Solo target Claude Code.',
+    preseleccionado: false,
+  },
 ];
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
+const MODULOS_PATH = path.join(RAIZ, 'manifiestos', 'modulos.json');
+
+/**
+ * Módulos `opt_in: true` de modulos.json — fuera de todos los perfiles,
+ * instalables solo por selección explícita (DT-MODULOS-OPT-IN). El wizard
+ * los ofrece como paso propio; el CLI equivalente es `--with a,b`.
+ *
+ * @returns {Array<{valor: string, etiqueta: string, descripcion: string}>}
+ */
+function cargarModulosOptIn() {
+  try {
+    const data = JSON.parse(fs.readFileSync(MODULOS_PATH, 'utf8'));
+    const modulos = data.modulos || {};
+    return Object.entries(modulos)
+      .filter(([, m]) => m && m.opt_in === true)
+      .map(([nombre, m]) => ({
+        valor: nombre,
+        etiqueta: nombre,
+        descripcion: String(m.descripcion || '').slice(0, 140),
+      }));
+  } catch (_) {
+    return [];
+  }
+}
+
 function cargarPerfiles() {
   try {
     const data = JSON.parse(fs.readFileSync(PERFILES_PATH, 'utf8'));
@@ -181,6 +212,13 @@ function pantallaPreview(opciones, perfiles) {
         filas.push(['Stacks extra', opciones.stacks.join(', ')]);
       }
 
+      if (opciones['solo-hooks']) {
+        filas.push(['Solo hooks', 'sí — registra hooks del scope global en el proyecto, sin copiar componentes']);
+      }
+      if (opciones.with) {
+        filas.push(['Módulos opt-in', opciones.with]);
+      }
+
       const perfilInfo = perfiles[opciones.profile];
       if (perfilInfo?.modulos) {
         filas.push(['Módulos', String(perfilInfo.modulos.length)]);
@@ -247,7 +285,7 @@ async function ejecutarWizardInstall() {
   // (fix 2026-07-09: era selector único; el flujo multi-runtime obligaba a
   // repetir el wizard completo por cada runtime).
   let targets = null;
-  let tituloPaso1 = 'Paso 1/6 — ¿En qué runtime(s) instalas SWL? (espacio para marcar)';
+  let tituloPaso1 = 'Paso 1/7 — ¿En qué runtime(s) instalas SWL? (espacio para marcar)';
   for (;;) {
     targets = await selectorMulti({ titulo: tituloPaso1, items: RUNTIMES });
     if (targets === null) return { exito: false, cancelado: true };
@@ -259,13 +297,13 @@ async function ejecutarWizardInstall() {
       targets = [RUNTIMES[0].valor];
       break;
     }
-    tituloPaso1 = 'Paso 1/6 — Marca AL MENOS un runtime con espacio (Esc para cancelar)';
+    tituloPaso1 = 'Paso 1/7 — Marca AL MENOS un runtime con espacio (Esc para cancelar)';
   }
   const target = targets[0]; // compat: preview/ejecutores leen .target
 
   // 2. Perfil
   const profile = await selectorUnico({
-    titulo: 'Paso 2/6 — ¿Qué perfil instalas?',
+    titulo: 'Paso 2/7 — ¿Qué perfil instalas?',
     items: construirItemsPerfil(perfiles),
     indiceDefault: 0,
   });
@@ -273,7 +311,7 @@ async function ejecutarWizardInstall() {
 
   // 3. Scope
   const scope = await selectorUnico({
-    titulo: 'Paso 3/6 — ¿Dónde se instala?',
+    titulo: 'Paso 3/7 — ¿Dónde se instala?',
     items: SCOPES,
     indiceDefault: 0,
   });
@@ -281,16 +319,31 @@ async function ejecutarWizardInstall() {
 
   // 4. Flags
   const flagsSeleccionados = await selectorMulti({
-    titulo: 'Paso 4/6 — Flags adicionales (espacio para toggle):',
+    titulo: 'Paso 4/7 — Flags adicionales (espacio para toggle):',
     items: FLAGS,
   });
   if (flagsSeleccionados === null) return { exito: false, cancelado: true };
 
-  // 5. Stacks (solo si perfil = completo)
+  // 5. Módulos opt-in (DT-MODULOS-OPT-IN) — fuera de todos los perfiles;
+  // solo se instalan por selección explícita. Se omite en modo solo-hooks
+  // (ese camino no copia componentes).
+  const soloHooks = flagsSeleccionados.includes('solo-hooks');
+  let modulosOptIn = [];
+  const itemsOptIn = soloHooks ? [] : cargarModulosOptIn();
+  if (itemsOptIn.length > 0) {
+    const elegidos = await selectorMulti({
+      titulo: 'Paso 5/7 — Módulos opt-in (fuera del perfil; espacio para marcar, Enter para omitir):',
+      items: itemsOptIn,
+    });
+    if (elegidos === null) return { exito: false, cancelado: true };
+    modulosOptIn = elegidos;
+  }
+
+  // 6. Stacks (solo si perfil = completo)
   let stacks = [];
-  if (profile === 'completo') {
+  if (profile === 'completo' && !soloHooks) {
     const elegidos = await selectorMulti({
-      titulo: 'Paso 5/6 — Stacks de lenguajes adicionales (perfil completo):',
+      titulo: 'Paso 6/7 — Stacks de lenguajes adicionales (perfil completo):',
       items: STACKS_ADICIONALES,
     });
     if (elegidos === null) return { exito: false, cancelado: true };
@@ -304,6 +357,8 @@ async function ejecutarWizardInstall() {
     global: scope === 'global',
     with_mcp: flagsSeleccionados.includes('with-mcp'),
     dry_run: flagsSeleccionados.includes('dry-run'),
+    'solo-hooks': soloHooks,
+    with: modulosOptIn.join(',') || undefined,
     all_langs: stacks.length > 0,
     stacks,
   };
@@ -314,7 +369,7 @@ async function ejecutarWizardInstall() {
 
   // 7. Confirmación final (selector único con 2 opciones para claridad visual)
   const confirmacion = await selectorUnico({
-    titulo: 'Paso 6/6 — Confirmar e iniciar instalación',
+    titulo: 'Paso 7/7 — Confirmar e iniciar instalación',
     items: [
       {
         valor: 'si',
@@ -344,4 +399,5 @@ module.exports = {
   FLAGS,
   cargarPerfiles,
   construirItemsPerfil,
+  cargarModulosOptIn,
 };

package/scripts/validar.js

@@ -92,7 +92,7 @@ verificar(comandos.length >= 9, `Comandos: ${comandos.length} (mínimo 9)`);
 // proyecto (node scripts/ | node hooks/ | require('./scripts|hooks/...')).
 // Esas rutas no existen downstream; deben usar el subcomando del CLI.
 // Ver docs/invocacion-cli-cross-scope.md.
-const { auditarInvocacionesComandos } = require('./lib/auditar-invocaciones-comandos');
+const { auditarInvocacionesComandos, auditarInvocacionesSkills } = require('./lib/auditar-invocaciones-comandos');
 const auditInvoc = auditarInvocacionesComandos(path.join(RAIZ, 'comandos', 'swl'));
 verificar(
   auditInvoc.ok,
@@ -101,6 +101,17 @@ verificar(
     : `Cross-scope: ${auditInvoc.violaciones.length} invocación(es) relativa(s) — ${auditInvoc.violaciones.map(v => `${v.comando}.md:${v.linea}`).join(', ')}`
 );
 
+// 7b-bis. Mismo gate sobre skills user-facing (DT-PATHS-DESTINO, cierre
+// 2026-07-10): solo fences ejecutables (bash/sh/sin lenguaje); los bloques js
+// de API llevan clarificador de layout. Skills host-only en SKILLS_SOLO_MADRE.
+const auditInvocSkills = auditarInvocacionesSkills(path.join(RAIZ, 'habilidades'));
+verificar(
+  auditInvocSkills.ok,
+  auditInvocSkills.ok
+    ? `Cross-scope skills: ${auditInvocSkills.escaneados} skills sin rutas relativas al proyecto`
+    : `Cross-scope skills: ${auditInvocSkills.violaciones.length} invocación(es) relativa(s) — ${auditInvocSkills.violaciones.map(v => `${v.comando}:${v.linea}`).join(', ')}`
+);
+
 // 7c. Gate inverso de evolución (Fase 16, REQ-16-03): el FUENTE no debe portar
 // marcadores evolved (frontmatter evolved:true ni sidecar .evolved.json). Un
 // marcador en el repo madre es shipped-evolved espurio que congela el componente
@@ -166,6 +177,34 @@ try {
   }
 } catch { /* ignore */ }
 
+// 15. Procedencia de evoluciones aplicadas (DT-AGP-SCORE-AUTODECLARADO):
+// toda entrada tipo:aplicada en evoluciones.jsonl debe llevar la cadena de
+// procedencia del score (producido_por ≠ target + evaluacion_path). Cutoff
+// 2026-07-10: fecha en que --record-after empezó a exigir el artefacto —
+// entradas previas son legacy sin contrato.
+try {
+  const evolLog = path.join(RAIZ, '.planning', 'evolution', 'evoluciones.jsonl');
+  if (fs.existsSync(evolLog)) {
+    const CUTOFF_PROCEDENCIA = Date.parse('2026-07-10T00:00:00Z');
+    const sinProcedencia = fs.readFileSync(evolLog, 'utf-8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(l => { try { return JSON.parse(l); } catch { return null; } })
+      .filter(e => e && e.tipo === 'aplicada' && Date.parse(e.ts || '') >= CUTOFF_PROCEDENCIA)
+      .filter(e =>
+        !e.producido_por ||
+        e.producido_por === e.target ||
+        !e.evaluacion_path
+      );
+    verificar(
+      sinProcedencia.length === 0,
+      sinProcedencia.length === 0
+        ? 'Evoluciones aplicadas: cadena de procedencia completa (anti-gaming)'
+        : `Evoluciones aplicadas SIN procedencia válida: ${sinProcedencia.map(e => `${e.target}@${e.ts}`).join(', ')} — el score debe venir del artefacto de /swl:evaluar-skill`
+    );
+  }
+} catch { /* log ilegible: no bloquear la validación estructural */ }
+
 console.log('\n' + '='.repeat(40));
 if (errores === 0) {
   console.log('Todas las validaciones pasaron.');