@saulwade/swl-ses 2.1.0 → 2.2.1

package/scripts/lib/canonical-hash.js

@@ -0,0 +1,94 @@
+'use strict';
+
+/**
+ * canonical-hash — Hash determinista del "cuerpo canónico" de un componente SWL.
+ *
+ * El discriminador A/B de la Fase 16 necesita distinguir:
+ *   - Población A: evolución genuina del usuario (cuerpo modificado tras recibir
+ *     el componente del paquete) → debe MERGE, jamás overwrite.
+ *   - Población B: shipped-evolved de fábrica (frontmatter `evolved:*` espurio
+ *     puesto por el repo madre, cuerpo idéntico al canónico) → actualizable.
+ *
+ * La señal es el cuerpo SIN los campos `evolved-*`: si el cuerpo instalado
+ * hashea igual al cuerpo canónico de la versión `evolved-from`, el usuario NO
+ * lo tocó (es B). Si difiere, hubo mutación real del usuario (es A).
+ *
+ * El hash ignora los campos `evolved-*` del frontmatter (que el shipping mete y
+ * quita) y normaliza CRLF→LF para ser estable cross-OS (el usuario corre
+ * Windows; el CI/manifiesto se genera en cualquier plataforma).
+ *
+ * Zero-deps: solo `crypto` nativo. Patrón de hashing precedente en
+ * `hooks/lib/merkle-audit.js` y `scripts/lib/plan-lock.js`.
+ *
+ * @module scripts/lib/canonical-hash
+ */
+
+const { createHash } = require('crypto');
+
+/**
+ * Normaliza el contenido a su "cuerpo canónico":
+ *   - Elimina toda línea de frontmatter `evolved*:` (`evolved:`, `evolved-from:`,
+ *     `evolved-at:`, `evolved-by:`, `evolved-rounds:`, `evolved-score:`,
+ *     `evolved-note:`, `evolved-origin:`).
+ *   - Normaliza line endings CRLF/CR → LF.
+ *   - Recorta whitespace final (un solo `\n` al cierre) para que diferencias de
+ *     EOF no cambien el hash.
+ *
+ * El filtro `^evolved[-\w]*:` se aplica EXCLUSIVAMENTE al bloque frontmatter.
+ * Aplicarlo a todo el archivo (bug detectado en auditoría nemesis Fase 16)
+ * borraría líneas legítimas del body que empiecen con `evolved-*` (p. ej.
+ * `aprender.md`/`evolucionar.md` documentan esos campos en su cuerpo), lo que
+ * causaba un FALSO POSITIVO en el discriminador A/B: el cuerpo del usuario
+ * hasheaba igual al baseline → se clasificaba como shipped → overwrite de
+ * evolución del usuario (violación del invariante merge-no-overwrite).
+ *
+ * Normaliza CRLF/CR → LF (estable cross-OS) antes de hashear.
+ *
+ * @param {string} content
+ * @returns {string} cuerpo canónico normalizado
+ */
+function canonicalBody(content) {
+  const norm = String(content).replace(/\r\n|\r/g, '\n');
+  // Separar frontmatter (entre los primeros dos `---`) del body.
+  const m = norm.match(/^(---\n[\s\S]*?\n---\n?)([\s\S]*)$/);
+  if (!m) {
+    // Sin frontmatter: el contenido completo es body, no se filtra nada.
+    return norm.replace(/\s+$/, '') + '\n';
+  }
+  const fmFiltrado = m[1]
+    .split('\n')
+    .filter((line) => !/^evolved[-\w]*:/i.test(line)) // flag i: simétrico con la detección
+    .join('\n');
+  return (fmFiltrado + m[2]).replace(/\s+$/, '') + '\n';
+}
+
+/**
+ * SHA256 hex (64 chars) del cuerpo canónico de un componente.
+ *
+ * @param {string} content - Contenido completo del archivo `.md`.
+ * @returns {string} hash hex de 64 caracteres
+ */
+function canonicalHash(content) {
+  return createHash('sha256').update(canonicalBody(content), 'utf8').digest('hex');
+}
+
+/**
+ * Decide si el contenido local corresponde al cuerpo canónico shipped de una
+ * versión dada (= NO fue tocado por el usuario = población B).
+ *
+ * @param {object} manifiesto    - `{ version: { rutaRel: sha256 } }`
+ * @param {string} versionPrev   - Versión base (típicamente `evolved-from`).
+ * @param {string} rutaRel       - Ruta relativa del componente (ej. `agentes/X-swl.md`).
+ * @param {string} contenidoLocal- Contenido completo del archivo instalado.
+ * @returns {boolean} true si el hash local coincide con el baseline de esa versión.
+ */
+function hashCoincide(manifiesto, versionPrev, rutaRel, contenidoLocal) {
+  if (!manifiesto || typeof manifiesto !== 'object') return false;
+  const porVersion = manifiesto[versionPrev];
+  if (!porVersion || typeof porVersion !== 'object') return false;
+  const esperado = porVersion[rutaRel];
+  if (!esperado) return false;
+  return canonicalHash(contenidoLocal) === esperado;
+}
+
+module.exports = { canonicalBody, canonicalHash, hashCoincide };

