@saulwade/swl-ses 2.5.3 → 2.6.1

package/scripts/actualizar.js

@@ -226,6 +226,9 @@ async function update(opciones) {
           profile: estado.perfil,
           global: estado.global,
           force: true,
+          // Módulos opt-in registrados por --with en installs previos
+          // (DT-MODULOS-OPT-IN): sin re-pasarlos, el update los perdía.
+          with: (estado.modulosExtra || []).join(',') || undefined,
         });
 
         sp.exito(`${runtime.nombre} actualizado a v${VERSION} (${estado.archivosInstalados.length} archivos)`);

package/scripts/auditar-clases-conocidas.js

@@ -1,106 +1,134 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * auditar-clases-conocidas.js — Gate de clases de bug ya documentadas.
- *
- * "El conocimiento documentado no previene — solo los gates previenen."
- * Cada clase de este gate mordió al proyecto en producción pese a estar
- * escrita como regla/aprendizaje. El gate la vuelve imposible de reintroducir:
- *
- *   C1 — Fecha UTC truncada: toISOString + slice(0,10) fecha artefactos
- *        "mañana" desde México (23 instancias corregidas 2026-07-08/09).
- *        Correcto: `toLocaleDateString('sv')`. Escape: `// fecha-utc-ok`.
- *        (El patrón no se escribe literal aquí: el gate escanea este archivo
- *        también — se auto-detectó en el publish v2.5.1.)
- *   C2 — Comparación byte a byte en modos --check: comparar texto leído de
- *        disco sin normalizar EOL revienta con CRLF tras checkout/reset de
- *        git (tumbó el publish v2.5.0). Un script con modo --check que lee
- *        texto debe normalizar `\r\n` o comparar estructuras (JSON.parse).
- *        Escape: `// eol-ok: <razón>`.
- *   C3 — Bloqueo ciego en hooks: exit(2) sin console.error deja al modelo
- *        sin la razón del bloqueo (el canal de exit 2 es stderr).
- *
- * Alcance: archivos .js versionados en scripts/, hooks/, bin/, gateway/
- * (tests/ excluido: los tests DEBEN poder citar el patrón para validarlo).
- * Exit: 0 limpio · 1 con hallazgos.
- */
-
-const { execFileSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const RAIZ = path.resolve(__dirname, '..');
-
-const RX_UTC = /toISOString\(\)\s*\.\s*(?:slice|substring)\s*\(\s*0\s*,\s*10\s*\)/;
-const RX_ESCAPE_UTC = /fecha-utc-ok/;
-const RX_ESCAPE_EOL = /eol-ok:/;
-
-function archivosObjetivo() {
-  const salida = execFileSync('git', [
-    'ls-files', '--',
-    'scripts/*.js', 'scripts/**/*.js',
-    'hooks/*.js', 'hooks/**/*.js',
-    'bin/*.js',
-    'gateway/*.js', 'gateway/**/*.js',
-  ], { cwd: RAIZ, encoding: 'utf8' });
-  return salida.split(/\r?\n/).filter(f => f && !f.includes('vendor/'));
-}
-
-function auditarUtc(ruta, lineas, hallazgos) {
-  lineas.forEach((linea, i) => {
-    if (RX_UTC.test(linea) && !RX_ESCAPE_UTC.test(linea)) {
-      hallazgos.push(`[C1 fecha-UTC] ${ruta}:${i + 1} — toISOString().slice(0,10) fecha "mañana" desde UTC-6; usar toLocaleDateString('sv') o marcar \`// fecha-utc-ok\` si la semántica UTC es deliberada`);
-    }
-  });
-}
-
-function auditarEolCheck(ruta, contenido, hallazgos) {
-  // Aplica solo a GENERADORES con modo --check (escriben el artefacto y en
-  // check comparan lo regenerado contra disco). Un --check selector de
-  // sub-checks (verificar-docs) no compara texto por igualdad — no aplica.
-  if (!contenido.includes("'--check'") && !contenido.includes('"--check"')) return;
-  if (!/atomicWrite|writeFileSync/.test(contenido)) return;
-  if (!/readFileSync\([^)]*utf-?8/i.test(contenido)) return;
-  const normaliza = contenido.includes('\\r\\n') || contenido.includes('\\r?\\n');
-  const comparaEstructura = contenido.includes('JSON.parse');
-  const escape = RX_ESCAPE_EOL.test(contenido);
-  if (!normaliza && !comparaEstructura && !escape) {
-    hallazgos.push(`[C2 EOL] ${ruta} — modo --check que lee texto sin normalizar \\r\\n ni comparar estructuras: reventará con CRLF tras checkout/reset de git (caso publish v2.5.0). Normalizar EOL antes de comparar o marcar \`// eol-ok: <razón>\``);
-  }
-}
-
-function auditarBloqueoCiego(ruta, contenido, hallazgos) {
-  if (!ruta.startsWith('hooks/') || ruta.startsWith('hooks/lib/')) return;
-  const usaExit2 = /exit\(2\)|exitCode\s*=\s*2/.test(contenido);
-  const escribeStderr = contenido.includes('console.error') || contenido.includes('process.stderr.write');
-  if (usaExit2 && !escribeStderr) {
-    hallazgos.push(`[C3 bloqueo-ciego] ${ruta} — usa exit 2 sin escribir a stderr (console.error/process.stderr.write): el modelo recibe el bloqueo sin la razón`);
-  }
-}
-
-function main() {
-  const hallazgos = [];
-  const archivos = archivosObjetivo();
-  for (const ruta of archivos) {
-    let contenido;
-    try {
-      contenido = fs.readFileSync(path.join(RAIZ, ruta), 'utf8');
-    } catch { continue; }
-    const lineas = contenido.split(/\r?\n/);
-    auditarUtc(ruta, lineas, hallazgos);
-    auditarEolCheck(ruta, contenido, hallazgos);
-    auditarBloqueoCiego(ruta, contenido, hallazgos);
-  }
-
-  if (hallazgos.length === 0) {
-    console.log(`[clases-conocidas] OK — ${archivos.length} archivos, 0 reincidencias de clases documentadas (C1 UTC, C2 EOL, C3 bloqueo ciego)`);
-    return;
-  }
-  console.error(`[clases-conocidas] ${hallazgos.length} reincidencia(s) de clases de bug documentadas:`);
-  for (const h of hallazgos) console.error('  ' + h);
-  process.exitCode = 1;
-}
-
-module.exports = { auditarUtc, auditarEolCheck, auditarBloqueoCiego };
-if (require.main === module) main();
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * auditar-clases-conocidas.js — Gate de clases de bug ya documentadas.
+ *
+ * "El conocimiento documentado no previene — solo los gates previenen."
+ * Cada clase de este gate mordió al proyecto en producción pese a estar
+ * escrita como regla/aprendizaje. El gate la vuelve imposible de reintroducir:
+ *
+ *   C1 — Fecha UTC truncada: toISOString + slice(0,10) fecha artefactos
+ *        "mañana" desde México (23 instancias corregidas 2026-07-08/09).
+ *        Correcto: `toLocaleDateString('sv')`. Escape: `// fecha-utc-ok`.
+ *        (El patrón no se escribe literal aquí: el gate escanea este archivo
+ *        también — se auto-detectó en el publish v2.5.1.)
+ *   C2 — Comparación byte a byte en modos --check: comparar texto leído de
+ *        disco sin normalizar EOL revienta con CRLF tras checkout/reset de
+ *        git (tumbó el publish v2.5.0). Un script con modo --check que lee
+ *        texto debe normalizar `\r\n` o comparar estructuras (JSON.parse).
+ *        Escape: `// eol-ok: <razón>`.
+ *   C3 — Bloqueo ciego en hooks: exit(2) sin console.error deja al modelo
+ *        sin la razón del bloqueo (el canal de exit 2 es stderr).
+ *   C4 — Ancla .planning/instintos al CWD crudo en hooks: en monorepos con
+ *        sesión abierta en un subdirectorio fragmenta la memoria del proyecto
+ *        en árboles huérfanos (DT-HOOKS-RAIZ-GIT, reportes de campo oic+sigm
+ *        2026-07-10; flota completa migrada el mismo día). Correcto:
+ *        `raizProyecto(process.cwd())` de hooks/lib/raiz-proyecto.js.
+ *        Escape: `// raiz-ok: <razón>`. Solo hooks/** — los scripts CLI se
+ *        invocan desde la raíz del proyecto por contrato, y el instalador
+ *        ancla al cwd DELIBERADAMENTE (instala hacia ese proyecto; saltar a
+ *        un repo padre sería un bug).
+ *
+ * Alcance: archivos .js versionados en scripts/, hooks/, bin/, gateway/ y
+ * los scripts ejecutables de skills (habilidades/<skill>/scripts/) —
+ * parse-commits.js escapó al gate C1 hasta 2026-07-10 por no estar en el alcance.
+ * (tests/ excluido: los tests DEBEN poder citar el patrón para validarlo.)
+ * Exit: 0 limpio · 1 con hallazgos.
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const RAIZ = path.resolve(__dirname, '..');
+
+const RX_UTC = /toISOString\(\)\s*\.\s*(?:slice|substring)\s*\(\s*0\s*,\s*10\s*\)/;
+const RX_ESCAPE_UTC = /fecha-utc-ok/;
+const RX_ESCAPE_EOL = /eol-ok:/;
+// C4: join directo del cwd crudo con .planning o instintos. El patrón se
+// construye por concatenación para que el gate no se detecte a sí mismo.
+const RX_CWD_PLANNING = new RegExp(
+  'join\\(\\s*process\\.cwd\\(\\)\\s*,\\s*[\'"]' + '(?:\\.plan' + 'ning|instin' + 'tos)'
+);
+const RX_ESCAPE_RAIZ = /raiz-ok:/;
+
+function archivosObjetivo() {
+  const salida = execFileSync('git', [
+    'ls-files', '--',
+    'scripts/*.js', 'scripts/**/*.js',
+    'hooks/*.js', 'hooks/**/*.js',
+    'bin/*.js',
+    'gateway/*.js', 'gateway/**/*.js',
+    'habilidades/*/scripts/*.js', 'habilidades/*/scripts/**/*.js',
+  ], { cwd: RAIZ, encoding: 'utf8' });
+  return salida.split(/\r?\n/).filter(f => f && !f.includes('vendor/'));
+}
+
+function auditarUtc(ruta, lineas, hallazgos) {
+  lineas.forEach((linea, i) => {
+    if (RX_UTC.test(linea) && !RX_ESCAPE_UTC.test(linea)) {
+      hallazgos.push(`[C1 fecha-UTC] ${ruta}:${i + 1} — toISOString().slice(0,10) fecha "mañana" desde UTC-6; usar toLocaleDateString('sv') o marcar \`// fecha-utc-ok\` si la semántica UTC es deliberada`);
+    }
+  });
+}
+
+function auditarEolCheck(ruta, contenido, hallazgos) {
+  // Aplica solo a GENERADORES con modo --check (escriben el artefacto y en
+  // check comparan lo regenerado contra disco). Un --check selector de
+  // sub-checks (verificar-docs) no compara texto por igualdad — no aplica.
+  if (!contenido.includes("'--check'") && !contenido.includes('"--check"')) return;
+  if (!/atomicWrite|writeFileSync/.test(contenido)) return;
+  if (!/readFileSync\([^)]*utf-?8/i.test(contenido)) return;
+  const normaliza = contenido.includes('\\r\\n') || contenido.includes('\\r?\\n');
+  const comparaEstructura = contenido.includes('JSON.parse');
+  const escape = RX_ESCAPE_EOL.test(contenido);
+  if (!normaliza && !comparaEstructura && !escape) {
+    hallazgos.push(`[C2 EOL] ${ruta} — modo --check que lee texto sin normalizar \\r\\n ni comparar estructuras: reventará con CRLF tras checkout/reset de git (caso publish v2.5.0). Normalizar EOL antes de comparar o marcar \`// eol-ok: <razón>\``);
+  }
+}
+
+function auditarBloqueoCiego(ruta, contenido, hallazgos) {
+  if (!ruta.startsWith('hooks/') || ruta.startsWith('hooks/lib/')) return;
+  const usaExit2 = /exit\(2\)|exitCode\s*=\s*2/.test(contenido);
+  const escribeStderr = contenido.includes('console.error') || contenido.includes('process.stderr.write');
+  if (usaExit2 && !escribeStderr) {
+    hallazgos.push(`[C3 bloqueo-ciego] ${ruta} — usa exit 2 sin escribir a stderr (console.error/process.stderr.write): el modelo recibe el bloqueo sin la razón`);
+  }
+}
+
+function auditarCwdPlanning(ruta, lineas, hallazgos) {
+  if (!ruta.startsWith('hooks/')) return;
+  lineas.forEach((linea, i) => {
+    if (RX_CWD_PLANNING.test(linea) && !RX_ESCAPE_RAIZ.test(linea)) {
+      hallazgos.push(`[C4 raiz-proyecto] ${ruta}:${i + 1} — ancla .planning/instintos a process.cwd() crudo: fragmenta la memoria en monorepos (DT-HOOKS-RAIZ-GIT); usar raizProyecto(process.cwd()) de hooks/lib/raiz-proyecto.js o marcar \`// raiz-ok: <razón>\``);
+    }
+  });
+}
+
+function main() {
+  const hallazgos = [];
+  const archivos = archivosObjetivo();
+  for (const ruta of archivos) {
+    let contenido;
+    try {
+      contenido = fs.readFileSync(path.join(RAIZ, ruta), 'utf8');
+    } catch { continue; }
+    const lineas = contenido.split(/\r?\n/);
+    auditarUtc(ruta, lineas, hallazgos);
+    auditarEolCheck(ruta, contenido, hallazgos);
+    auditarBloqueoCiego(ruta, contenido, hallazgos);
+    auditarCwdPlanning(ruta, lineas, hallazgos);
+  }
+
+  if (hallazgos.length === 0) {
+    console.log(`[clases-conocidas] OK — ${archivos.length} archivos, 0 reincidencias de clases documentadas (C1 UTC, C2 EOL, C3 bloqueo ciego, C4 ancla cwd)`);
+    return;
+  }
+  console.error(`[clases-conocidas] ${hallazgos.length} reincidencia(s) de clases de bug documentadas:`);
+  for (const h of hallazgos) console.error('  ' + h);
+  process.exitCode = 1;
+}
+
+module.exports = { auditarUtc, auditarEolCheck, auditarBloqueoCiego, auditarCwdPlanning };
+if (require.main === module) main();

