@saulwade/swl-ses 2.2.0 → 2.2.3

package/scripts/publicar.js

@@ -32,6 +32,32 @@ const {
 const ROOT     = path.resolve(__dirname, '..');
 const PKG_PATH = path.join(ROOT, 'package.json');
 
+// --- Log de la corrida (.planning/logs/publish-<version>-<ts>.log) -----------
+// Captura stdout+stderr del publish para diagnóstico: npm v10 NO escribe el
+// stdout de un script fallido (prepublishOnly/test:release) en su debug log,
+// así que sin esto el test que rompe el publish queda invisible. Tee: eco a
+// consola + archivo persistente.
+let LOG_PATH = null;
+function iniciarLog(version) {
+  try {
+    const dir = path.join(ROOT, '.planning', 'logs');
+    fs.mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    LOG_PATH = path.join(dir, `publish-${version}-${ts}.log`);
+    // Escritura SÍNCRONA (writeFileSync/appendFileSync): un createWriteStream
+    // async + process.exit() inmediato perdía el buffer sin volcarlo a disco
+    // (dejaba el log vacío). appendFileSync vacía en cada llamada.
+    fs.writeFileSync(LOG_PATH, `# publish ${version} — ${new Date().toISOString()}\n# argv: ${process.argv.slice(2).join(' ')}\n\n`);
+  } catch (err) {
+    process.stderr.write(`[publicar] no se pudo abrir log: ${String(err.message).slice(0, 120)}\n`);
+    LOG_PATH = null;
+  }
+}
+function logWrite(text) {
+  if (LOG_PATH && text) { try { fs.appendFileSync(LOG_PATH, text); } catch { /* best-effort */ } }
+}
+function cerrarLog() { /* no-op: appendFileSync ya volcó todo a disco */ }
+
 /**
  * Resuelve el binario de npm a invocar. Usa node + npm-cli.js cuando es
  * posible para evitar shell:true en Windows (mismo enfoque que la lib
@@ -60,15 +86,19 @@ function npmExec(args, opts = {}) {
 }
 
 /**
- * Variante de npmExec que captura stderr para detección posterior de errores
- * estructurados (ej: EOTP). stdout sigue heredado (live-streaming visible al
- * usuario) y stderr se pipea a un buffer + se ecoa a process.stderr al final.
+ * Variante de npmExec que captura stdout+stderr para (a) detección de errores
+ * estructurados (ej: EOTP) y (b) persistencia en el log de la corrida
+ * (`iniciarLog`). Ambos streams se pipean, se ecoan a consola al terminar y se
+ * vuelcan al log — así el stdout del script que rompe el publish (test:release)
+ * queda registrado. Trade-off: la salida del prepublish aparece al finalizar el
+ * spawn (no en vivo), por eso se imprime un aviso antes.
  *
  * Retorna { status, stderr } sin lanzar — el caller inspecciona el status.
  */
 function npmSpawnCaptureStderr(args, opts = {}) {
   const defaults = { cwd: ROOT, timeout: 300_000, env: process.env };
-  const merged = { ...defaults, ...opts, stdio: ['inherit', 'inherit', 'pipe'] };
+  const merged = { ...defaults, ...opts, stdio: ['inherit', 'pipe', 'pipe'] };
+  process.stderr.write('[publicar] ejecutando npm (incluye prepublish/test:release; salida completa al finalizar y en el log)...\n');
   let res;
   if (NPM_CLI_JS) {
     res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
@@ -76,9 +106,13 @@ function npmSpawnCaptureStderr(args, opts = {}) {
     const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
     res = spawnSync(bin, args, merged);
   }
+  const stdout = res.stdout ? String(res.stdout) : '';
   const stderr = res.stderr ? String(res.stderr) : '';
-  // Ecoar stderr al usuario para que vea el diagnóstico de npm aunque se capturó.
+  // Eco a consola + volcado al log (stdout primero, luego stderr).
+  if (stdout) process.stdout.write(stdout);
   if (stderr) process.stderr.write(stderr);
+  logWrite(stdout);
+  logWrite(stderr);
   return { status: res.status, signal: res.signal, stderr, error: res.error };
 }
 
@@ -482,6 +516,7 @@ function reportarResultado(pkg, opts, npmjsOk, githubOk) {
 function main() {
   const opts = parsearArgs(process.argv.slice(2));
   const pkg  = leerPkg();
+  iniciarLog(pkg.version);
   imprimirEncabezado(pkg.version, opts.dryRun);
   avisarSiHayCambiosSinCommit(opts.dryRun);
 
@@ -489,6 +524,8 @@ function main() {
   const githubOk = opts.soloNpmjs  ? true : publicarGitHub(pkg, opts.dryRun);
 
   reportarResultado(pkg, opts, npmjsOk, githubOk);
+  if (LOG_PATH) process.stdout.write(`\nLog de la corrida: ${path.relative(ROOT, LOG_PATH).replace(/\\/g, '/')}\n`);
+  cerrarLog();
   process.exit(npmjsOk && githubOk ? 0 : 1);
 }
 

package/scripts/remediar-evolved-instaladas.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * remediar-evolved-instaladas — Descongela copias instaladas con marcadores
+ * evolved espurios (Fase 16, T-25, REQ-16-14).
+ *
+ * Las instalaciones previas a Fase 16 quedaron con componentes `evolved:true`
+ * shippeados de fábrica que el instalador preservaba para siempre (bug). Este
+ * sub-comando los reclasifica en la máquina del usuario:
+ *
+ *   - B (shipped intacto): el cuerpo canónico instalado coincide con el baseline
+ *     de su `evolved-from` (manifiesto actual o `git show v<from>:<ruta>`).
+ *     → el usuario NO lo tocó → actualizar al canónico actual (con backup + auditoría).
+ *   - A (evolución del usuario): el cuerpo difiere del baseline, o no hay baseline
+ *     verificable. → PRESERVAR (jamás overwrite). Invariante.
+ *
+ * SEGURO por defecto: `--dry-run` (solo reporta). Requiere `--apply` explícito.
+ * Ante CUALQUIER duda (sin baseline, sin fuente, error) clasifica A (preserva).
+ *
+ * Uso:
+ *   node scripts/remediar-evolved-instaladas.js --target=~/.claude          (dry-run)
+ *   node scripts/remediar-evolved-instaladas.js --target=~/.claude --apply  (aplica)
+ *
+ * Zero-deps salvo git (para baseline histórico). Layout runtime: claude.
+ *
+ * @module scripts/remediar-evolved-instaladas
+ */
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { canonicalHash } = require('./lib/canonical-hash');
+const { auditarEscritura } = require('./lib/audit-evolved');
+const { mergeEvolved } = require('../hooks/lib/evolution-tracker');
+
+const RAIZ_PKG = path.resolve(__dirname, '..');
+
+// Mapeo dir-runtime (claude) → dir-fuente (clave del manifiesto / git).
+const MAP_DIRS = [
+  { runtime: 'agents',        fuente: 'agentes',       skill: false },
+  { runtime: 'commands/swl',  fuente: 'comandos/swl',  skill: false },
+  { runtime: 'rules',         fuente: 'reglas',        skill: false },
+  { runtime: 'skills',        fuente: 'habilidades',   skill: true  },
+];
+
+function expandirTarget(t) {
+  if (!t) return path.join(os.homedir(), '.claude');
+  if (t === '~' || t.startsWith('~/') || t.startsWith('~\\')) return path.join(os.homedir(), t.slice(1).replace(/^[/\\]/, ''));
+  return path.resolve(t);
+}
+
+function leerEvolved(content) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (!m) return { evolved: false };
+  const fm = m[1];
+  if (!/^evolved:\s*(true|yes)\b/mi.test(fm)) return { evolved: false };
+  const from = (/^evolved-from:\s*["']?([^"'\n\r]+)/mi.exec(fm) || [])[1];
+  // CRÍTICO (nemesis): extraer evolved-origin — sin esto, la defensa
+  // 'evolved-origin: user fuerza A' era letra muerta aquí (ev.origin undefined).
+  const origin = (/^evolved-origin:\s*["']?([^"'\n\r]+)/mi.exec(fm) || [])[1];
+  return { evolved: true, from: from ? from.trim() : '', origin: origin ? origin.trim() : '' };
+}
+
+/** Baseline canónico de un componente en una versión: manifiesto actual o git. */
+function baselineCanonico(manifiesto, from, sourceRel) {
+  if (manifiesto && manifiesto[from] && manifiesto[from][sourceRel]) return manifiesto[from][sourceRel];
+  if (!from) return null;
+  const r = spawnSync('git', ['show', `v${from}:${sourceRel}`], { cwd: RAIZ_PKG, encoding: 'utf8' });
+  if (r.status !== 0 || !r.stdout) return null;
+  return canonicalHash(r.stdout);
+}
+
+/**
+ * Conjunto de hashes canónicos que el archivo `sourceRel` tuvo a lo largo de
+ * TODA la historia del repo madre (siguiendo renames). Si el cuerpo instalado
+ * coincide con cualquiera de ellos, el componente es contenido shipped del repo
+ * (ya incorporado en algún momento → B), no una evolución inventada por el
+ * usuario (Punto 1: "analizar si ya lo incorporas al proyecto madre").
+ * @param {string} sourceRel
+ * @param {number} [maxCommits=120]
+ * @returns {Set<string>}
+ */
+function hashesHistoricos(sourceRel, maxCommits = 120) {
+  const set = new Set();
+  const GIT_OPTS = { cwd: RAIZ_PKG, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 };
+  const log = spawnSync('git', ['log', '--all', '--follow', '--pretty=%H', '--', sourceRel], GIT_OPTS);
+  if (log.status !== 0 || !log.stdout) return set;
+  const commits = log.stdout.trim().split('\n').filter(Boolean).slice(0, maxCommits);
+  for (const c of commits) {
+    // status !== 0 es esperado en commits pre-rename (la ruta nueva no existía):
+    // se saltan, no son error. Solo se agregan blobs realmente presentes.
+    const show = spawnSync('git', ['show', `${c}:${sourceRel}`], GIT_OPTS);
+    if (show.status === 0 && show.stdout) set.add(canonicalHash(show.stdout));
+  }
+  return set;
+}
+
+function cargarManifiesto() {
+  try { return JSON.parse(fs.readFileSync(path.join(RAIZ_PKG, 'manifiestos', 'canonical-hashes.json'), 'utf8')); }
+  catch { return {}; }
+}
+
+/** Lista componentes evolved instalados en el target, con su mapeo a fuente. */
+function escanear(target) {
+  const items = [];
+  for (const { runtime, fuente, skill } of MAP_DIRS) {
+    const dir = path.join(target, runtime);
+    if (!fs.existsSync(dir)) continue;
+    if (skill) {
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        const skillMd = path.join(dir, e.name, 'SKILL.md');
+        if (fs.existsSync(skillMd)) items.push({ archivo: skillMd, sourceRel: `${fuente}/${e.name}/SKILL.md`, esDir: true, dir: path.join(dir, e.name) });
+      }
+    } else {
+      for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (e.isFile() && e.name.endsWith('.md')) items.push({ archivo: path.join(dir, e.name), sourceRel: `${fuente}/${e.name}`, esDir: false });
+      }
+    }
+  }
+  return items;
+}
+
+function backupSimple(target, archivo, ts) {
+  const rel = path.relative(target, archivo);
+  const dest = path.join(target, '.swl-evolved-backups', ts, rel);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(archivo, dest);
+  return dest;
+}
+
+function remediar({ target, apply = false } = {}) {
+  target = expandirTarget(target);
+  const manifiesto = cargarManifiesto();
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  // El target es un dir de config runtime (~/.claude, ~/.codex), NO un proyecto:
+  // los artefactos de gobernanza evolved van bajo `.swl-evolved-backups/` (donde
+  // ya viven los backups), sin crear un `.planning/` de proyecto ahí (C-3).
+  const reconcileDir = path.join(target, '.swl-evolved-backups', 'reconcile');
+  const resumen = { target, A: [], B: [], errores: [], reconcileDir };
+
+  for (const item of escanear(target)) {
+    let content;
+    try { content = fs.readFileSync(item.archivo, 'utf8'); } catch (e) { resumen.errores.push({ archivo: item.sourceRel, error: e.message }); continue; }
+    const ev = leerEvolved(content);
+    if (!ev.evolved) continue;
+
+    const fuenteAbs = path.join(RAIZ_PKG, item.sourceRel);
+    const instaladoHash = canonicalHash(content);
+
+    // Clasificación B (shipped → ya incorporado en el repo madre):
+    //   (1) marca explícita evolved-origin: user → A definitivo (defensa en profundidad).
+    //   (2) coincide con baseline del manifiesto / git show v<from>.
+    //   (3) coincide con CUALQUIER estado histórico del archivo en el repo (Punto 1).
+    let esB = false;
+    let evidencia = '';
+    if ((ev.origin || '').toLowerCase() === 'user') {
+      evidencia = 'evolved-origin: user (marca explícita)';
+    } else {
+      const baseline = baselineCanonico(manifiesto, ev.from, item.sourceRel);
+      if (baseline && instaladoHash === baseline) { esB = true; evidencia = `baseline v${ev.from} coincide`; }
+      else if (hashesHistoricos(item.sourceRel).has(instaladoHash)) { esB = true; evidencia = 'coincide con un estado histórico del repo madre'; }
+      else evidencia = baseline ? 'cuerpo difiere de todo estado del repo (edición del usuario)' : 'sin baseline ni coincidencia histórica';
+    }
+
+    if (!esB) {
+      // A — evolución del usuario. PRESERVAR + diff centralizado para revisión upstream.
+      let diffRel = null;
+      if (apply && fs.existsSync(fuenteAbs)) {
+        const m = mergeEvolved(item.archivo, fuenteAbs, 'actual', { diffDir: reconcileDir });
+        if (m.merged && m.diffPath) diffRel = path.relative(target, m.diffPath).replace(/\\/g, '/');
+      }
+      resumen.A.push({ archivo: item.sourceRel, from: ev.from, razon: evidencia, diff: diffRel });
+      continue;
+    }
+
+    // B — shipped intacto. Actualizar al canónico actual del paquete.
+    if (!fs.existsSync(fuenteAbs)) { resumen.errores.push({ archivo: item.sourceRel, error: 'fuente actual no existe' }); continue; }
+    if (apply) {
+      try {
+        const hashFuente = canonicalHash(fs.readFileSync(fuenteAbs, 'utf8')); // antes del copy
+        const backupPath = backupSimple(target, item.archivo, ts);            // backup PRECEDE al overwrite
+        fs.copyFileSync(fuenteAbs, item.archivo); // fuente limpio (sin evolved-*) → descongelado
+        auditarEscritura({ archivo: item.sourceRel, clasificacion: 'B', accion: 'overwrite', hashAntes: instaladoHash, hashDespues: hashFuente, backupPath, evidencia: `remediación: ${evidencia}`, cwd: target, subdir: '.swl-evolved-backups' });
+      } catch (e) { resumen.errores.push({ archivo: item.sourceRel, error: e.message }); continue; }
+    }
+    resumen.B.push({ archivo: item.sourceRel, from: ev.from, razon: evidencia });
+  }
+
+  if (apply) escribirIndiceReconcile(resumen);
+  return resumen;
+}
+
+/** Escribe un índice consolidado de reconciliación (superficie de revisión upstream). */
+function escribirIndiceReconcile(resumen) {
+  if (resumen.A.length === 0) return;
+  try {
+    fs.mkdirSync(resumen.reconcileDir, { recursive: true });
+    const lineas = [
+      '# Reconciliación de evoluciones del usuario (revisión upstream)',
+      '',
+      'Estos componentes difieren de todo estado conocido del repo madre — son',
+      'ediciones locales genuinas. Revisa cada diff y decide si incorporarlo al',
+      'repo con `/swl:aprender` o `/swl:autoresearch`, o descartarlo.',
+      '',
+      '| Componente | evolved-from | Diff | Motivo |',
+      '|---|---|---|---|',
+      ...resumen.A.map(a => `| ${a.archivo} | v${a.from || '?'} | ${a.diff || '—'} | ${a.razon} |`),
+      '',
+    ];
+    fs.writeFileSync(path.join(resumen.reconcileDir, 'INDEX.md'), lineas.join('\n'), 'utf8');
+  } catch { /* best-effort */ }
+}
+
+function imprimir(r, apply) {
+  process.stdout.write(`\n=== Remediación evolved instaladas — target: ${r.target} ===\n`);
+  process.stdout.write(`Modo: ${apply ? 'APPLY (escribe)' : 'DRY-RUN (solo reporta)'}\n\n`);
+  process.stdout.write(`B (shipped intacto → ${apply ? 'actualizado' : 'se actualizaría'}): ${r.B.length}\n`);
+  for (const b of r.B) process.stdout.write(`  ⇪ ${b.archivo} (from v${b.from})\n`);
+  process.stdout.write(`\nA (evolución del usuario → PRESERVADO): ${r.A.length}\n`);
+  for (const a of r.A) process.stdout.write(`  ★ ${a.archivo} (from v${a.from || '?'}) — ${a.razon}\n`);
+  if (r.errores.length) {
+    process.stdout.write(`\nErrores: ${r.errores.length}\n`);
+    for (const e of r.errores) process.stdout.write(`  ! ${e.archivo}: ${e.error}\n`);
+  }
+  if (apply && r.A.length) process.stdout.write(`\nDiffs de reconciliación (revisión upstream): ${path.relative(r.target, r.reconcileDir).replace(/\\/g, '/')}/INDEX.md\n`);
+  if (!apply && r.B.length) process.stdout.write(`\n→ Para aplicar: agregar --apply (backups, diffs y AUDITORIA centralizados en <target>/.swl-evolved-backups/).\n`);
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const targetArg = (args.find(a => a.startsWith('--target=')) || '').slice('--target='.length) || undefined;
+  const apply = args.includes('--apply');
+  const r = remediar({ target: targetArg, apply });
+  imprimir(r, apply);
+  process.exit(0);
+}
+
+module.exports = { remediar, escanear, leerEvolved, baselineCanonico, expandirTarget };

package/scripts/validar.js

@@ -101,6 +101,20 @@ verificar(
     : `Cross-scope: ${auditInvoc.violaciones.length} invocación(es) relativa(s) — ${auditInvoc.violaciones.map(v => `${v.comando}.md:${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
+// downstream. Ver scripts/lib/evolved-fuente.js y verificar-evolucion.js --gate-inverso.
+const { listarOfensores } = require('./lib/evolved-fuente');
+const ofensoresEvolved = listarOfensores(RAIZ);
+const totalOfensores = ofensoresEvolved.frontmatter.length + ofensoresEvolved.sidecars.length;
+verificar(
+  totalOfensores === 0,
+  totalOfensores === 0
+    ? 'Gate inverso evolved: fuente sin marcadores evolved espurios'
+    : `Gate inverso evolved: ${totalOfensores} componente(s) del fuente con evolved (corregir: node scripts/verificar-evolucion.js --gate-inverso --fix)`
+);
+
 // 8. Reglas
 const reglas = fs.readdirSync(path.join(RAIZ, 'reglas')).filter(f => f.endsWith('.md'));
 verificar(reglas.length >= 7, `Reglas: ${reglas.length} (mínimo 7)`);

package/scripts/verificar-evolucion.js

@@ -32,6 +32,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
+const { listarOfensores, limpiar } = require('./lib/evolved-fuente');
 
 /**
  * Detecta si `dir` es la raíz del paquete swl-ses (repo madre).
@@ -291,9 +292,43 @@ function imprimirResultado(r) {
   process.stdout.write('[' + marca + '] ' + r.archivo + ': ' + mensaje + '\n');
 }
 
+/**
+ * Gate inverso (Fase 16, REQ-16-03): ningún componente del FUENTE (repo madre)
+ * puede portar marcador evolved (frontmatter `evolved:true` o sidecar
+ * `.evolved.json`). Un marcador en el fuente es shipped-evolved espurio que
+ * congela el componente downstream. Corre SIEMPRE en el repo madre — es el
+ * complemento exacto del bypass `if (raizPaquete)` de verificarArchivo (que
+ * omite los checks evolved-de-usuario; este gate verifica lo contrario).
+ *
+ * @param {{ fix?: boolean, raiz?: string }} [opts]
+ * @returns {number} 0 si limpio, 1 si hay ofensores (sin --fix)
+ */
+function gateInverso({ fix = false, raiz = process.cwd() } = {}) {
+  if (fix) {
+    const acciones = limpiar(raiz);
+    for (const a of acciones) process.stdout.write(`  [fix] ${a.tipo}: ${a.archivo}\n`);
+    process.stdout.write(`[gate-inverso] limpieza aplicada: ${acciones.length} acción(es)\n`);
+  }
+  const { frontmatter, sidecars } = listarOfensores(raiz);
+  const total = frontmatter.length + sidecars.length;
+  if (total === 0) {
+    process.stdout.write('[gate-inverso] OK — ningún componente del fuente porta marcador evolved.\n');
+    return 0;
+  }
+  process.stdout.write(`[gate-inverso] FALLA — ${total} componente(s) del fuente con marcador evolved (deben limpiarse):\n`);
+  for (const f of frontmatter) process.stdout.write(`  - frontmatter evolved: ${f}\n`);
+  for (const s of sidecars)    process.stdout.write(`  - sidecar .evolved.json: ${s}\n`);
+  process.stdout.write('  → corregir: node scripts/verificar-evolucion.js --gate-inverso --fix\n');
+  return 1;
+}
+
 function main() {
   const args = process.argv.slice(2);
 
+  if (args.includes('--gate-inverso')) {
+    process.exit(gateInverso({ fix: args.includes('--fix') }));
+  }
+
   if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
     process.stdout.write(
       'Uso:\n' +
@@ -351,5 +386,6 @@ module.exports = {
   leerCampo,
   obtenerVersionEnHEAD,
   esRaizDelPaquete,
+  gateInverso,
   main,
 };

package/scripts/verificar-release.js

@@ -317,6 +317,18 @@ function main() {
   // calibración + ADR posterior (mismo patrón que G0/G2/G3).
   const gateLicencias = ejecutarGateLicencias();
 
+  // Gate de evolución (Fase 16, REQ-16-13): el manifiesto canonical-hashes debe
+  // estar al día y el fuente NO debe portar marcadores evolved espurios. Ambos
+  // son blocking — un release con manifiesto stale o fuente evolved congelaría
+  // componentes downstream.
+  const gateEvolved = ejecutarGateEvolved();
+  if (!gateEvolved.ok) {
+    fallasObligatorias++;
+  }
+  console.log(gateEvolved.ok
+    ? '  [OK] Gate evolución: manifiesto al día + fuente sin evolved espurio'
+    : `  [FALLA] Gate evolución: ${gateEvolved.problemas.join('; ')}`);
+
   if (jsonOut) {
     process.stdout.write(JSON.stringify({
       version,
@@ -330,6 +342,7 @@ function main() {
       description_gate: gateDescription,
       aiisms_gate: aiismsGate,
       gate_licencias: gateLicencias,
+      gate_evolved: gateEvolved,
       resultados: resultados.map(({ entrada, resultado }) => ({
         archivo: entrada.archivo,
         obligatorio: entrada.obligatorio,
@@ -887,6 +900,25 @@ function ejecutarGateDescription(contadoresReales) {
  *   para tests; en producción usa el CWD del proceso).
  * @returns {{disponible: boolean, hallazgos?: Array, resumen?: object, error?: string}}
  */
+/**
+ * Gate de evolución (Fase 16): manifiesto canonical-hashes al día + fuente sin
+ * marcadores evolved espurios. Reusa los scripts existentes vía subproceso.
+ * @returns {{ ok: boolean, problemas: string[] }}
+ */
+function ejecutarGateEvolved() {
+  const { spawnSync } = require('child_process');
+  const problemas = [];
+  const correr = (args) => spawnSync(process.execPath, args, { cwd: CWD, encoding: 'utf8' }).status;
+
+  if (correr([path.join(CWD, 'scripts', 'generar-canonical-hashes.js'), '--check']) !== 0) {
+    problemas.push('manifiesto canonical-hashes desactualizado (node scripts/generar-canonical-hashes.js)');
+  }
+  if (correr([path.join(CWD, 'scripts', 'verificar-evolucion.js'), '--gate-inverso']) !== 0) {
+    problemas.push('fuente con marcadores evolved espurios (node scripts/verificar-evolucion.js --gate-inverso --fix)');
+  }
+  return { ok: problemas.length === 0, problemas };
+}
+
 function ejecutarGateLicencias(baseDir = CWD) {
   try {
     const { hallazgos, resumen } = evaluarLicencias(baseDir);
@@ -905,4 +937,5 @@ module.exports = {
   extraerCifrasDescription,
   ejecutarGateDescription,
   ejecutarGateLicencias,
+  ejecutarGateEvolved,
 };

package/agentes/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "release-manager-swl.md": {
-    "evolved": true,
-    "evolvedFrom": "5.10.4",
-    "evolvedAt": "2026-04-20",
-    "evolvedBy": "aprender",
-    "evolvedNote": "gap recurrente en bumps: package-lock nested + .planning/"
-  }
-}

package/comandos/swl/.evolved.json

@@ -1,23 +0,0 @@
-{
-  "release.md": {
-    "evolved": true,
-    "evolvedFrom": "5.4.0",
-    "evolvedAt": "2026-04-11",
-    "evolvedBy": "aprender",
-    "evolvedNote": "mejora de metodología: checklist obligatoria de archivos de versión en paso 6"
-  },
-  "aprender.md": {
-    "evolved": true,
-    "evolvedFrom": "5.12.3",
-    "evolvedAt": "2026-04-25",
-    "evolvedBy": "aprender",
-    "evolvedNote": "Paso 2 — filtro crítico obligatorio sobre reportes de sub-agentes Explore para evitar sobre-ingeniería al analizar papers académicos"
-  },
-  "verificar.md": {
-    "evolved": true,
-    "evolvedFrom": "5.12.3",
-    "evolvedAt": "2026-04-26",
-    "evolvedBy": "evolucionar",
-    "evolvedNote": "flag --until-converge para iterar verificar→corregir→re-verificar hasta 0 hallazgos CRÍTICO+ALTO+MAYOR (max-iter=5, --no-prompt CI, detección adversarial ≥5 hallazgos nuevos)"
-  }
-}

package/habilidades/auth-patrones/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "SKILL.md": {
-    "evolved": true,
-    "evolvedFrom": "5.11.1",
-    "evolvedAt": "2026-04-23",
-    "evolvedBy": "aprender",
-    "evolvedNote": "sección nueva: Multitenancy con get_readable_statement (patrón de polar)"
-  }
-}

package/habilidades/extractor-de-aprendizajes/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "SKILL.md": {
-    "evolved": true,
-    "evolvedFrom": "5.11.0",
-    "evolvedAt": "2026-04-22",
-    "evolvedBy": "aprender",
-    "evolvedNote": "Gotchas nuevos: registro dual manifiestos para hooks + inventario estimado a mano"
-  }
-}

package/habilidades/instalar-sistema/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "SKILL.md": {
-    "evolved": true,
-    "evolvedFrom": "5.10.4",
-    "evolvedAt": "2026-04-20",
-    "evolvedBy": "aprender",
-    "evolvedNote": "state file busqueda en 7 ubicaciones"
-  }
-}

package/habilidades/manejo-errores/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "SKILL.md": {
-    "evolved": true,
-    "evolvedFrom": "1.1.0",
-    "evolvedAt": "2026-05-02",
-    "evolvedBy": "aprender",
-    "evolvedNote": "Gotcha nueva: try/catch require para módulos opcionales (15 archivos migrados)"
-  }
-}

package/habilidades/node-experto/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "SKILL.md": {
-    "evolved": true,
-    "evolvedFrom": "5.3.3",
-    "evolvedAt": "2026-04-09",
-    "evolvedBy": "aprender",
-    "evolvedNote": "anti-patrón JSDoc glob, JSONL append-only, webhook fire-and-forget, dual-use scripts"
-  }
-}

package/habilidades/release-semver/.evolved.json

@@ -1,9 +0,0 @@
-{
-  "SKILL.md": {
-    "evolved": true,
-    "evolvedFrom": "1.0.1",
-    "evolvedAt": "2026-05-02",
-    "evolvedBy": "aprender",
-    "evolvedNote": "Sección nueva: publish a múltiples registries (republish-only + auth GitHub Packages)"
-  }
-}