@saulwade/swl-ses 2.2.0 → 2.2.3

package/habilidades/verificar-trabajo/SKILL.md

@@ -2,11 +2,6 @@
 name: verificar-trabajo
 description: Verificación goal-backward del trabajo ejecutado en 4 niveles progresivos — EXISTE, SUSTANTIVO, CONECTADO, DATOS_FLUYEN. Clasifica claims en 4 tipos (TASK, FIX, TEST_OR_BUILD, FEATURE_GO) con evidencia proporcional. Detecta stubs, componentes huérfanos, integraciones rotas y flujos incompletos. Produce veredictos estructurados JSON con clasificación de riesgo (Low/Medium/High) y evidencia verificable. Soporta loop de reparación cuando el veredicto es Fail.
 version: "1.2.1"
-evolved: true
-evolved-from: "1.2.0"
-evolved-at: "2026-05-15"
-evolved-by: "aprender"
-evolved-note: "Gotchas v1.5.1 acumulados en este ciclo: (1) health-check post-hoc que recalcula contexto del install desde cwd actual → falso positivo (caso doctor 2026-05-15); (2) smoke E2E obligatorio para features cross-cutting (Sub-fase 11.5: transformarAgente nunca invocado pese a suite 100% verde); (3) auto-reparación debe verificar que el chequeo subsecuente ya no detecta el problema, si no → loop infinito (Sub-fase 12: doctor)."
 herramientasPermitidas: [Read, Write, Edit, Bash, Glob, Grep]
 exclusiones:
   - "No cargar durante la implementación activa de una tarea; la verificación es posterior a la implementación, no concurrente."

package/hooks/lib/etapa-perfil-usuario.js