package/scripts/benchmark-memoria.js

@@ -164,4 +164,5 @@ if (require.main === module) {
 
 module.exports = {
   parseArgs,
+  main,
 };

package/scripts/bootstrap-instintos.js

@@ -5,9 +5,23 @@
  * bootstrap-instintos.js
  *
  * Pobla instintos/proyecto.yaml inicial a partir de las entradas de
- * .planning/APRENDIZAJES.md. Cada entrada `### [YYYY-MM-DD] título` se
- * convierte en un instinto con confidence inicial según la sección que lo
- * contiene:
+ * .planning/APRENDIZAJES.md. Reconoce dos formatos de entrada:
+ *
+ *   ### [YYYY-MM-DD] Título                              (formato histórico)
+ *   ### L-NNN: Título (RATING, Tipo X → destino)          (formato /swl:aprender actual)
+ *
+ * Para el formato L-NNN, la fecha se toma de una línea `**valid_at**: YYYY-MM-DD`
+ * dentro del cuerpo de la entrada (o de la fecha del encabezado `## [YYYY-MM-DD] ...`
+ * que la contiene, si la trae); si ninguna aparece, se usa la fecha de generación.
+ * El rating (HIGH/MEDIUM/LOW) y el Tipo (A/B/C/D) del título, cuando existen,
+ * tienen prioridad sobre la confidence/tags inferidas de la sección — son más
+ * específicos a la entrada individual que el título de la sección que la contiene.
+ *
+ * Gap conocido, no cubierto: entradas registradas como ítem de lista numerada
+ * dentro de un bloque de sesión (`4. **[L-285]** ...`) sin encabezado `###`
+ * propio — requieren un parser de listas dedicado, fuera del alcance de este fix.
+ *
+ * Cada instinto recibe confidence inicial según la sección que lo contiene:
  *
  *   ## Anti-patrones detectados  → confidence 0.7, tags: [anti-patron]
  *   ## Patrones exitosos         → confidence 0.6, tags: [patron]
@@ -81,21 +95,54 @@ function detectarConfidence(seccion) {
   return { confidence: 0.5, tags: [] };
 }
 
+/**
+ * Detecta un rating (HIGH/MEDIUM/LOW) en el título de una entrada `### L-NNN: ...`.
+ * Más específico que la confidence por sección — prioridad cuando existe.
+ * @param {string} titulo
+ * @returns {number|null}
+ */
+function detectarConfidenceDeTitulo(titulo) {
+  const t = titulo || '';
+  if (/\bHIGH\b/i.test(t)) return 0.8;
+  if (/\bMEDIUM\b/i.test(t)) return 0.6;
+  if (/\bLOW\b/i.test(t)) return 0.4;
+  return null;
+}
+
+/**
+ * Detecta el Tipo (A/B/C/D, taxonomía de /swl:aprender § Paso 4) en el título
+ * de una entrada `### L-NNN: ...` y lo mapea a un tag. Más específico que los
+ * tags por sección — prioridad cuando existe al menos un match.
+ * @param {string} titulo
+ * @returns {string[]}
+ */
+function detectarTagsDeTitulo(titulo) {
+  const t = titulo || '';
+  const tags = [];
+  if (/\bTipo\s*A\b/.test(t)) tags.push('regla-proyecto');
+  if (/\bTipo\s*B\b/.test(t)) tags.push('anti-patron');
+  if (/\bTipo\s*C\b/.test(t)) tags.push('nueva-habilidad');
+  if (/\bTipo\s*D\b/.test(t)) tags.push('metodologia');
+  return tags;
+}
+
 // ---------------------------------------------------------------------------
 // Parser de APRENDIZAJES.md
 // ---------------------------------------------------------------------------
 
 /**
  * Parsea el markdown en objetos de instinto.
- * Formato esperado por entrada:
+ * Formatos reconocidos por entrada:
  *   ## Sección
- *   ### [YYYY-MM-DD] Título
- *   Párrafo de descripción (puede ser multi-línea hasta el siguiente ###)
+ *   ### [YYYY-MM-DD] Título                      — histórico
+ *   ### L-NNN: Título (RATING, Tipo X → destino) — actual (/swl:aprender)
+ * Párrafo de descripción (puede ser multi-línea hasta el siguiente ### o ##).
  */
 function parsearAprendizajes(texto) {
   const lineas = texto.split(/\r?\n/);
   const entradas = [];
   let seccionActual = '';
+  let fechaSeccionActual = null;
   let actual = null;
 
   const flushActual = () => {
@@ -110,15 +157,17 @@ function parsearAprendizajes(texto) {
   for (const raw of lineas) {
     const linea = raw.replace(/\s+$/, '');
 
-    // Sección (##)
+    // Sección (## sin ser ###) — puede traer su propia fecha "## [YYYY-MM-DD] ..."
     const mSec = linea.match(/^##\s+(.+)$/);
     if (mSec && !linea.startsWith('###')) {
       flushActual();
       seccionActual = mSec[1].trim();
+      const mFechaSec = seccionActual.match(/^\[(\d{4}-\d{2}-\d{2})\]/);
+      fechaSeccionActual = mFechaSec ? mFechaSec[1] : null;
       continue;
     }
 
-    // Entrada (### [YYYY-MM-DD] Título)
+    // Entrada formato histórico: ### [YYYY-MM-DD] Título
     const mEntry = linea.match(/^###\s+\[(\d{4}-\d{2}-\d{2})\]\s+(.+)$/);
     if (mEntry) {
       flushActual();
@@ -131,9 +180,26 @@ function parsearAprendizajes(texto) {
       continue;
     }
 
-    // Acumular descripción si tenemos entrada activa
+    // Entrada formato actual: ### L-NNN: Título (RATING, Tipo X → destino)
+    const mEntryL = linea.match(/^###\s+L-\d+:\s*(.+)$/);
+    if (mEntryL) {
+      flushActual();
+      actual = {
+        fecha: fechaSeccionActual, // se corrige abajo con **valid_at** si aparece
+        titulo: mEntryL[1].trim(),
+        seccion: seccionActual,
+        _descParts: [],
+      };
+      continue;
+    }
+
+    // Acumular descripción / capturar valid_at si tenemos entrada activa
     if (actual) {
       const t = linea.trim();
+      if (t) {
+        const mValidAt = t.match(/\*\*valid_at\*\*:\s*(\d{4}-\d{2}-\d{2})/);
+        if (mValidAt) actual.fecha = mValidAt[1];
+      }
       if (t && !t.startsWith('#') && !t.startsWith('---')) {
         actual._descParts.push(t);
       }
@@ -161,9 +227,14 @@ function truncate(s, n) {
 function generarInstintos(entradas) {
   const hoy = new Date().toLocaleDateString('sv');
   return entradas.map((e, idx) => {
-    const { confidence, tags } = detectarConfidence(e.seccion);
+    const base = detectarConfidence(e.seccion);
+    const confidenceTitulo = detectarConfidenceDeTitulo(e.titulo);
+    const tagsTitulo = detectarTagsDeTitulo(e.titulo);
+    const confidence = confidenceTitulo != null ? confidenceTitulo : base.confidence;
+    const tags = tagsTitulo.length > 0 ? tagsTitulo : base.tags;
     const pattern = truncate(e.titulo, 200);
     const description = truncate(e.description || e.titulo, 500);
+    const fecha = e.fecha || hoy;
     return {
       id: `inst-${String(idx + 1).padStart(3, '0')}`,
       pattern,
@@ -172,8 +243,8 @@ function generarInstintos(entradas) {
       scope: 'project',
       source: 'APRENDIZAJES.md',
       evidence_count: 1,
-      last_validated: e.fecha,
-      last_validated_at: e.fecha,
+      last_validated: fecha,
+      last_validated_at: fecha,
       contradictions: 0,
       status: 'active',
       tags,
@@ -242,7 +313,7 @@ function main() {
   const entradas = parsearAprendizajes(texto);
 
   if (entradas.length === 0) {
-    console.log('No se detectaron entradas en APRENDIZAJES.md (patrón "### [YYYY-MM-DD] Título").');
+    console.log('No se detectaron entradas en APRENDIZAJES.md (patrones "### [YYYY-MM-DD] Título" o "### L-NNN: Título").');
     return;
   }
 
@@ -284,4 +355,4 @@ function main() {
 
 if (require.main === module) main();
 
-module.exports = { parsearAprendizajes, generarInstintos, detectarConfidence, inferirTipoMemoria, main };
+module.exports = { parsearAprendizajes, generarInstintos, detectarConfidence, detectarConfidenceDeTitulo, detectarTagsDeTitulo, inferirTipoMemoria, main };