@saulwade/swl-ses 2.4.3 → 2.5.1

package/scripts/generar-inventario.js

@@ -44,18 +44,47 @@ function leerFrontmatter(ruta) {
     const match = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (!match) return {};
     const fm = {};
-    for (const linea of match[1].split(/\r?\n/)) {
+    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, la consume el bloque de abajo
       const idx = linea.indexOf(':');
-      if (idx > 0) {
-        const key = linea.slice(0, idx).trim();
-        const val = linea.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
-        fm[key] = val;
+      if (idx <= 0) continue;
+      const key = linea.slice(0, idx).trim();
+      let val = linea.slice(idx + 1).trim().replace(/^["']|["']$/g, '');
+      // Escalares plegados YAML (`description: >` / `|`): juntar las líneas indentadas siguientes.
+      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 {}; }
 }
 
+/** Recorta una descripción a n caracteres en límite de palabra, colapsando whitespace. */
+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) + '…';
+}
+
+function contarArchivosRec(dir, ext) {
+  let total = 0;
+  try {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.isDirectory()) total += contarArchivosRec(path.join(dir, e.name), ext);
+      else if (e.name.endsWith(ext)) total++;
+    }
+  } catch { /* dir inexistente → 0 */ }
+  return total;
+}
+
 function contarArchivos(dir, ext) {
   try {
     return fs.readdirSync(dir).filter(f => f.endsWith(ext)).length;
@@ -94,6 +123,12 @@ function recolectarAgentes() {
       version: fm.version || '?',
       model: fm.model || '?',
       nivelRiesgo: fm.nivelRiesgo || '?',
+      description: fm.description || '',
+      skillsInvocables: (fm.skillsInvocables || '')
+        .replace(/^\[|\]$/g, '')
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean),
     };
   });
 }
@@ -105,7 +140,24 @@ function recolectarSkills() {
   );
   return dirs.map(d => {
     const fm = leerFrontmatter(path.join(dir, d, 'SKILL.md'));
-    return { dir: d, name: fm.name || d, description: (fm.description || '').substring(0, 80) };
+    return {
+      dir: d,
+      name: fm.name || d,
+      version: fm.version || '—',
+      description: fm.description || '',
+    };
+  });
+}
+
+function recolectarComandos() {
+  const dir = path.join(RAIZ, 'comandos', 'swl');
+  return fs.readdirSync(dir).filter(f => f.endsWith('.md')).map(f => {
+    const fm = leerFrontmatter(path.join(dir, f));
+    return {
+      archivo: f,
+      name: fm.name || `swl:${f.replace('.md', '')}`,
+      description: fm.description || '',
+    };
   });
 }
 