@@ -251,7 +251,7 @@ function ejecutar(inputRaw) {
     //    cada sesión.
     const señalesKw = detectarKeywords(textoUsuario)
       .map(s => {
-        const r = scanInjection(s.snippet, 'perfil-usuario/dirty.json');
+        const r = scanInjection(s.snippet, 'user-profile/dirty.json');
         return { ...s, _scan: r };
       })
       .filter(s => {

package/hooks/lib/evolution-tracker.js

@@ -28,6 +28,75 @@ try {
   atomicWriteJSON = (p, o) => fs.writeFileSync(p, JSON.stringify(o, null, 2), 'utf8');
 }
 
+// Comparación SemVer real (Fase 16 — el bug original comparaba versiones como
+// string). Fallback defensivo a comparación numérica por segmento.
+let compararSemver;
+try {
+  ({ compararSemver } = require('../../scripts/lib/npm-version'));
+} catch {
+  compararSemver = (a, b) => {
+    const pa = /^(\d+)\.(\d+)\.(\d+)/.exec(String(a));
+    const pb = /^(\d+)\.(\d+)\.(\d+)/.exec(String(b));
+    if (!pa || !pb) return null;
+    for (let i = 1; i <= 3; i++) {
+      const x = Number(pa[i]), y = Number(pb[i]);
+      if (x !== y) return x > y ? 1 : -1;
+    }
+    return 0;
+  };
+}
+
+// Discriminador A/B por hash del cuerpo canónico (Fase 16).
+let canonicalHash, hashCoincide;
+try {
+  ({ canonicalHash, hashCoincide } = require('../../scripts/lib/canonical-hash'));
+} catch (e) {
+  // H3 (nemesis O5): no-fallback-silencioso. Si canonical-hash no carga, el
+  // discriminador A/B queda inhabilitado (todo evolved → conflict/merge, jamás
+  // overwrite — protector pero bloquea actualizaciones de shipped). Avisar.
+  try { process.stderr.write(`[evolution-tracker] canonical-hash no disponible (${e.code || e.message}); discriminador A/B deshabilitado → todo evolved se trata como evolución del usuario.\n`); } catch { /* noop */ }
+  canonicalHash = null;
+  hashCoincide = () => false;
+}
+
+/** Ruta al manifiesto de hashes canónicos (baseline del discriminador A/B). */
+const CANONICAL_HASHES_PATH = path.resolve(__dirname, '../../manifiestos/canonical-hashes.json');
+
+/**
+ * Carga el manifiesto de hashes canónicos. Tolera ausencia (→ {}), de modo que
+ * la ausencia de baseline degrada a estrategia protectora (conflict), nunca a
+ * overwrite. Permite override de ruta para tests.
+ * @param {string} [rutaManifiesto]
+ * @returns {object}
+ */
+function _cargarCanonicalHashes(rutaManifiesto) {
+  const ruta = rutaManifiesto || CANONICAL_HASHES_PATH;
+  try {
+    return JSON.parse(fs.readFileSync(ruta, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Deriva la ruta relativa del componente (clave del manifiesto) a partir de la
+ * ruta del archivo ORIGEN (del paquete). El manifiesto usa claves tipo
+ * `agentes/X-swl.md`, `comandos/swl/foo.md`, `habilidades/Y/SKILL.md`,
+ * `reglas/z.md`. Devuelve null si no se reconoce un dominio versionable.
+ * @param {string} origenAbs
+ * @returns {string|null}
+ */
+function _rutaRelComponente(origenAbs) {
+  const partes = String(origenAbs).split(/[\\/]+/);
+  const dominios = new Set(['agentes', 'habilidades', 'comandos', 'reglas']);
+  for (let i = partes.length - 1; i >= 0; i--) {
+    if (dominios.has(partes[i])) {
+      return partes.slice(i).join('/');
+    }
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Constantes
 // ---------------------------------------------------------------------------
@@ -41,6 +110,7 @@ const EVOLUTION_FIELDS = {
   evolvedRounds: 'evolved-rounds', // number: rondas de autoresearch (si aplica)
   evolvedScore:  'evolved-score',  // string: "baseline% → final%"
   evolvedNote:   'evolved-note',   // string: descripción breve del cambio
+  evolvedOrigin: 'evolved-origin', // string: "user" | "shipped" (defensa en profundidad)
 };
 
 /** Nombre del archivo sidecar para componentes sin frontmatter (reglas). */
@@ -123,7 +193,11 @@ function readEvolutionMeta(filePath) {
 
     return { evolved: true, metadata };
   } catch (_) {
-    return empty;
+    // Fail-cerrado (Fase 16, REQ-16-10): un error de lectura/parse NO significa
+    // "no evolucionado". Señalamos `_readError` para que decideUpdateStrategy
+    // proteja el archivo (conflict) en lugar de sobreescribirlo. Mantenemos
+    // `evolved: false` para no contaminar el conteo de scanEvolved.
+    return { evolved: false, metadata: {}, _readError: true };
   }
 }
 
@@ -145,7 +219,10 @@ function _readSidecar(filePath) {
     if (entry && entry.evolved) {
       return { evolved: true, metadata: entry };
     }
-  } catch (_) {}
+  } catch (_) {
+    // Fail-cerrado (REQ-16-10): sidecar corrupto/ilegible → proteger, no overwrite.
+    return { evolved: false, metadata: {}, _readError: true };
+  }
 
   return { evolved: false, metadata: {} };
 }
@@ -235,10 +312,18 @@ function markAsEvolved(filePath, meta) {
     // Detectar EOL del archivo para preservarlo en la escritura.
     const eol = prefix.includes('\r\n') ? '\r\n' : '\n';
 
-    // Remover campos evolved previos
+    // Preservar el origen existente si el caller no lo sobreescribe (REQ-16-06):
+    // un `evolved-origin: shipped` no debe degradarse a `user` por defecto.
+    const existingOrigin = (frontmatter.match(/^evolved-origin:\s*["']?(\w+)["']?/mi) || [])[1];
+    const origin = meta.origin || existingOrigin || 'user';
+
+    // Remover campos evolved previos. Flag `i`: simétrico con la extracción
+    // case-insensitive de existingOrigin (arriba) y con readEvolutionMeta — sin
+    // él, `Evolved-Origin:` se detectaría pero no se removería, dejando campos
+    // duplicados en el frontmatter (Bug 1).
     frontmatter = frontmatter
       .split(/\r?\n/)
-      .filter(line => !line.match(/^evolved[-\w]*:/))
+      .filter(line => !line.match(/^evolved[-\w]*:/i))
       .join(eol);
 
     // Agregar campos nuevos
@@ -248,6 +333,7 @@ function markAsEvolved(filePath, meta) {
       `evolved-from: "${meta.from}"`,
       `evolved-at: "${date}"`,
       `evolved-by: "${meta.by}"`,
+      `evolved-origin: "${origin}"`,
     ];
     if (meta.rounds) newFields.push(`evolved-rounds: ${meta.rounds}`);
     if (meta.score) newFields.push(`evolved-score: "${meta.score}"`);
@@ -279,11 +365,13 @@ function _writeSidecar(filePath, meta) {
     }
   } catch (_) {}
 
+  const existingOrigin = data[basename] && data[basename].evolvedOrigin;
   data[basename] = {
     evolved: true,
     evolvedFrom: meta.from,
     evolvedAt: new Date().toISOString().split('T')[0],
     evolvedBy: meta.by,
+    evolvedOrigin: meta.origin || existingOrigin || 'user',
     ...(meta.rounds && { evolvedRounds: meta.rounds }),
     ...(meta.score && { evolvedScore: meta.score }),
     ...(meta.note && { evolvedNote: meta.note }),
@@ -305,9 +393,18 @@ function _writeSidecar(filePath, meta) {
  * @param {string} versionNueva     - Versión del paquete nuevo (ej: "5.2.0").
  * @returns {{ strategy: 'preserve'|'overwrite'|'conflict', reason: string, metadata?: object }}
  */
-function decideUpdateStrategy(destino, origen, versionNueva) {
+function decideUpdateStrategy(destino, origen, versionNueva, opts = {}) {
   const evo = readEvolutionMeta(destino);
 
+  // Fail-cerrado (REQ-16-10): metadata ilegible/corrupta → proteger, NUNCA overwrite.
+  if (evo._readError) {
+    return {
+      strategy: 'conflict',
+      reason: 'No se pudo leer/parsear la metadata de evolución del destino — se protege el archivo (no overwrite)',
+      metadata: {},
+    };
+  }
+
   if (!evo.evolved) {
     return { strategy: 'overwrite', reason: 'No evolucionado — actualización normal' };
   }
@@ -316,7 +413,7 @@ function decideUpdateStrategy(destino, origen, versionNueva) {
   const evolvedBy = evo.metadata.evolvedBy || evo.metadata.evolved_by || 'auto-evolución';
 
   // Caso 1: evolved: true y no hay archivo origen disponible → preservar siempre
-  // (no podemos comparar, pero el usuario evolucionó deliberadamente)
+  // (no podemos comparar, pero el archivo está marcado como evolucionado).
   if (!origen || !fs.existsSync(origen)) {
     return {
       strategy: 'preserve',
@@ -325,39 +422,75 @@ function decideUpdateStrategy(destino, origen, versionNueva) {
     };
   }
 
-  // Caso 2: Si el contenido del origen (sin evolved fields) es igual al destino (sin evolved fields)
-  // → preservar (la versión nueva no cambió el contenido base de este archivo)
+  let origenContent, destinoContent;
   try {
-    const origenContent  = fs.readFileSync(origen, 'utf8');
-    const destinoContent = fs.readFileSync(destino, 'utf8');
-    const origenSinEvo   = _stripEvolutionFields(origenContent);
-    const destinoSinEvo  = _stripEvolutionFields(destinoContent);
-
-    if (origenSinEvo.trim() === destinoSinEvo.trim()) {
-      return {
-        strategy: 'preserve',
-        reason: 'Contenido base idéntico — solo tiene campos evolved adicionales',
-        metadata: evo.metadata,
-      };
-    }
-  } catch (_) {}
+    origenContent  = fs.readFileSync(origen, 'utf8');
+    destinoContent = fs.readFileSync(destino, 'utf8');
+  } catch (_) {
+    // No se pudo leer alguno de los dos → proteger (fail-cerrado).
+    return {
+      strategy: 'conflict',
+      reason: 'Error de lectura al comparar origen/destino — se protege el archivo (no overwrite)',
+      metadata: evo.metadata,
+    };
+  }
 
-  // Caso 3: La versión base de la evolución es la misma o anterior a la nueva
-  // Y el contenido del destino tiene mutaciones reales → preservar
-  // (las mutaciones del usuario son más valiosas que la actualización base)
-  if (evolvedFrom && evolvedFrom <= versionNueva) {
+  // Caso 2: cuerpo canónico idéntico (ignorando campos evolved, CRLF-safe)
+  // → preservar: la versión nueva no cambió el contenido base de este archivo.
+  const mismoBody = canonicalHash
+    ? canonicalHash(origenContent) === canonicalHash(destinoContent)
+    : _stripEvolutionFields(origenContent).trim() === _stripEvolutionFields(destinoContent).trim();
+  if (mismoBody) {
     return {
       strategy: 'preserve',
-      reason: `Evolucionado desde ${evolvedFrom} por ${evolvedBy} — mutaciones locales preservadas sobre v${versionNueva}`,
+      reason: 'Contenido base idéntico — solo difieren los campos evolved',
+      metadata: evo.metadata,
+    };
+  }
+
+  // El cuerpo difiere entre origen (canónico nuevo) y destino (instalado evolved).
+  // Discriminador A/B (REQ-16-05, REQ-16-06):
+  //   B — shipped-evolved intacto: el cuerpo del destino coincide con el baseline
+  //       de la versión `evolvedFrom` → el usuario NO lo tocó → actualización
+  //       segura (overwrite con backup, lo aplica el caller).
+  //   A — evolución del usuario: el cuerpo difiere del baseline (o no hay
+  //       baseline para esa versión) → MERGE, jamás overwrite (invariante).
+
+  // Defensa en profundidad (REQ-16-06): una marca explícita `evolved-origin: user`
+  // gana sobre el hash. Si el componente declara que fue evolucionado por el
+  // usuario, es A definitivamente — ni siquiera una coincidencia de hash con el
+  // baseline puede degradarlo a overwrite. (Las evoluciones de usuario las marca
+  // markAsEvolved con origin 'user' por defecto.) Inversamente, `shipped` no
+  // fuerza B: aún exige que el hash baseline coincida (el hash manda para B).
+  const origin = (evo.metadata.evolvedOrigin || '').toLowerCase();
+  if (origin === 'user') {
+    return {
+      strategy: 'conflict',
+      reason: 'evolved-origin: user (marca explícita del usuario) — merge, no overwrite',
       metadata: evo.metadata,
     };
   }
 
-  // Caso 4: Versión base diferente + contenido diferente + versión futura (edge case)
-  // → conflicto (requiere revisión manual)
+  const rutaRel = _rutaRelComponente(origen);
+  const manifiesto = _cargarCanonicalHashes(opts.manifestPath);
+  if (rutaRel && hashCoincide(manifiesto, evolvedFrom, rutaRel, destinoContent)) {
+    return {
+      strategy: 'overwrite',
+      reason: `shipped-evolved (hash baseline de v${evolvedFrom} coincide) — actualización segura a v${versionNueva}`,
+      origin: 'shipped',
+      metadata: evo.metadata,
+    };
+  }
+
+  // Caso 3 (REGLA NUEVA): evolución del usuario o sin baseline verificable.
+  // Antes esto hacía `preserve` mudo por comparación string; ahora enruta al
+  // merge definido (el caller invoca mergeEvolved → preserve + .evolved-diff.txt).
+  const semverInfo = compararSemver(evolvedFrom, versionNueva);
   return {
     strategy: 'conflict',
-    reason: `Evolucionado desde ${evolvedFrom} pero la versión nueva (${versionNueva}) tiene cambios significativos. Requiere revisión.`,
+    reason: rutaRel
+      ? `Evolución del usuario (cuerpo difiere del baseline de v${evolvedFrom}) — merge, no overwrite`
+      : `Evolucionado desde v${evolvedFrom} (semver ${semverInfo}) sin baseline verificable — merge, no overwrite`,
     metadata: evo.metadata,
   };
 }
@@ -371,7 +504,7 @@ function decideUpdateStrategy(destino, origen, versionNueva) {
 function _stripEvolutionFields(content) {
   return content
     .split(/\r?\n/)
-    .filter(line => !line.match(/^evolved[-\w]*:/))
+    .filter(line => !line.match(/^evolved[-\w]*:/i))
     .join('\n');
 }
 
@@ -441,7 +574,7 @@ const DIFF_NOISY_THRESHOLD = 50;
  *   error?: string
  * }}
  */
-function mergeEvolved(destino, origen, versionNueva) {
+function mergeEvolved(destino, origen, versionNueva, opts = {}) {
   try {
     if (!fs.existsSync(destino) || !fs.existsSync(origen)) {
       return { merged: false, error: 'Archivo destino u origen no existe' };
@@ -478,11 +611,31 @@ function mergeEvolved(destino, origen, versionNueva) {
       }
     }
 
-    const diffPath = destino.replace(/\.md$/, '.evolved-diff.txt');
-    // Legacy: versiones previas escribían el diff como `.evolved-diff.md`, que
-    // el harness indexaba como slash-command. Se limpia siempre que se toca el
-    // componente, exista o no divergencia nueva.
+    // Diff centralizado (Fase 16, Punto 2): si opts.diffDir está presente, el
+    // diff se escribe en un directorio único de reconciliación (p. ej.
+    // `.planning/evolution/reconcile/`) con nombre plano, en vez de adyacente al
+    // componente. Esto evita ruido en `commands/`/`skills/` (donde scanners y el
+    // harness podrían detectarlo) y da una superficie única de revisión para
+    // decidir incorporación upstream. Si no, fallback adyacente (legacy).
+    const adyacenteTxt = destino.replace(/\.md$/, '.evolved-diff.txt');
     const diffPathLegacy = destino.replace(/\.md$/, '.evolved-diff.md');
+    let diffPath = adyacenteTxt;
+    if (opts.diffDir) {
+      try { fs.mkdirSync(opts.diffDir, { recursive: true }); } catch { /* best-effort */ }
+      // Nombre plano con el directorio padre como prefijo (layout-agnóstico:
+      // sirve para runtime `agents/skills/commands/rules` y fuente
+      // `agentes/habilidades/comandos/reglas`). Evita colisión entre dominios
+      // (p. ej. agents/foo.md vs commands/foo.md → 'agents__foo' vs 'commands__foo').
+      const segs = destino.replace(/\\/g, '/').split('/').filter(Boolean);
+      const esSkill = segs[segs.length - 1] === 'SKILL.md';
+      const baseNombre = esSkill
+        ? `${segs[segs.length - 3] || 'x'}__${segs[segs.length - 2]}__SKILL`
+        : `${segs[segs.length - 2] || 'x'}__${path.basename(segs[segs.length - 1], '.md')}`;
+      const nombrePlano = baseNombre.replace(/[^A-Za-z0-9_.-]/g, '_');
+      diffPath = path.join(opts.diffDir, nombrePlano + '.evolved-diff.txt');
+      // Limpiar cualquier diff adyacente previo (de versiones que no centralizaban).
+      if (fs.existsSync(adyacenteTxt)) { try { fs.unlinkSync(adyacenteTxt); } catch { /* best-effort */ } }
+    }
     const limpiarLegacy = () => {
       if (fs.existsSync(diffPathLegacy)) {
         try { fs.unlinkSync(diffPathLegacy); return true; } catch { /* best-effort */ }
@@ -515,6 +668,9 @@ function mergeEvolved(destino, origen, versionNueva) {
         rounds: evo.metadata.evolvedRounds ? parseInt(evo.metadata.evolvedRounds, 10) : undefined,
         score: evo.metadata.evolvedScore,
         note: `Re-aplicado desde v${evo.metadata.evolvedFrom || '?'} tras actualización a v${versionNueva}`,
+        // mergeEvolved solo se invoca para evolución del usuario (población A):
+        // decideUpdateStrategy enruta shipped (B) a 'overwrite', nunca aquí.
+        origin: evo.metadata.evolvedOrigin || 'user',
         force: true,
       });
       return { merged: marked.marked, cleanedDiff };

package/hooks/resumen-sesion.js

@@ -85,10 +85,10 @@ function hooksDisparados(sessionId) {
   try {
     const planningDir = path.join(process.cwd(), '.planning');
     const jsonlCandidatos = [
-      ['evolucion/nudges.jsonl', 'nudge-tracker'],
-      ['auto-evolucion/agentes.jsonl', 'auto-evolucion'],
-      ['perfil-usuario/dirty.json', 'actualizar-perfil-usuario'],
-      ['evolucion/metricas.json', 'metricas-evolucion'],
+      ['evolution/nudges.jsonl', 'nudge-tracker'],
+      ['auto-evolution/agentes.jsonl', 'auto-evolucion'],
+      ['user-profile/dirty.json', 'actualizar-perfil-usuario'],
+      ['evolution/metricas.json', 'metricas-evolucion'],
     ];
     for (const [rel, nombre] of jsonlCandidatos) {
       const p = path.join(planningDir, rel);

package/llms.txt

@@ -1,6 +1,6 @@
 # swl-ses (@saulwade/swl-ses)
 
-> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. 60 agentes, 182 habilidades, 44 comandos, 37 reglas base y 48 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 2.2.0.
+> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. 60 agentes, 182 habilidades, 44 comandos, 37 reglas base y 48 hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión 2.2.3.
 
 Archivo generado por `node scripts/generar-inventario.js` — no editar a mano. Las cifras se sincronizan con INVENTARIO.md en cada regeneración.