@saulwade/swl-ses 2.4.3 → 2.5.2

package/scripts/lib/evidencia-valor.js

@@ -0,0 +1,228 @@
+'use strict';
+
+/**
+ * evidencia-valor.js — Evidencia de valor del harness EN CAMPO (downstream).
+ *
+ * En un proyecto real no hay A/B (nadie desarrolla la misma feature dos
+ * veces); la evidencia creíble son HECHOS producidos por actores
+ * independientes del sistema, nunca scores autodeclarados (regla
+ * anti-gaming de seguridad-agentes). Cuatro fuentes, cada una con
+ * procedencia explícita:
+ *
+ *   1. Intercepciones de gates  — eventos durables de `.planning/evolution/
+ *      nudges.jsonl` (hook disparó una intervención). Evidencia directa:
+ *      cada bloqueo/alerta con causa real es un defecto prevenido contable.
+ *   2. Presión de defectos      — git: ratio commits fix/feat en la ventana
+ *      + fixes POSTERIORES a la última verificación de fase (escape rate
+ *      aproximado — la métrica que CASTIGA al harness). Proxy honesto.
+ *   3. DORA-lite + CI           — reusa scripts/lib/metricas-dora.js
+ *      (deployment frequency, lead time, change failure rate, MTTR vía gh).
+ *      Producido por git/GitHub, no por el sistema.
+ *   4. Uso del sistema          — .planning/skill-metrics.json. Solo
+ *      contexto (correlación, jamás causalidad).
+ *
+ * FRONTERA DE DATOS (documentada en docs/evidencia-valor.md): TODO se lee
+ * LOCAL, del `.planning/` y el git del propio proyecto downstream donde
+ * corre el comando. El repo madre NUNCA lee estos datos; el único canal
+ * hacia el autor es el field-report opt-in con agregados anónimos.
+ *
+ * Zero-deps. Funciones puras respecto a raíz/inyecciones para testeo.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const DIA_MS = 24 * 60 * 60 * 1000;
+
+/** Tipos de nudge que constituyen una intervención del sistema (evidencia). */
+const TIPOS_INTERVENCION = new Set([
+  'bloqueo', 'bloqueo-hook', 'secreto-detectado', 'calidad-pre-commit',
+  'drift-detectado', 'recovery-activado', 'riesgo-alto', 'proteccion-rutas',
+  'prompt-injection', 'veto', 'gate-fallido',
+]);
+
+// ─── 1. Intercepciones (nudges.jsonl) ────────────────────────────────────────
+
+/**
+ * Diagnóstico de POR QUÉ no hay telemetría: los hooks solo se registran a
+ * nivel PROYECTO (ADR-0009 — un install --global copia los archivos pero NO
+ * los registra en ~/.claude/settings.json, para no correr 49 hooks en cada
+ * sesión de cualquier proyecto). Sin registro local, nudges.jsonl y
+ * skill-metrics.json jamás aparecerán — el panel debe decir CÓMO activarlo,
+ * no solo "no disponible" (reporte de campo SIGM, 2026-07-09).
+ */
+function hooksRegistradosEnProyecto(raiz) {
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(raiz, '.claude', 'settings.json'), 'utf8'));
+    return Object.values(s.hooks || {}).some(m => Array.isArray(m) && m.length > 0);
+  } catch { return false; }
+}
+
+const HINT_ACTIVACION = 'hooks sin registrar a nivel proyecto (el install --global no los registra por diseño, ADR-0009) — activar con: npx -y @saulwade/swl-ses@latest install --target claude --perfil core (SIN --global, en la raíz del proyecto)';
+
+function leerNudges(raiz, { ventanaDias = 30, hoy = new Date() } = {}) {
+  const ruta = path.join(raiz, '.planning', 'evolution', 'nudges.jsonl');
+  if (!fs.existsSync(ruta)) {
+    const razon = hooksRegistradosEnProyecto(raiz)
+      ? 'sin nudges.jsonl aún (hooks registrados; se acumula con el uso de sesiones)'
+      : HINT_ACTIVACION;
+    return { disponible: false, razon, eventos: [] };
+  }
+  const corte = hoy.getTime() - ventanaDias * DIA_MS;
+  const eventos = [];
+  for (const linea of fs.readFileSync(ruta, 'utf8').split(/\r?\n/)) {
+    if (!linea.trim()) continue;
+    try {
+      const e = JSON.parse(linea);
+      const t = Date.parse(e.timestamp || e.ts || '');
+      if (!Number.isNaN(t) && t >= corte) eventos.push(e);
+    } catch { /* línea corrupta: se omite, no revienta el panel */ }
+  }
+  return { disponible: true, eventos };
+}
+
+function intercepciones(raiz, opts = {}) {
+  const { disponible, razon, eventos } = leerNudges(raiz, opts);
+  if (!disponible) return { disponible, razon, procedencia: 'hook-event (nudges.jsonl)', total: 0, porTipo: {} };
+  const porTipo = {};
+  let intervenciones = 0;
+  for (const e of eventos) {
+    const tipo = String(e.tipo || 'desconocido');
+    porTipo[tipo] = (porTipo[tipo] || 0) + 1;
+    if (TIPOS_INTERVENCION.has(tipo) || e.blocking === true || e.estado === 'critico') intervenciones++;
+  }
+  return {
+    disponible: true,
+    procedencia: 'hook-event (nudges.jsonl)',
+    caracter: 'evidencia',
+    totalEventos: eventos.length,
+    intervenciones,
+    porTipo,
+  };
+}
+
+// ─── 2. Presión de defectos (git) ────────────────────────────────────────────
+
+function ejecutarGit(raiz, args) {
+  return execFileSync('git', args, { cwd: raiz, encoding: 'utf8' });
+}
+
+function presionDefectos(raiz, { ventanaDias = 30, hoy = new Date(), git = ejecutarGit } = {}) {
+  let sujetos;
+  try {
+    const desde = new Date(hoy.getTime() - ventanaDias * DIA_MS).toISOString();
+    sujetos = git(raiz, ['log', `--since=${desde}`, '--pretty=format:%ad|%s', '--date=iso-strict'])
+      .split(/\r?\n/).filter(Boolean);
+  } catch (err) {
+    return { disponible: false, razon: `git no disponible: ${err.message.split(/\r?\n/)[0]}` };
+  }
+  const esFix = s => /^(fix|hotfix)(\(|!|:)/.test(s);
+  const esFeat = s => /^feat(\(|!|:)/.test(s);
+  const fixes = sujetos.filter(l => esFix(l.split('|').slice(1).join('|')));
+  const feats = sujetos.filter(l => esFeat(l.split('|').slice(1).join('|')));
+
+  // Escape aproximado: fixes con fecha POSTERIOR a la última verificación de
+  // fase (VERIFICACION.md más reciente). Sin fases verificadas → no aplica.
+  // La fecha se toma de GIT (autoría del último commit que tocó el archivo),
+  // no del mtime del filesystem: tras un clone/checkout todos los archivos
+  // comparten el mtime de la operación y el proxy daba falso negativo
+  // (reporte de campo SIGM, 2026-07-09). Fallback a mtime fuera de git.
+  let escapes = { disponible: false, razon: 'sin VERIFICACION.md en .planning/fases/ (proyecto sin ciclo GSD verificado)' };
+  try {
+    const dirFases = path.join(raiz, '.planning', 'fases');
+    let ultimaVerificacion = 0;
+    if (fs.existsSync(dirFases)) {
+      for (const fase of fs.readdirSync(dirFases)) {
+        const v = path.join(dirFases, fase, 'VERIFICACION.md');
+        if (!fs.existsSync(v)) continue;
+        let fecha = 0;
+        try {
+          const rel = path.relative(raiz, v);
+          const ct = parseInt(git(raiz, ['log', '-1', '--format=%ct', '--', rel]).trim(), 10);
+          if (Number.isFinite(ct) && ct > 0) fecha = ct * 1000;
+        } catch { /* fuera de git o archivo sin commits → fallback mtime */ }
+        if (fecha === 0) fecha = fs.statSync(v).mtimeMs;
+        ultimaVerificacion = Math.max(ultimaVerificacion, fecha);
+      }
+    }
+    if (ultimaVerificacion > 0) {
+      const post = fixes.filter(l => {
+        const t = Date.parse(l.split('|')[0]);
+        return !Number.isNaN(t) && t > ultimaVerificacion;
+      });
+      escapes = {
+        disponible: true,
+        fixesTrasUltimaVerificacion: post.length,
+        ultimaVerificacion: new Date(ultimaVerificacion).toLocaleDateString('sv'),
+        nota: 'lo que el harness NO atrapó — la métrica que lo castiga',
+      };
+    }
+  } catch { /* best-effort */ }
+
+  return {
+    disponible: true,
+    procedencia: 'git log (independiente del sistema)',
+    caracter: 'proxy',
+    commits: sujetos.length,
+    fixes: fixes.length,
+    feats: feats.length,
+    ratioFixFeat: feats.length > 0 ? +(fixes.length / feats.length).toFixed(2) : null,
+    escapes,
+  };
+}
+
+// ─── 3 y 4. DORA/CI y uso (reuso de fuentes existentes) ─────────────────────
+
+function doraCi(raiz, { ventanaDias = 30, hoy = new Date() } = {}) {
+  try {
+    const { calcularDora } = require('./metricas-dora.js');
+    const d = calcularDora(raiz, { ventanaDias, hoy });
+    return { disponible: true, procedencia: 'git + GitHub Actions (gh)', caracter: 'evidencia (tendencia; correlación, no causalidad)', dora: d };
+  } catch (err) {
+    return { disponible: false, razon: `metricas-dora no disponible: ${err.message.split(/\r?\n/)[0]}` };
+  }
+}
+
+function usoSistema(raiz) {
+  const ruta = path.join(raiz, '.planning', 'skill-metrics.json');
+  if (!fs.existsSync(ruta)) {
+    const razon = hooksRegistradosEnProyecto(raiz)
+      ? 'sin skill-metrics.json aún (hooks registrados; se acumula con el uso de skills)'
+      : HINT_ACTIVACION;
+    return { disponible: false, razon };
+  }
+  try {
+    // Forma real: { version, entries: [{skill, estado, timestamp}, ...] }
+    // (eventos individuales del hook telemetria-skill-routing) — agregamos aquí.
+    const m = JSON.parse(fs.readFileSync(ruta, 'utf8'));
+    const eventos = Object.values(m.entries || {});
+    const porSkill = {};
+    for (const e of eventos) {
+      if (!e || !e.skill) continue;
+      porSkill[e.skill] = (porSkill[e.skill] || 0) + 1;
+    }
+    const top = Object.entries(porSkill).sort((a, b) => b[1] - a[1]).slice(0, 5)
+      .map(([k, n]) => `${k}:${n}`);
+    return { disponible: true, procedencia: 'telemetria-skill-routing', caracter: 'contexto (solo correlación)', invocaciones: eventos.length, top5: top };
+  } catch (err) {
+    return { disponible: false, razon: `skill-metrics ilegible: ${err.message}` };
+  }
+}
+
+// ─── Panel ────────────────────────────────────────────────────────────────────
+
+function panelEvidencia(raiz = process.cwd(), opts = {}) {
+  const ventanaDias = opts.ventanaDias || 30;
+  return {
+    generado: new Date().toLocaleDateString('sv'),
+    ventanaDias,
+    frontera: 'Datos 100% locales del proyecto (.planning/ + git). El repo madre no lee nada de aquí (docs/evidencia-valor.md).',
+    intercepciones: intercepciones(raiz, { ventanaDias, hoy: opts.hoy }),
+    defectos: presionDefectos(raiz, { ventanaDias, hoy: opts.hoy, git: opts.git }),
+    doraCi: doraCi(raiz, { ventanaDias, hoy: opts.hoy }),
+    uso: usoSistema(raiz),
+  };
+}
+
+module.exports = { panelEvidencia, intercepciones, presionDefectos, leerNudges, usoSistema, TIPOS_INTERVENCION };

package/scripts/lib/expandir-targets.js

@@ -1,71 +1,71 @@
-'use strict';
-
-/**
- * Expansión de --target (CSV) y --all-runtimes para multi-target install.
- *
- * ADR-0019 Sub-fase 2.5.
- *
- * Extraído de bin/swl-ses.js para permitir tests unitarios. NUNCA debe tener
- * side effects fuera de logging — solo manipula la lista de strings.
- *
- * @module scripts/lib/expandir-targets
- */
-
-const { listarRuntimesInstalables, RUNTIMES } = require('./detectar-runtime');
-
-/**
- * Expande las opciones del CLI a un array de target IDs.
- *
- * Reglas:
- *  - `all_runtimes` tiene prioridad sobre `target`. Si ambos vienen, se loggea
- *    aviso (vía `logger.warn`) y se usa `all_runtimes`.
- *  - `target='a,b,c'` → ['a','b','c'].
- *  - `target='claude'` → ['claude'].
- *  - Sin nada → ['claude'] (default histórico, backward-compat).
- *  - Duplicados se deduplican preservando el primer orden.
- *  - Targets desconocidos se omiten con aviso (logger.warn).
- *
- * @param {object} opciones - Objeto con `target` (string|undefined) y `all_runtimes` (bool).
- * @param {object} [logger] - Sustituible para tests. Default console.
- * @returns {{ targets: string[], omitidos: string[], errores: string[] }}
- */
-function expandirTargets(opciones, logger) {
-  const log = logger || console;
-  const omitidos = [];
-  const errores = [];
-
-  let candidatos;
-  if (opciones.all_runtimes) {
-    if (opciones.target && typeof opciones.target === 'string') {
-      log.warn && log.warn('[expandir-targets] --all-runtimes tiene prioridad sobre --target; se ignora --target.');
-    }
-    candidatos = listarRuntimesInstalables();
-  } else if (typeof opciones.target === 'string' && opciones.target.includes(',')) {
-    candidatos = opciones.target.split(',').map(s => s.trim()).filter(Boolean);
-  } else if (typeof opciones.target === 'string' && opciones.target.length > 0) {
-    candidatos = [opciones.target.trim()];
-  } else {
-    candidatos = ['claude']; // backward-compat
-  }
-
-  const visto = new Set();
-  const targets = [];
-  for (const t of candidatos) {
-    if (visto.has(t)) continue;
-    visto.add(t);
-    if (!RUNTIMES[t]) {
-      log.warn && log.warn(`[expandir-targets] Target desconocido omitido: "${t}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`);
-      omitidos.push(t);
-      continue;
-    }
-    targets.push(t);
-  }
-
-  if (targets.length === 0) {
-    errores.push('Ningún target válido tras expansión.');
-  }
-
-  return { targets, omitidos, errores };
-}
-
-module.exports = { expandirTargets };
+'use strict';
+
+/**
+ * Expansión de --target (CSV) y --all-runtimes para multi-target install.
+ *
+ * ADR-0019 Sub-fase 2.5.
+ *
+ * Extraído de bin/swl-ses.js para permitir tests unitarios. NUNCA debe tener
+ * side effects fuera de logging — solo manipula la lista de strings.
+ *
+ * @module scripts/lib/expandir-targets
+ */
+
+const { listarRuntimesInstalables, RUNTIMES } = require('./detectar-runtime');
+
+/**
+ * Expande las opciones del CLI a un array de target IDs.
+ *
+ * Reglas:
+ *  - `all_runtimes` tiene prioridad sobre `target`. Si ambos vienen, se loggea
+ *    aviso (vía `logger.warn`) y se usa `all_runtimes`.
+ *  - `target='a,b,c'` → ['a','b','c'].
+ *  - `target='claude'` → ['claude'].
+ *  - Sin nada → ['claude'] (default histórico, backward-compat).
+ *  - Duplicados se deduplican preservando el primer orden.
+ *  - Targets desconocidos se omiten con aviso (logger.warn).
+ *
+ * @param {object} opciones - Objeto con `target` (string|undefined) y `all_runtimes` (bool).
+ * @param {object} [logger] - Sustituible para tests. Default console.
+ * @returns {{ targets: string[], omitidos: string[], errores: string[] }}
+ */
+function expandirTargets(opciones, logger) {
+  const log = logger || console;
+  const omitidos = [];
+  const errores = [];
+
+  let candidatos;
+  if (opciones.all_runtimes) {
+    if (opciones.target && typeof opciones.target === 'string') {
+      log.warn && log.warn('[expandir-targets] --all-runtimes tiene prioridad sobre --target; se ignora --target.');
+    }
+    candidatos = listarRuntimesInstalables();
+  } else if (typeof opciones.target === 'string' && opciones.target.includes(',')) {
+    candidatos = opciones.target.split(',').map(s => s.trim()).filter(Boolean);
+  } else if (typeof opciones.target === 'string' && opciones.target.length > 0) {
+    candidatos = [opciones.target.trim()];
+  } else {
+    candidatos = ['claude']; // backward-compat
+  }
+
+  const visto = new Set();
+  const targets = [];
+  for (const t of candidatos) {
+    if (visto.has(t)) continue;
+    visto.add(t);
+    if (!RUNTIMES[t]) {
+      log.warn && log.warn(`[expandir-targets] Target desconocido omitido: "${t}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`);
+      omitidos.push(t);
+      continue;
+    }
+    targets.push(t);
+  }
+
+  if (targets.length === 0) {
+    errores.push('Ningún target válido tras expansión.');
+  }
+
+  return { targets, omitidos, errores };
+}
+
+module.exports = { expandirTargets };

package/scripts/lib/frontmatter-md.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * frontmatter-md.js — Parser mínimo zero-deps de frontmatter YAML en archivos .md.
+ *
+ * Soporta el subconjunto que usan los componentes SWL:
+ *   - pares `clave: valor` de una línea (comillas opcionales)
+ *   - escalares plegados (`clave: >`, `|`, `>-`, `|-`) juntando las líneas indentadas
+ *   - listas inline (`tools: [Read, Write]`) — se devuelven como string; usar
+ *     `parsearListaInline()` para convertirlas a array
+ *
+ * NO es un parser YAML completo (sin listas multilínea ni objetos anidados) —
+ * suficiente y determinista para frontmatter de agentes/skills/comandos.
+ * Consumidores: scripts/generar-inventario.js, scripts/generar-comandos.js.
+ */
+
+const fs = require('fs');
+
+function leerFrontmatter(ruta) {
+  try {
+    const contenido = fs.readFileSync(ruta, 'utf8');
+    const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match) return {};
+    const fm = {};
+    const lineas = match[1].split(/\r?\n/);
+    for (let i = 0; i < lineas.length; i++) {
+      const linea = lineas[i];
+      if (/^\s/.test(linea)) continue; // continuación de multilínea
+      const idx = linea.indexOf(':');
+      if (idx <= 0) continue;
+      const key = linea.slice(0, idx).trim();
+      let val = linea.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+      if (val === '>' || val === '|' || val === '>-' || val === '|-' || val === '') {
+        const partes = [];
+        for (let j = i + 1; j < lineas.length && /^\s+\S/.test(lineas[j]); j++) {
+          partes.push(lineas[j].trim());
+        }
+        if (partes.length > 0) val = partes.join(' ');
+      }
+      fm[key] = val;
+    }
+    return fm;
+  } catch { return {}; }
+}
+
+/** `[a, b, c]` → ['a','b','c']; string vacío → []. */
+function parsearListaInline(valor) {
+  return String(valor || '')
+    .replace(/^\[|\]$/g, '')
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+}
+
+/** Recorta a n caracteres en límite de palabra, colapsando whitespace y pipes. */
+function resumir(texto, n = 110) {
+  const limpio = String(texto || '').replace(/\s+/g, ' ').replace(/\|/g, '/').trim();
+  if (limpio.length <= n) return limpio;
+  const corte = limpio.lastIndexOf(' ', n);
+  return limpio.slice(0, corte > 40 ? corte : n) + '…';
+}
+
+module.exports = { leerFrontmatter, parsearListaInline, resumir };

package/scripts/lib/parsear-opciones.js

@@ -48,6 +48,8 @@ const BOOLEANAS = [
   // TUI opt-out (Fase 4 instalador visual). Default: si stdin es TTY y no
   // hay flags, lanza el TUI. Con --no-tui cae al install-asistido clásico.
   'no-tui', 'tui',
+  // prune (DT-INSTALADOR-PRUNE): --confirmar ejecuta el plan; --json salida machine-readable
+  'confirmar', 'json',
 ];
 
 /**

package/scripts/lib/prune-componentes.js

@@ -0,0 +1,180 @@
+'use strict';
+
+/**
+ * prune-componentes — Purga de componentes retirados en instalaciones SWL.
+ *
+ * Cierra DT-INSTALADOR-PRUNE: cuando el paquete retira un componente
+ * (skill/agente/comando/regla/hook), las instalaciones existentes lo
+ * conservaban para siempre. Este módulo compara el `.swl-install-state.json`
+ * del destino contra el paquete actual y elimina SOLO lo que cumple las dos
+ * condiciones de seguridad:
+ *
+ *   1. El `origen` registrado ya NO existe en el paquete (componente retirado).
+ *   2. El contenido instalado coincide con un hash canónico conocido del
+ *      componente (manifiestos/canonical-hashes.json, cualquier versión) —
+ *      es contenido de fábrica sin tocar.
+ *
+ * Si el contenido difiere de todo hash canónico conocido (evolución del
+ * usuario) o el componente no tiene hash registrado (p. ej. recursos/ de un
+ * skill), NUNCA se elimina: se reporta como `preservados` para revisión
+ * manual. Invariante merge-no-overwrite (ADR-0040) extendida al borrado.
+ *
+ * API pura respecto de rutas: recibe `rutaBase` (instalación destino) y
+ * `raizPaquete` (paquete fuente actual). El caller (scripts/prune.js) resuelve
+ * ambos; los tests inyectan sandboxes.
+ *
+ * @module scripts/lib/prune-componentes
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { cargarEstado, guardarEstado } = require('./estado.js');
+const { canonicalHash } = require('./canonical-hash.js');
+
+/**
+ * Construye el índice rutaRelativa → Set(hashes canónicos de todas las
+ * versiones) desde manifiestos/canonical-hashes.json del paquete.
+ *
+ * @param {string} raizPaquete
+ * @returns {Map<string, Set<string>>}
+ */
+function cargarHashesConocidos(raizPaquete) {
+  const indice = new Map();
+  try {
+    const ruta = path.join(raizPaquete, 'manifiestos', 'canonical-hashes.json');
+    const porVersion = JSON.parse(fs.readFileSync(ruta, 'utf-8'));
+    for (const version of Object.keys(porVersion)) {
+      const componentes = porVersion[version];
+      if (!componentes || typeof componentes !== 'object') continue;
+      for (const [rutaRel, hash] of Object.entries(componentes)) {
+        const clave = rutaRel.replace(/\\/g, '/');
+        if (!indice.has(clave)) indice.set(clave, new Set());
+        indice.get(clave).add(String(hash));
+      }
+    }
+  } catch { /* sin manifiesto de hashes → índice vacío → todo se preserva */ }
+  return indice;
+}
+
+/**
+ * Clasifica los archivos instalados contra el paquete actual.
+ *
+ * @param {object} opciones
+ * @param {string} opciones.rutaBase     Directorio de la instalación (contiene .swl-install-state.json)
+ * @param {string} opciones.raizPaquete  Raíz del paquete swl-ses actual
+ * @returns {{
+ *   error?: string,
+ *   eliminables: Array<{origen: string, destino: string, tipo: string}>,
+ *   preservados: Array<{origen: string, destino: string, tipo: string, razon: string}>,
+ *   yaAusentes: Array<{origen: string, destino: string}>,
+ *   vigentes: number,
+ * }}
+ */
+function planPrune({ rutaBase, raizPaquete }) {
+  const estado = cargarEstado(rutaBase);
+  if (!estado) {
+    return { error: `No hay .swl-install-state.json en ${rutaBase} — nada que podar.`, eliminables: [], preservados: [], yaAusentes: [], vigentes: 0 };
+  }
+
+  const hashesConocidos = cargarHashesConocidos(raizPaquete);
+  const eliminables = [];
+  const preservados = [];
+  const yaAusentes = [];
+  let vigentes = 0;
+
+  for (const archivo of estado.archivosInstalados || []) {
+    const origenRel = String(archivo.origen || '').replace(/\\/g, '/');
+    if (!origenRel) continue;
+
+    if (fs.existsSync(path.join(raizPaquete, origenRel))) {
+      vigentes++;
+      continue; // el paquete todavía distribuye este componente
+    }
+
+    // Componente retirado del paquete.
+    if (!fs.existsSync(archivo.destino)) {
+      yaAusentes.push({ origen: origenRel, destino: archivo.destino });
+      continue;
+    }
+
+    const hashes = hashesConocidos.get(origenRel);
+    if (!hashes || hashes.size === 0) {
+      preservados.push({
+        origen: origenRel,
+        destino: archivo.destino,
+        tipo: archivo.tipo || '?',
+        razon: 'sin hash canónico registrado — revisar y borrar manualmente si aplica',
+      });
+      continue;
+    }
+
+    let hashLocal;
+    try {
+      hashLocal = canonicalHash(fs.readFileSync(archivo.destino, 'utf-8'));
+    } catch {
+      preservados.push({ origen: origenRel, destino: archivo.destino, tipo: archivo.tipo || '?', razon: 'destino ilegible' });
+      continue;
+    }
+
+    if (hashes.has(hashLocal)) {
+      eliminables.push({ origen: origenRel, destino: archivo.destino, tipo: archivo.tipo || '?' });
+    } else {
+      preservados.push({
+        origen: origenRel,
+        destino: archivo.destino,
+        tipo: archivo.tipo || '?',
+        razon: 'contenido evolucionado por el usuario (hash ≠ canónico) — merge-no-overwrite',
+      });
+    }
+  }
+
+  return { eliminables, preservados, yaAusentes, vigentes };
+}
+
+/**
+ * Ejecuta el plan: borra los eliminables, limpia del estado las entradas
+ * eliminadas y las ya ausentes, y persiste el estado actualizado.
+ *
+ * @param {object} plan        Resultado de planPrune
+ * @param {object} opciones
+ * @param {string} opciones.rutaBase
+ * @returns {{eliminados: string[], erroresBorrado: Array<{destino: string, error: string}>, entradasLimpiadas: number}}
+ */
+function ejecutarPrune(plan, { rutaBase }) {
+  const eliminados = [];
+  const erroresBorrado = [];
+
+  for (const item of plan.eliminables) {
+    try {
+      fs.unlinkSync(item.destino);
+      eliminados.push(item.destino);
+      // Si el directorio del skill quedó vacío (p. ej. habilidades/x/), retirarlo.
+      const dir = path.dirname(item.destino);
+      try {
+        if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+      } catch { /* dir compartido o ya ausente — irrelevante */ }
+    } catch (err) {
+      erroresBorrado.push({ destino: item.destino, error: err.message });
+    }
+  }
+
+  // Limpiar el estado: fuera las entradas eliminadas y las ya ausentes.
+  const estado = cargarEstado(rutaBase);
+  let entradasLimpiadas = 0;
+  if (estado) {
+    const quitar = new Set([
+      ...eliminados,
+      ...plan.yaAusentes.map(a => a.destino),
+    ]);
+    const antes = estado.archivosInstalados.length;
+    estado.archivosInstalados = estado.archivosInstalados.filter(a => !quitar.has(a.destino));
+    entradasLimpiadas = antes - estado.archivosInstalados.length;
+    estado.actualizadoEn = new Date().toISOString();
+    guardarEstado(estado, rutaBase);
+  }
+
+  return { eliminados, erroresBorrado, entradasLimpiadas };
+}
+
+module.exports = { planPrune, ejecutarPrune, cargarHashesConocidos };

package/scripts/lib/reglas-globales-conocidas.json

@@ -1,8 +1,8 @@
 {
   "$schema-version": "1.0.0",
   "description": "Catálogo de reglas globales ~/.claude/rules/ que NO deben duplicarse inline en CLAUDE.md de proyectos. Consumido por scripts/lib/detector-reglas-duplicadas.js y por scripts/auditar-claudemd.js dimensión 'duplicacion-reglas-globales'. Cada entrada lista: nombre canónico, archivo origen, sección canónica para referenciar, patrones de detección (regex), y reemplazo sugerido.",
-  "version": "1.1.0",
-  "actualizado": "2026-05-22",
+  "version": "1.2.0",
+  "actualizado": "2026-07-08",
   "reglas": [
     {
       "id": "idioma-espanol-mexico",
@@ -168,6 +168,20 @@
       "min_matches": 1,
       "scope": "project-level",
       "remediacion_sugerida": "Eliminar el bloque local. La regla global aplica a cualquier proyecto con vault Obsidian disponible."
+    },
+    {
+      "id": "usar-code-review-graph",
+      "regla_global": "usar-code-review-graph.md",
+      "seccion_canonica": "Usar code-review-graph antes de Read/Grep/Glob para explorar",
+      "referencia_canonica": "@~/.claude/rules/usar-code-review-graph.md",
+      "descripcion": "Comportamiento completo del MCP code-review-graph (tabla de herramientas, workflow, excepciones). El CLAUDE.md del proyecto solo declara la disponibilidad del grafo — re-derivar el comportamiento inline es duplicación. Caso real: CLAUDE.md de swl-ses acumuló 37 líneas re-derivándolo en inglés (removido 2026-07-08).",
+      "patrones": [
+        "ALWAYS use thes+code-review-graph",
+        "code-review-graph MCP tools BEFORE",
+        "graph tools FIRST",
+        "detect_changes.*get_review_context|get_impact_radius.*blast radius"
+      ],
+      "remediacion_sugerida": "Una línea en Stack: 'MCP del proyecto: code-review-graph disponible vía .mcp.json. Comportamiento: @~/.claude/rules/usar-code-review-graph.md'"
     }
   ],
   "configuracion": {

package/scripts/lib/scoring-instintos.js

@@ -203,8 +203,8 @@ function applyFeedback(instinto, type, currentDate) {
     throw new Error(`Tipo de feedback inválido: ${type}`);
   }
   const now = (currentDate instanceof Date)
-    ? currentDate.toISOString().slice(0, 10)
-    : (currentDate || new Date().toISOString().slice(0, 10));
+    ? currentDate.toLocaleDateString('sv')
+    : (currentDate || new Date().toLocaleDateString('sv'));
 
   const next = { ...instinto };
   if (type === 'helpful') next.helpful_count = (next.helpful_count || 0) + 1;