@@ -139,19 +191,38 @@ function generarInventario() {
   const skills   = recolectarSkills();
   const hooks    = recolectarHooks();
   const libs     = recolectarLibs();
-  const comandos = contarArchivos(path.join(RAIZ, 'comandos', 'swl'), '.md');
+  const comandos = recolectarComandos();
   const reglasBase = contarArchivos(path.join(RAIZ, 'reglas'), '.md');
   const reglasLang = fs.readdirSync(path.join(RAIZ, 'reglas', 'lenguajes'))
     .filter(d => fs.statSync(path.join(RAIZ, 'reglas', 'lenguajes', d)).isDirectory())
     .reduce((acc, d) => acc + contarArchivos(path.join(RAIZ, 'reglas', 'lenguajes', d), '.md'), 0);
-  const schemas  = contarArchivos(path.join(RAIZ, 'schemas'), '.json');
-  const scripts  = contarArchivos(path.join(RAIZ, 'scripts', 'lib'), '.js') + contarArchivos(path.join(RAIZ, 'scripts', 'lib'), '.py');
+  const schemasList = fs.readdirSync(path.join(RAIZ, 'schemas')).filter(f => f.endsWith('.json')).sort();
+  const scriptsLibList = fs.readdirSync(path.join(RAIZ, 'scripts', 'lib'))
+    .filter(f => f.endsWith('.js') || f.endsWith('.py')).sort();
+  // Tipos antes omitidos del inventario (auditoría 2026-07-08)
+  const fragmentos = fs.readdirSync(path.join(RAIZ, 'agentes')).filter(f => f.startsWith('_') && f.endsWith('.md'));
+  const gatewayJs  = contarArchivosRec(path.join(RAIZ, 'gateway'), '.js');
+  const manifiestosJson = contarArchivos(path.join(RAIZ, 'manifiestos'), '.json');
+  const contextos  = contarArchivos(path.join(RAIZ, 'contextos'), '.md');
+  const plantillasTotal = contarArchivosRec(path.join(RAIZ, 'plantillas'), '.md') + contarArchivosRec(path.join(RAIZ, 'plantillas'), '.yml');
+  const scriptsTop = contarArchivos(path.join(RAIZ, 'scripts'), '.js');
+
+  // Mapa skill → agentes que la declaran en skillsInvocables
+  const skillAAgentes = new Map();
+  for (const a of agentes) {
+    for (const s of a.skillsInvocables) {
+      if (!skillAAgentes.has(s)) skillAAgentes.set(s, []);
+      skillAAgentes.get(s).push(a.name);
+    }
+  }
 
   const lines = [];
   lines.push(`# INVENTARIO.md — Referencia completa de componentes SWL v${pkg.version}`);
   lines.push('');
   lines.push('> Archivo generado automáticamente por `node scripts/generar-inventario.js`.');
   lines.push('> NO editar manualmente — se regenera con cada release.');
+  lines.push('> Índice de descubrimiento: cada catálogo incluye la descripción del');
+  lines.push('> componente para decidir qué usar sin abrir su archivo.');
   lines.push('');
   lines.push('## Resumen');
   lines.push('');
@@ -159,13 +230,19 @@ function generarInventario() {
   lines.push('|-----------|----------|');
   lines.push(`| Agentes SWL | ${agentes.length} |`);
   lines.push(`| Habilidades | ${skills.length} |`);
-  lines.push(`| Comandos | ${comandos} |`);
+  lines.push(`| Comandos | ${comandos.length} |`);
   lines.push(`| Reglas base | ${reglasBase} |`);
   lines.push(`| Reglas por lenguaje | ${reglasLang} |`);
   lines.push(`| Hooks | ${hooks.length} |`);
   lines.push(`| Librerías de hooks | ${libs.length} |`);
-  lines.push(`| Schemas | ${schemas} |`);
-  lines.push(`| Scripts lib | ${scripts} |`);
+  lines.push(`| Schemas | ${schemasList.length} |`);
+  lines.push(`| Scripts lib | ${scriptsLibList.length} |`);
+  lines.push(`| Scripts top-level | ${scriptsTop} |`);
+  lines.push(`| Fragmentos de agentes | ${fragmentos.length} |`);
+  lines.push(`| Gateway (archivos .js) | ${gatewayJs} |`);
+  lines.push(`| Manifiestos | ${manifiestosJson} |`);
+  lines.push(`| Contextos | ${contextos} |`);
+  lines.push(`| Plantillas | ${plantillasTotal} |`);
   lines.push('');
 
   // Equipos
@@ -174,22 +251,47 @@ function generarInventario() {
   lines.push('| Equipo | Líder | Miembros paralelos | Cuándo |');
   lines.push('|--------|-------|-------------------|--------|');
   lines.push('| Discovery | investigador-swl | investigador-ux-swl, producto-prd-swl | Proyecto nuevo |');
-  lines.push('| Arquitectura | arquitecto-swl | rendimiento-swl, revisor-seguridad-swl | Decisión de diseño |');
+  lines.push('| Arquitectura | arquitecto-swl | rendimiento-swl, revisor-seguridad-swl, abogado-diablo-swl | Decisión de diseño |');
   lines.push('| Frontend | frontend-swl | frontend-react-swl, frontend-css-swl, frontend-tailwind-swl | Feature UI compleja |');
   lines.push('| Backend | backend-python-swl | backend-api-swl, backend-workers-swl | Feature backend compleja |');
   lines.push('| Mobile | mobile-cross-swl | mobile-android-swl, mobile-ios-swl, mobile-testing-swl | Feature mobile |');
   lines.push('| Calidad | tdd-qa-swl | revisor-codigo-swl, revisor-seguridad-swl, accesibilidad-wcag-swl | Pre-release |');
-  lines.push('| Operaciones | devops-ci-swl | cloud-infra-swl, observabilidad-swl, sre-swl | Deploy, infra, confiabilidad |');
+  lines.push('| Auditoría profunda | nemesis-auditor-swl | feynman-auditor-swl, state-inconsistency-auditor-swl | Lógica compleja con estado acoplado |');
+  lines.push('| Operaciones | devops-ci-swl | cloud-infra-swl, observabilidad-swl, sre-swl, gh-fix-ci-swl | Deploy, infra, confiabilidad, fallas CI |');
   lines.push('| Cierre | consolidador-swl | documentador-swl, release-manager-swl, notificador-swl | Fase completada |');
   lines.push('');
 
   // Agentes
   lines.push(`## Agentes SWL — Registro completo (${agentes.length})`);
   lines.push('');
-  lines.push('| Agente | Versión | Modelo | Riesgo |');
-  lines.push('|--------|---------|--------|--------|');
+  lines.push('| Agente | Versión | Modelo | Riesgo | Qué hace / cuándo invocarlo |');
+  lines.push('|--------|---------|--------|--------|------------------------------|');
   for (const a of agentes.sort((x, y) => x.name.localeCompare(y.name))) {
-    lines.push(`| ${a.name} | ${a.version} | ${a.model} | ${a.nivelRiesgo} |`);
+    lines.push(`| ${a.name} | ${a.version} | ${a.model} | ${a.nivelRiesgo} | ${resumir(a.description, 160)} |`);
+  }
+  lines.push('');
+
+  // Habilidades — catálogo consultable (antes solo se contaban)
+  lines.push(`## Habilidades — Catálogo completo (${skills.length})`);
+  lines.push('');
+  lines.push('La columna "Agentes" lista quién la declara en `skillsInvocables`;');
+  lines.push('"—" significa que se invoca por descripción o desde comandos.');
+  lines.push('');
+  lines.push('| Skill | Versión | Descripción | Agentes |');
+  lines.push('|-------|---------|-------------|---------|');
+  for (const s of [...skills].sort((x, y) => x.name.localeCompare(y.name))) {
+    const invocadores = (skillAAgentes.get(s.name) || []).join(', ') || '—';
+    lines.push(`| ${s.name} | ${s.version} | ${resumir(s.description, 140)} | ${invocadores} |`);
+  }
+  lines.push('');
+
+  // Comandos — catálogo consultable (antes solo se contaban)
+  lines.push(`## Comandos /swl:* — Catálogo completo (${comandos.length})`);
+  lines.push('');
+  lines.push('| Comando | Descripción |');
+  lines.push('|---------|-------------|');
+  for (const c of [...comandos].sort((x, y) => x.name.localeCompare(y.name))) {
+    lines.push(`| /${c.name} | ${resumir(c.description, 180)} |`);
   }
   lines.push('');
 
@@ -243,6 +345,26 @@ function generarInventario() {
   }
   lines.push('');
 
+  // Schemas — superficie de contrato del sistema
+  lines.push(`## Schemas (${schemasList.length})`);
+  lines.push('');
+  lines.push('| Schema | Archivo |');
+  lines.push('|--------|---------|');
+  for (const s of schemasList) {
+    lines.push(`| ${s.replace('.schema.json', '').replace('.json', '')} | \`schemas/${s}\` |`);
+  }
+  lines.push('');
+
+  // Scripts lib — enumerados (antes solo se contaban)
+  lines.push(`## Librerías de scripts (scripts/lib/) — ${scriptsLibList.length}`);
+  lines.push('');
+  lines.push('| Librería | Archivo |');
+  lines.push('|----------|---------|');
+  for (const s of scriptsLibList) {
+    lines.push(`| ${s.replace(/\.(js|py)$/, '')} | \`scripts/lib/${s}\` |`);
+  }
+  lines.push('');
+
   return lines.join('\n');
 }
 
@@ -353,7 +475,9 @@ function generarSalud() {
   const lines = [];
   lines.push('# Reporte de Salud del Sistema SWL');
   lines.push('');
-  lines.push(`**Generado**: ${new Date().toISOString().slice(0, 10)}`);
+  // Fecha LOCAL (no UTC): en horario de México la tarde ya es "mañana" en UTC
+  // y el reporte quedaba con fecha futura. 'sv' formatea como YYYY-MM-DD.
+  lines.push(`**Generado**: ${new Date().toLocaleDateString('sv')}`);
   lines.push(`**Versión del sistema**: ${pkg.version}`);
   lines.push('');
   lines.push('> Archivo generado automáticamente por `node scripts/generar-inventario.js --salud`.');
@@ -463,11 +587,12 @@ function generarLlmsTxt() {
   L.push('');
   L.push('## Componentes');
   L.push('');
-  L.push(`- ${agentes} agentes especializados en \`agentes/\` (orquestación, implementación por stack, revisión, calidad, diseño)`);
-  L.push(`- ${skills} habilidades cargables bajo demanda en \`habilidades/\` (conocimiento operacional con divulgación progresiva)`);
-  L.push(`- ${comandos} comandos \`/swl:*\` en \`comandos/swl/\` (ciclo GSD, calidad, release, diagnóstico)`);
-  L.push(`- ${reglasBase} reglas base + ${reglasLang} reglas por lenguaje en \`reglas/\` (políticas obligatorias por matcher)`);
-  L.push(`- ${hooks} hooks en \`hooks/\` (telemetría, validación, seguridad; zero-deps, escrituras atómicas)`);
+  // llmstxt.org: cada entrada de sección debe ser un link markdown navegable.
+  L.push(`- [${agentes} agentes especializados](AGENTS.md): orquestación, implementación por stack, revisión, calidad, diseño — fuente en \`agentes/\``);
+  L.push(`- [${skills} habilidades cargables bajo demanda](INVENTARIO.md): conocimiento operacional con divulgación progresiva — fuente en \`habilidades/\``);
+  L.push(`- [${comandos} comandos /swl:*](COMANDOS.md): ciclo GSD, calidad, release, diagnóstico — fuente en \`comandos/swl/\``);
+  L.push(`- [${reglasBase} reglas base + ${reglasLang} por lenguaje](INVENTARIO.md): políticas obligatorias por matcher — fuente en \`reglas/\``);
+  L.push(`- [${hooks} hooks](INVENTARIO.md): telemetría, validación, seguridad; zero-deps, escrituras atómicas — fuente en \`hooks/\``);
   L.push('');
   L.push('## Opcional');
   L.push('');
@@ -479,6 +604,83 @@ function generarLlmsTxt() {
   return L.join('\n');
 }
 
+// ── MAPEO_SKILLS_AGENTES.md ───────────────────────────────────────────
+// Antes se mantenía a mano y era el peor infractor de drift del sistema
+// (auditoría 2026-07-08: mencionaba skills retiradas, mapeos falsos en 3/5
+// agentes muestreados y totales stale, pese a ser insumo del gate de release).
+// Se deriva por completo de los skillsInvocables del frontmatter de agentes.
+function generarMapeo() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(RAIZ, 'package.json'), 'utf8'));
+  const agentes = recolectarAgentes();
+  const skills  = recolectarSkills();
+  const nombresSkill = new Set(skills.map(s => s.name));
+
+  const L = [];
+  L.push(`# MAPEO_SKILLS_AGENTES.md — v${pkg.version}`);
+  L.push('');
+  L.push('> Archivo generado automáticamente por `node scripts/generar-inventario.js`.');
+  L.push('> NO editar manualmente — se deriva de los `skillsInvocables` declarados');
+  L.push('> en el frontmatter de `agentes/*.md`. El mapa inverso (skill → agentes)');
+  L.push('> vive en `INVENTARIO.md § Habilidades — Catálogo completo`.');
+  L.push('');
+  L.push(`Total de agentes: ${agentes.length}`);
+  L.push(`Total de skills: ${skills.length}`);
+  L.push('');
+  L.push('## Agente → skills que declara invocables');
+  L.push('');
+  L.push('| Agente | # | skillsInvocables |');
+  L.push('|--------|---|------------------|');
+  // Skills de la colección oficial Anthropic (opt-in, instaladas en
+  // .claude/skills/ vía `swl-ses skills add anthropics/skills`) — referencias
+  // legítimas aunque no vivan en habilidades/. Ver MANUAL_USO § Anthropic Skills.
+  const SKILLS_ANTHROPIC = new Set([
+    'pdf', 'docx', 'xlsx', 'pptx', 'frontend-design', 'web-artifacts-builder',
+    'canvas-design', 'algorithmic-art', 'theme-factory', 'slack-gif-creator',
+    'claude-api', 'mcp-builder', 'webapp-testing', 'doc-coauthoring',
+    'internal-comms', 'brand-guidelines', 'skill-creator',
+  ]);
+  const externas = new Set();
+  const inexistentes = [];
+  for (const a of [...agentes].sort((x, y) => x.name.localeCompare(y.name))) {
+    for (const s of a.skillsInvocables) {
+      if (s === 'todos') continue; // centinela: el agente puede invocar cualquier skill
+      if (nombresSkill.has(s)) continue;
+      if (SKILLS_ANTHROPIC.has(s)) externas.add(s);
+      else inexistentes.push(`${a.name} → ${s}`);
+    }
+    const etiqueta = a.skillsInvocables.includes('todos')
+      ? 'todos (acceso a cualquier skill)'
+      : (a.skillsInvocables.join(', ') || '—');
+    L.push(`| ${a.name} | ${a.skillsInvocables.includes('todos') ? skills.length : a.skillsInvocables.length} | ${etiqueta} |`);
+  }
+  L.push('');
+  if (externas.size > 0) {
+    L.push(`## Skills externas referenciadas (colección Anthropic, opt-in) — ${externas.size}`);
+    L.push('');
+    L.push('No viven en `habilidades/`; se instalan con `swl-ses skills add anthropics/skills`.');
+    L.push('Si la colección no está instalada, el agente degrada sin fallar.');
+    L.push('');
+    L.push([...externas].sort().map(s => `\`${s}\``).join(', '));
+    L.push('');
+  }
+  if (inexistentes.length > 0) {
+    L.push('## ⚠ Referencias a skills inexistentes (corregir en el frontmatter del agente)');
+    L.push('');
+    for (const i of inexistentes) L.push(`- ${i}`);
+    L.push('');
+  }
+  const declaradas = new Set(agentes.flatMap(a => a.skillsInvocables));
+  const sinAgente = skills.filter(s => !declaradas.has(s.name));
+  L.push(`## Skills sin agente declarado (${sinAgente.length})`);
+  L.push('');
+  L.push('No es error: se invocan por descripción (matching nativo del runtime),');
+  L.push('desde comandos `/swl:*`, o son infraestructura del sistema.');
+  L.push('');
+  L.push(sinAgente.map(s => `\`${s.name}\``).join(', '));
+  L.push('');
+  return L.join('\n');
+}
+
 // ── Ejecutar ──────────────────────────────────────────────────────────
 
 if (AMBOS || SOLO_INV) {
@@ -513,3 +715,14 @@ if (AMBOS || SOLO_LLMS) {
     console.log('llms.txt generado correctamente.');
   }
 }
+
+if (AMBOS || args.has('--mapeo')) {
+  const mapeo = generarMapeo();
+  if (DRY) {
+    console.log('\n=== MAPEO_SKILLS_AGENTES.md (dry-run) ===\n');
+    console.log(mapeo.substring(0, 1500) + '\n...(truncado)');
+  } else {
+    atomicWriteSync(path.join(RAIZ, '.planning', 'MAPEO_SKILLS_AGENTES.md'), mapeo, 'utf8');
+    console.log('MAPEO_SKILLS_AGENTES.md generado correctamente.');
+  }
+}

package/scripts/generar-matriz-lenguajes.js

@@ -207,7 +207,7 @@ function renderResumen() {
 // ---------------------------------------------------------------------------
 
 function main() {
-  const fecha = new Date().toISOString().slice(0, 10);
+  const fecha = new Date().toLocaleDateString('sv'); // local, no UTC (regla CLAUDE.md Code style)
   const contenido = `# Matriz de cobertura SWL × lenguaje
 
 > **Generado automáticamente** por \`scripts/generar-matriz-lenguajes.js\`.

package/scripts/instalador.js

@@ -857,7 +857,20 @@ async function install(opciones) {
             accion: resMerge.accion,
           });
         } else {
-          // Comportamiento clásico: sobrescribir archivo completo (codex/gemini/copilot/opencode)
+          // Comportamiento clásico: sobrescribir archivo completo (codex/gemini/copilot/opencode).
+          // GUARD anti-clobber (bug 2026-07-08): si el destino YA existe y NO fue
+          // generado por SWL (sin el marcador "Generado por swl-ses"), es contenido
+          // del usuario o documentación canónica del proyecto — sobreescribirlo es
+          // pérdida de datos (caso real: install --target opencode pisó el AGENTS.md
+          // canónico del repo madre, 420 líneas). Preservar y avisar; el usuario
+          // puede borrar el archivo manualmente si quiere el generado.
+          const yaExiste = fs.existsSync(rutaInstrucciones);
+          const esGeneradoSwl = yaExiste
+            ? fs.readFileSync(rutaInstrucciones, 'utf-8').includes('Generado por swl-ses')
+            : false;
+          if (yaExiste && !esGeneradoSwl) {
+            console.log(`  = ${instrucciones.rutaRelativa} NO modificado — existe contenido propio del proyecto (sin marcador "Generado por swl-ses"). Borra el archivo y reinstala si quieres el generado.`);
+          } else {
           if (!fs.existsSync(dirInstrucciones)) {
             fs.mkdirSync(dirInstrucciones, { recursive: true });
           }
@@ -868,6 +881,7 @@ async function install(opciones) {
             destino: rutaInstrucciones,
             tipo: 'instrucciones',
           });
+          } // cierre del guard anti-clobber
         }
       }
     } catch (err) {

package/scripts/lib/configurar-ci.js

@@ -44,9 +44,10 @@ const WORKFLOWS_DIR = '.github/workflows';
 
 /** Workflows que este módulo gestiona (identificados por nombre de archivo). */
 const WORKFLOWS_SWL = {
-  security: 'swl-security.yml',
-  ci:       'swl-ci.yml',
-  release:  'release-please.yml',
+  security:  'swl-security.yml',
+  ci:        'swl-ci.yml',
+  release:   'release-please.yml',
+  devsecops: 'swl-devsecops.yml',
 };
 
 /** Secrets que requiere cada workflow. */
@@ -54,6 +55,9 @@ const SECRETS_REQUERIDOS = {
   'swl-security.yml': ['CLAUDE_API_KEY'],
   'swl-ci.yml':       [],
   'release-please.yml': [],
+  // GITLEAKS_LICENSE solo es necesaria en repos de organización (gratuita
+  // para individuos) — no se lista como requerida para no bloquear el caso común.
+  'swl-devsecops.yml': [],
 };
 
 // ---------------------------------------------------------------------------
@@ -121,6 +125,7 @@ function listarPlantillas() {
  * @param {boolean} [opciones.withSecurity=true]         Instalar swl-security.yml
  * @param {boolean} [opciones.withCi=true]               Instalar swl-ci.yml
  * @param {boolean} [opciones.withReleasePlease=false]   Instalar release-please.yml
+ * @param {boolean} [opciones.withDevsecops=false]       Instalar swl-devsecops.yml (gitleaks + audit de deps)
  * @param {boolean} [opciones.dryRun=false]              Solo mostrar cambios, no copiar
  * @param {boolean} [opciones.force=false]               Sobreescribir archivos existentes
  * @param {string}  [opciones._proyectoPathOverride]     Path del proyecto (tests)
@@ -130,6 +135,7 @@ function init({
   withSecurity = true,
   withCi       = true,
   withReleasePlease = false,
+  withDevsecops = false,
   dryRun       = false,
   force        = false,
   _proyectoPathOverride,
@@ -141,6 +147,7 @@ function init({
   if (withSecurity)     seleccionados.push(WORKFLOWS_SWL.security);
   if (withCi)           seleccionados.push(WORKFLOWS_SWL.ci);
   if (withReleasePlease) seleccionados.push(WORKFLOWS_SWL.release);
+  if (withDevsecops)    seleccionados.push(WORKFLOWS_SWL.devsecops);
 
   const copiados   = [];
   const existentes = [];

package/scripts/lib/diary-entry.js

@@ -38,7 +38,9 @@ function nowIso() {
 }
 
 function todayDate() {
-  return nowIso().slice(0, 10);
+  // Fecha LOCAL, no UTC: desde México la tarde ya es "mañana" en UTC y el id
+  // del diary quedaba fechado en el futuro (regla CLAUDE.md § Code style).
+  return new Date().toLocaleDateString('sv');
 }
 
 function shortHash(input) {

package/scripts/lib/drift-detector.js

@@ -367,7 +367,7 @@ function generarLineaTemporal({
   for (let i = dias - 1; i >= 0; i--) {
     const inicioDia = ahora - (i + 1) * 24 * 3600 * 1000;
     const finDia    = ahora - i * 24 * 3600 * 1000;
-    const fecha     = new Date(inicioDia).toISOString().slice(0, 10);
+    const fecha     = new Date(inicioDia).toLocaleDateString('sv');
 
     const del_dia = eventos.filter(e => {
       const ms = aMs(e.timestamp ?? e.ts ?? e.inicio ?? e.created_at);

package/scripts/lib/evidencia-valor.js

@@ -0,0 +1,189 @@
+'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) ────────────────────────────────────────
+
+function leerNudges(raiz, { ventanaDias = 30, hoy = new Date() } = {}) {
+  const ruta = path.join(raiz, '.planning', 'evolution', 'nudges.jsonl');
+  if (!fs.existsSync(ruta)) return { disponible: false, razon: 'sin nudges.jsonl (proyecto sin actividad de hooks o telemetría desactivada)', 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.
+  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)) ultimaVerificacion = Math.max(ultimaVerificacion, fs.statSync(v).mtimeMs);
+      }
+    }
+    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)) return { disponible: false, razon: 'sin skill-metrics.json (telemetría de routing sin datos)' };
+  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 };