package/scripts/lib/evolved-fuente.js

@@ -0,0 +1,138 @@
+'use strict';
+
+/**
+ * evolved-fuente — Higiene de marcadores de evolución en el repo madre (Fase 16).
+ *
+ * Invariante del sistema: `evolved: true` (frontmatter o sidecar `.evolved.json`)
+ * significa "este componente fue modificado por un USUARIO tras recibirlo del
+ * paquete". En el repo madre (fuente) NO debe existir ningún marcador evolved —
+ * los cambios del mantenedor se rastrean por git + bump de `version`. Un marcador
+ * evolved en el fuente es "shipped-evolved" espurio: confunde al discriminador
+ * A/B del instalador y congela el componente en las máquinas de los usuarios.
+ *
+ * Esta lib:
+ *   - `listarOfensores(raiz)`: detecta marcadores evolved en el fuente (gate inverso).
+ *   - `limpiar(raiz, opts)`: elimina los marcadores (frontmatter evolved-* y
+ *     sidecars), preservando el body intacto.
+ *
+ * Dominios cubiertos: agentes/, habilidades/, comandos/, reglas/.
+ * Zero-deps. CRLF-safe.
+ *
+ * @module scripts/lib/evolved-fuente
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require('../../hooks/lib/atomic-write'));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
+
+const DOMINIOS = ['agentes', 'habilidades', 'comandos', 'reglas'];
+
+function _walk(dir, pred, out) {
+  if (!fs.existsSync(dir)) return;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) _walk(p, pred, out);
+    else if (pred(entry.name)) out.push(p);
+  }
+}
+
+function _rel(raiz, abs) {
+  return path.relative(raiz, abs).replace(/\\/g, '/');
+}
+
+/** ¿El frontmatter (primer bloque ---) declara evolved: true|yes? */
+function _frontmatterTieneEvolved(content) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (!m) return false;
+  return /^evolved:\s*(true|yes)\b/mi.test(m[1]);
+}
+
+/**
+ * Lista los marcadores evolved presentes en el fuente.
+ * @param {string} [raiz=process.cwd()]
+ * @returns {{ frontmatter: string[], sidecars: string[] }}
+ */
+function listarOfensores(raiz) {
+  raiz = raiz || process.cwd();
+  const frontmatter = [];
+  const sidecars = [];
+
+  for (const d of DOMINIOS) {
+    const base = path.join(raiz, d);
+
+    const mds = [];
+    _walk(base, (name) => name.endsWith('.md'), mds);
+    for (const abs of mds) {
+      try {
+        if (_frontmatterTieneEvolved(fs.readFileSync(abs, 'utf8'))) frontmatter.push(_rel(raiz, abs));
+      } catch { /* ilegible: lo ignora el gate, lo verá el linter de IO */ }
+    }
+
+    const sc = [];
+    _walk(base, (name) => name === '.evolved.json', sc);
+    for (const abs of sc) sidecars.push(_rel(raiz, abs));
+  }
+
+  return {
+    frontmatter: frontmatter.sort(),
+    sidecars: sidecars.sort(),
+  };
+}
+
+/**
+ * Elimina las líneas `evolved-*` SOLO del bloque frontmatter, preservando el
+ * body (que puede tener líneas `evolved-*` legítimas como documentación, p. ej.
+ * aprender.md / evolucionar.md).
+ * @param {string} content
+ * @returns {string}
+ */
+function limpiarFrontmatter(content) {
+  const m = content.match(/^(---\r?\n)([\s\S]*?)(\r?\n---)/);
+  if (!m) return content;
+  const eol = m[1].includes('\r\n') ? '\r\n' : '\n';
+  const fmLimpio = m[2]
+    .split(/\r?\n/)
+    // flag `i`: simétrico con la detección case-insensitive de
+    // _frontmatterTieneEvolved. Sin él, `Evolved: true` se detectaría como
+    // ofensor pero no se limpiaría → --fix inútil (nemesis O4).
+    .filter((line) => !/^evolved[-\w]*:/i.test(line))
+    .join(eol);
+  return m[1] + fmLimpio + m[3] + content.slice(m[0].length);
+}
+
+/**
+ * Limpia todos los marcadores evolved del fuente.
+ * @param {string} [raiz=process.cwd()]
+ * @param {{ dryRun?: boolean }} [opts]
+ * @returns {Array<{ tipo: string, archivo: string }>} acciones realizadas/propuestas
+ */
+function limpiar(raiz, { dryRun = false } = {}) {
+  raiz = raiz || process.cwd();
+  const { frontmatter, sidecars } = listarOfensores(raiz);
+  const acciones = [];
+
+  for (const rel of frontmatter) {
+    const abs = path.join(raiz, rel);
+    const orig = fs.readFileSync(abs, 'utf8');
+    const limpio = limpiarFrontmatter(orig);
+    if (limpio !== orig) {
+      acciones.push({ tipo: 'strip-frontmatter', archivo: rel });
+      if (!dryRun) atomicWriteSync(abs, limpio, 'utf8');
+    }
+  }
+
+  for (const rel of sidecars) {
+    acciones.push({ tipo: 'rm-sidecar', archivo: rel });
+    if (!dryRun) fs.unlinkSync(path.join(raiz, rel));
+  }
+
+  return acciones;
+}
+
+module.exports = { listarOfensores, limpiar, limpiarFrontmatter, DOMINIOS };

package/scripts/lib/resolver-plan-fase.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * resolver-plan-fase.js
+ *
+ * Resuelve la ruta del PLAN.md de una fase a partir de las opciones del CLI.
+ * Compartido por los subcomandos `aprobar-plan` y `verificar-plan`.
+ *
+ * Acepta `--plan=<ruta>` explícito o `--fase=N` (deriva
+ * `.planning/fases/0N-PLAN.md`, con fallback sin cero a la izquierda).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * @param {{plan?:string, fase?:(string|number|boolean)}} [opciones]
+ * @returns {string|null} ruta al PLAN, o null si no se pudo derivar.
+ */
+function resolverPlanPath(opciones = {}) {
+  if (opciones && opciones.plan && typeof opciones.plan === 'string') {
+    return opciones.plan;
+  }
+  const fase = opciones ? opciones.fase : undefined;
+  if (fase == null || fase === true) return null;
+  const n = String(fase).padStart(2, '0');
+  const candidatos = [
+    path.join('.planning', 'fases', `${n}-PLAN.md`),
+    path.join('.planning', 'fases', `${fase}-PLAN.md`),
+  ];
+  for (const c of candidatos) {
+    if (fs.existsSync(c)) return c;
+  }
+  return candidatos[0];
+}
+
+module.exports = { resolverPlanPath };

package/scripts/remediar-evolved-instaladas.js

@@ -0,0 +1,239 @@
+#!/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, '-');
+  const reconcileDir = path.join(target, '.planning', 'evolution', '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}` });
+      } 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 en <target>/.swl-evolved-backups/, diffs centralizados en .planning/evolution/reconcile/).\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

@@ -88,6 +88,33 @@ verificar(habilidades.length >= 25, `Habilidades: ${habilidades.length} (mínimo
 const comandos = fs.readdirSync(path.join(RAIZ, 'comandos', 'swl')).filter(f => f.endsWith('.md'));
 verificar(comandos.length >= 9, `Comandos: ${comandos.length} (mínimo 9)`);
 
+// 7b. Gate cross-scope: comandos user-facing sin invocaciones relativas al
+// 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 auditInvoc = auditarInvocacionesComandos(path.join(RAIZ, 'comandos', 'swl'));
+verificar(
+  auditInvoc.ok,
+  auditInvoc.ok
+    ? `Cross-scope: ${auditInvoc.escaneados} comandos sin rutas relativas al proyecto`
+    : `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/scripts/verificar-trazabilidad.js

@@ -295,4 +295,4 @@ if (require.main === module) {
   main();
 }
 
-module.exports = { extraerReqs, extraerMatrizPlan, extraerCommitsConRefs, extraerTestsConMarker, validarFase };
+module.exports = { extraerReqs, extraerMatrizPlan, extraerCommitsConRefs, extraerTestsConMarker, validarFase, main };

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/"
-  }
-}