@saulwade/swl-ses 1.6.7 → 1.7.0

package/habilidades/swl-claudemd/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: swl-claudemd
 description: Conocimiento operacional para auditar y mantener archivos CLAUDE.md — contrato canónico de secciones (best practices Anthropic, ADR-0016), umbrales de bloat (líneas totales, bullets gigantes, placeholders, @references rotas), reglas de extracción a archivos referenciados con @, y plantillas de inicialización (init-user para ~/.claude/CLAUDE.md, init-project para CLAUDE.md raíz detectando stack). Provee las reglas; el comando /swl:claudemd ejecuta el flujo. Cargar desde ese comando o cuando el hook claudemd-bloat-detector sugiera intervención.
-version: "1.0.2"
+version: "1.2.0"
 herramientasPermitidas: [Read, Write, Edit, Bash, Glob, Grep]
 exclusiones:
   - "No cargar para editar reglas globales en ~/.claude/rules/ — usar Edit directo."
@@ -9,6 +9,11 @@ exclusiones:
   - "No cargar para validar otros archivos (.md de docs, READMEs) — solo CLAUDE.md tiene contrato canónico."
   - "No cargar para generar el bloque del installer en CLAUDE.md de proyectos destino — eso lo hace scripts/lib/transformadores/claude.js."
 evolvable: true
+evolved: true
+evolved-from: "1.1.0"
+evolved-at: "2026-05-22"
+evolved-by: "aprender"
+evolved-note: "Dimensión 8 — detección de duplicación de reglas globales (catálogo declarativo en scripts/lib/reglas-globales-conocidas.json). Refactor propone reemplazo canónico. Hook claudemd-duplicacion-detector.js complementa la capa async. Aplica regla nueva reglas/sin-duplicacion-reglas-globales.md (v1.7.0)."
 ---
 
 # Habilidad: Tratamiento profesional de CLAUDE.md
@@ -58,7 +63,7 @@ node scripts/auditar-claudemd.js --json    # para parsing
 node scripts/auditar-claudemd.js --strict  # exit 1 si WARN
 ```
 
-El auditor verifica seis dimensiones:
+El auditor verifica ocho dimensiones:
 
 | Dimensión | Regla | Severidad |
 |---|---|---|
@@ -68,6 +73,8 @@ El auditor verifica seis dimensiones:
 | Secciones canónicas | Stack, Comandos, Code style, Conventions presentes | WARN |
 | @references | Archivos >80 líneas usan al menos un `@docs/...md` | WARN |
 | Placeholders | `[TBD]`, `[TODO]`, `[COMPLETAR]` | ERROR |
+| Karpathy reference | Project-level >50 LOC menciona "Karpathy", los 4 principios, o `prevencion-sobreingenieria` | WARN |
+| Duplicación reglas globales | Bloque inline parafrasea regla de `~/.claude/rules/` ya cargada globalmente (catálogo en `scripts/lib/reglas-globales-conocidas.json`) | WARN |
 
 Veredicto final: ERROR → WARN → OK (el más severo gana).
 
@@ -168,6 +175,9 @@ Genera `./CLAUDE.md` raíz del proyecto detectando stack actual.
 2. Ejecutar `detectarStackDetallado(process.cwd())` (de
    `scripts/lib/detectar-stack-detallado.js`).
 3. Generar archivo con secciones pobladas:
+   - **Reglas obligatorias**: `@reglas/usar-sistema-swl.md`
+   - **Reglas de máxima prioridad** con sub-sección **Cuatro principios de
+     implementación (Karpathy)** — bloque exacto definido abajo
    - **Stack**: lenguaje + framework + ORM + package manager detectados
    - **Comandos**: npm scripts detectados o comandos típicos por lenguaje
    - **Code style**: placeholders explícitos (`<!-- pendiente: definir convención de X -->`)
@@ -177,6 +187,218 @@ Genera `./CLAUDE.md` raíz del proyecto detectando stack actual.
 4. Imprimir mensaje con próximo paso: "ejecuta `/swl:claudemd audit`
    para verificar".
 
+### Bloque obligatorio Karpathy en init-project
+
+Toda generación nueva incluye esta sub-sección literal en "Reglas de
+máxima prioridad":
+
+```markdown
+### Cuatro principios de implementación (Karpathy)
+Antes de implementar, refactorizar o corregir bugs: (1) **pensar antes de codificar** (no asumir en silencio), (2) **simplicidad primero** (sin abstracciones especulativas), (3) **cambios quirúrgicos** (leer archivo completo antes de editar, no refactor de oportunidad), (4) **ejecución orientada a metas** (criterios verificables, test que reproduce bugs antes del fix). Detalle + 9 ejemplos MAL→BIEN: `Skill("prevencion-sobreingenieria")` + `recursos/EXAMPLES.md`.
+```
+
+Justificación: el skill `prevencion-sobreingenieria` y su `recursos/EXAMPLES.md`
+se distribuyen con cada instalación SWL, así que la referencia siempre resuelve.
+La sub-sección compacta (5 líneas) ataca los gaps cognitivos más frecuentes
+de cualquier proyecto sin agregar opinión específica.
+
+### Check Karpathy en audit
+
+`scripts/auditar-claudemd.js` debe verificar (search regex case-insensitive):
+
+- `/karpathy/i`
+- `/cuatro principios/i` o `/4 principios/i`
+- `/prevencion-sobreingenieria/`
+- `/Skill\(["'`]prevencion-sobreingenieria["'`]\)/`
+
+Si NO encuentra ninguna AND el archivo tiene >50 LOC AND es project-level
+(no `~/.claude/CLAUDE.md`): emitir hallazgo WARN con mensaje:
+
+```
+CLAUDE.md no menciona los cuatro principios Karpathy ni el skill
+prevencion-sobreingenieria. Considerar agregar la sub-sección compacta
+(ver /swl:claudemd init-project § Bloque obligatorio Karpathy).
+```
+
+Esta dimensión es WARN, no ERROR — guía sin imponer. CLAUDE.md user-level
+(`~/.claude/`) NO se evalúa contra este check.
+
+---
+
+## Interacción con /swl:aprender (contrato cruzado)
+
+`/swl:aprender` y `/swl:claudemd` operan sobre el mismo archivo desde
+ángulos opuestos: aprender **muta**, claudemd **prescribe contrato**.
+Sin coordinación explícita, una sesión de aprender puede romper el
+contrato silenciosamente.
+
+### El gap arquitectural que esta interacción cierra
+
+`/swl:aprender` Paso 6 Tipo A agrega reglas a `CLAUDE.md` del proyecto.
+El hook `claudemd-bloat-detector.js` (PostToolUse, async, no bloqueante)
+emite nudge tras Write/Edit/MultiEdit sobre CLAUDE.md, pero **el nudge
+llega después** del comando de aprender. Resultado: aprender termina,
+reporta éxito al usuario, y solo después aparece el nudge — con el
+commit ya hecho.
+
+Origen detectado: sesión 2026-05-22 al evaluar el flujo SIGAF→swl-ses.
+CLAUDE.md SIGAF recibió ~25 líneas inline de "Triangulación schema
+cross-stack" sin validación post-mutación → archivo probablemente
+superó el umbral de 200 LOC sin warning consciente.
+
+### Contrato canónico de interacción
+
+Para cualquier comando SWL que escriba a CLAUDE.md del proyecto
+(`/swl:aprender`, `/swl:adoptar-proyecto`, `/swl:nuevo-proyecto`,
+`/swl:claudemd init-project`, futuros comandos similares):
+
+1. **Antes de escribir**: opcional, pero recomendado — leer el tamaño
+   actual del archivo y estimar el delta.
+2. **Después de escribir**: OBLIGATORIO ejecutar el auditor síncrono:
+
+   ```bash
+   node scripts/auditar-claudemd.js --json
+   # o fallback:
+   npx -y @saulwade/swl-ses@latest audit-claudemd --json
+   ```
+
+3. **Evaluar veredicto**:
+   - `OK` → continuar
+   - `WARN tamano-total` → proponer condensar o extraer a `@docs/lessons-<tema>.md`
+   - `WARN bullet-gigante` → proponer condensar a tabla/lista jerárquica
+   - `WARN secciones-canonicas` / `WARN sin-at-references` / `WARN karpathy-reference` → reportar al usuario, permitir continuar
+   - `ERROR placeholders` → **DETENER** y revertir
+
+4. **Re-ejecutar el auditor** tras la corrección hasta veredicto OK o
+   WARN aceptable.
+
+### Doble red de seguridad
+
+El sistema tiene dos capas de protección complementarias:
+
+| Capa | Mecanismo | Cuándo actúa | Bloqueo |
+|------|-----------|--------------|---------|
+| Síncrona | Paso 6.5 de `/swl:aprender` (y equivalente en otros comandos) | Justo después del Write/Edit, antes del reporte final | Bloquea pasos posteriores hasta resolver |
+| Asíncrona | Hook `claudemd-bloat-detector.js` (PostToolUse) | Tras cualquier Write/Edit/MultiEdit a CLAUDE.md (incluso fuera de comandos SWL) | No bloquea — emite nudge a `.planning/evolucion/nudges.jsonl` |
+
+La capa síncrona es proactiva (detiene el comando antes de reportar
+éxito). La asíncrona es retroactiva (cubre escrituras desde fuera de
+comandos SWL, ej. edición manual).
+
+### Por qué NO se duplica al hook
+
+El hook async existente cubre el caso de escrituras desde **cualquier
+fuente** (edición manual del usuario, otros comandos, scripts externos).
+Es la red de seguridad universal. La validación síncrona en aprender es
+específica para el flujo del comando — donde el agente puede actuar
+sobre el WARN antes de continuar.
+
+NO crear un hook nuevo dedicado a aprender — duplicaría el rol del
+existente. La invocación síncrona en el Paso 6.5 es suficiente.
+
+### Reglas duras
+
+- `/swl:aprender` Paso 6.5 es OBLIGATORIO si se aplicó Tipo A.
+- `/swl:adoptar-proyecto` Paso 8 debe ejecutar el auditor tras
+  generar/modificar CLAUDE.md.
+- `/swl:nuevo-proyecto` Paso 6 debe ejecutar el auditor tras generar
+  CLAUDE.md inicial.
+- `/swl:claudemd init-project` debe ejecutar el auditor sobre el
+  archivo recién generado.
+
+Cualquier comando futuro que escriba a CLAUDE.md DEBE seguir este
+contrato.
+
+---
+
+---
+
+## Detección de duplicación de reglas globales (dimensión 8)
+
+### Por qué existe
+
+Las reglas en `~/.claude/rules/` se cargan automáticamente en cada
+sesión SWL. Si un proyecto duplica inline el contenido de esas reglas
+en su `CLAUDE.md`, ocurren tres patologías:
+
+1. **Bloat acumulativo**: 7-15 líneas por regla duplicada × N proyectos
+   = inflación silenciosa que rompe el umbral de 200 LOC.
+2. **Drift al actualizar la global**: si la regla global cambia, las
+   copias en cada CLAUDE.md quedan obsoletas sin alerta.
+3. **Erosión del contrato canónico**: cada CLAUDE.md re-deriva el
+   principio con palabras propias, generando 4 paráfrasis distintas
+   del mismo contenido.
+
+La regla `reglas/sin-duplicacion-reglas-globales.md` (v1.7.0) prohíbe
+esta duplicación. Esta dimensión del auditor la detecta.
+
+### Catálogo declarativo
+
+`scripts/lib/reglas-globales-conocidas.json` lista las reglas globales
+conocidas con sus patrones de detección. Estructura por entrada:
+
+```json
+{
+  "id": "idioma-espanol-mexico",
+  "regla_global": "brevedad-output.md",
+  "seccion_canonica": "Idioma obligatorio: español de México",
+  "referencia_canonica": "@~/.claude/rules/brevedad-output.md § Idioma obligatorio",
+  "patrones": ["\\bespañol\\s+de\\s+M[ée]xico\\b", "..."],
+  "min_matches": 2,
+  "remediacion_sugerida": "Eliminar el bloque local..."
+}
+```
+
+Reglas incluidas en v1.7.0:
+
+- `idioma-espanol-mexico` (brevedad-output.md § Idioma)
+- `brevedad-sin-aiisms` (brevedad-output.md § Brevedad)
+- `git-sin-coautores` (git-coauthor.md)
+- `arreglar-al-detectar` (arreglar-al-detectar.md)
+- `debatir-antes-de-aceptar` (debatir-antes-de-aceptar.md)
+- `usar-context7` (usar-context7.md)
+
+### Cuándo NO se evalúa
+
+- **User-level** (`~/.claude/CLAUDE.md`): ahí sí pueden declararse
+  preferencias personales que parafrasean reglas globales. La opción
+  `esUserLevel: true` skipea la evaluación.
+- **Archivos < 20 LOC**: CLAUDE.md mínimos no acumulan duplicaciones
+  con suficiente densidad para evaluar.
+
+### Capa async — hook
+
+`hooks/claudemd-duplicacion-detector.js` (PostToolUse, no bloquea)
+ejecuta el detector tras cualquier Write/Edit a CLAUDE.md y emite
+nudge a `.planning/evolucion/nudges.jsonl` con `kind:
+claudemd-duplicacion-reglas`. Opt-out: `SWL_CLAUDEMD_DUPLICACION=0`.
+
+### Cómo refactorizar duplicaciones detectadas
+
+Tres opciones para cada hallazgo:
+
+1. **Eliminar** (default recomendado): el bloque solo repite la regla
+   global, eliminarlo no pierde información.
+2. **Convertir a matiz local** (≤3 líneas): si el bloque agrega valor
+   local genuino, reescribirlo corto referenciando la regla global:
+   ```markdown
+   Convenciones locales: identificadores técnicos en inglés (rutas,
+   comandos). Ver @~/.claude/rules/brevedad-output.md.
+   ```
+3. **Documentar override explícito** (raro): si el proyecto contradice
+   la regla global por requerimiento documentable:
+   ```markdown
+   Override de @~/.claude/rules/brevedad-output.md § Brevedad: este
+   proyecto exige docstrings extendidos por compliance regulatorio.
+   ```
+
+### Anti-patrón: "lo dejo por claridad"
+
+La regla global YA es visible — se carga automáticamente. Duplicarla
+no aumenta su prioridad ni su claridad; solo crea deuda. Si el WARN
+del auditor incomoda, la respuesta correcta es **resolver la
+duplicación**, no aceptar el WARN.
+
 ---
 
 ## Gotchas / Errores comunes no obvios

package/hooks/claudemd-duplicacion-detector.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: claudemd-duplicacion-detector.js
+ * Tipo: PostToolUse  (aplica a: Write, Edit, MultiEdit)
+ *
+ * Detecta duplicación de reglas globales (`~/.claude/rules/`) inline en
+ * `CLAUDE.md` de proyecto recién modificados. Consume el detector
+ * `scripts/lib/detector-reglas-duplicadas.js` que lee el catálogo
+ * declarativo `scripts/lib/reglas-globales-conocidas.json`.
+ *
+ * Aplica la regla `reglas/sin-duplicacion-reglas-globales.md`:
+ * el `CLAUDE.md` del proyecto NO debe duplicar reglas que ya viven en
+ * `~/.claude/rules/`. La regla global es fuente de verdad; el proyecto
+ * referencia, no duplica.
+ *
+ * Opt-out: SWL_CLAUDEMD_DUPLICACION=0 desactiva completamente el hook.
+ *
+ * Comportamiento:
+ *   - Nunca bloquea operaciones (exit code 0 siempre)
+ *   - Solo emite nudge cuando hay duplicaciones detectadas
+ *   - Solo se dispara con archivos cuyo basename sea exactamente CLAUDE.md
+ *   - Respeta exclusiones: temp/, node_modules/, respositorios-git/
+ *   - NO evalúa user-level (~/.claude/CLAUDE.md) — ahí sí pueden
+ *     declararse preferencias personales
+ *
+ * Formato del nudge:
+ *   {
+ *     id: string,
+ *     kind: "claudemd-duplicacion-reglas",
+ *     target: "documentador-swl",
+ *     source: "hooks/claudemd-duplicacion-detector.js",
+ *     message: "...",
+ *     data: { archivo, duplicaciones: [...] },
+ *     ts: ISO,
+ *     accionado: false
+ *   }
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// ─── Opt-out global ───────────────────────────────────────────────────────
+if (process.env.SWL_CLAUDEMD_DUPLICACION === '0') {
+  process.exit(0);
+}
+
+let hookInput = '';
+try {
+  hookInput = fs.readFileSync(0, 'utf-8');
+} catch (_) {
+  process.exit(0);
+}
+
+let evento;
+try {
+  evento = JSON.parse(hookInput);
+} catch (_) {
+  process.exit(0);
+}
+
+const toolName = evento?.tool_name;
+const toolInput = evento?.tool_input;
+
+if (!toolName || !['Write', 'Edit', 'MultiEdit'].includes(toolName)) {
+  process.exit(0);
+}
+
+const filePath = toolInput?.file_path;
+if (!filePath) {
+  process.exit(0);
+}
+
+// Solo CLAUDE.md (basename exacto, case-sensitive)
+const basename = path.basename(filePath);
+if (basename !== 'CLAUDE.md') {
+  process.exit(0);
+}
+
+const pathNormalized = filePath.replace(/\\/g, '/');
+const RUTAS_EXCLUIDAS = [
+  '/temp/',
+  '/node_modules/',
+  '/respositorios-git/',
+  '/.planning/',
+];
+if (RUTAS_EXCLUIDAS.some((excluida) => pathNormalized.includes(excluida))) {
+  process.exit(0);
+}
+
+// User-level: no evaluar (puede declarar preferencias personales)
+const homeClaudeDir = path.resolve(path.join(os.homedir(), '.claude'));
+const rutaAbs = path.resolve(filePath);
+const esUserLevel = rutaAbs.startsWith(homeClaudeDir + path.sep) || rutaAbs === path.join(homeClaudeDir, 'CLAUDE.md');
+
+// El archivo debe existir
+if (!fs.existsSync(filePath)) {
+  process.exit(0);
+}
+
+// ─── Cargar detector ──────────────────────────────────────────────────────
+const CWD = process.cwd();
+const detectorPath = path.join(CWD, 'scripts', 'lib', 'detector-reglas-duplicadas.js');
+if (!fs.existsSync(detectorPath)) {
+  // No hay detector instalado en este destino; salir silenciosamente
+  process.exit(0);
+}
+
+let resultado;
+try {
+  const { detectarDuplicaciones } = require(detectorPath);
+  const contenido = fs.readFileSync(filePath, 'utf8');
+  resultado = detectarDuplicaciones(contenido, null, { esUserLevel });
+} catch (_) {
+  // Cualquier error del detector: salir silenciosamente
+  process.exit(0);
+}
+
+// Solo emitir nudge si hay duplicaciones detectadas
+if (!resultado || !resultado.evaluado || resultado.duplicaciones.length === 0) {
+  process.exit(0);
+}
+
+// ─── Construir nudge ──────────────────────────────────────────────────────
+const rutaRelativa = path.relative(CWD, filePath).replace(/\\/g, '/');
+const topDuplicaciones = resultado.duplicaciones
+  .slice(0, 5)
+  .map((d) => `  - [${d.severidad}] ${d.id} (regla global: ${d.regla_global}, línea ~${d.linea_aproximada})`)
+  .join('\n');
+
+const nudge = {
+  id: crypto.randomBytes(8).toString('hex'),
+  kind: 'claudemd-duplicacion-reglas',
+  target: 'documentador-swl',
+  source: 'hooks/claudemd-duplicacion-detector.js',
+  message:
+    `[claudemd-dup] ${rutaRelativa} duplica ${resultado.duplicaciones.length} regla(s) global(es):\n` +
+    topDuplicaciones + '\n' +
+    `  Ejecutar \`/swl:claudemd audit\` para detalle, ` +
+    `\`/swl:claudemd refactor\` para sugerencias de reemplazo.\n` +
+    `  Ver regla: \`reglas/sin-duplicacion-reglas-globales.md\`.`,
+  data: {
+    archivo: rutaRelativa,
+    total_evaluadas: resultado.total_reglas_evaluadas,
+    detectadas: resultado.duplicaciones.length,
+    ids: resultado.duplicaciones.map((d) => d.id),
+    reglas_globales: [...new Set(resultado.duplicaciones.map((d) => d.regla_global))],
+  },
+  ts: new Date().toISOString(),
+  accionado: false,
+  accionado_ts: null,
+  accionado_por: null,
+};
+
+// ─── Persistir a nudges.jsonl ─────────────────────────────────────────────
+try {
+  const nudgesPath = path.join(CWD, '.planning', 'evolucion', 'nudges.jsonl');
+  const nudgesDir = path.dirname(nudgesPath);
+  if (!fs.existsSync(nudgesDir)) {
+    fs.mkdirSync(nudgesDir, { recursive: true });
+  }
+  fs.appendFileSync(nudgesPath, JSON.stringify(nudge) + '\n', 'utf-8');
+} catch (_) {
+  // No fallar el hook por error de escritura
+}
+
+process.exit(0);

package/manifiestos/hooks-config.json

@@ -356,6 +356,15 @@
       "maxConsecutiveFailures": 5,
       "degradeOnFailure": "skip"
     },
+    "claudemd-duplicacion-detector.js": {
+      "event": "PostToolUse",
+      "matcher": "Write|Edit|MultiEdit",
+      "description": "Detecta duplicación de reglas globales (~/.claude/rules/) inline en CLAUDE.md de proyecto. Consume scripts/lib/detector-reglas-duplicadas.js + catálogo scripts/lib/reglas-globales-conocidas.json. Aplica regla reglas/sin-duplicacion-reglas-globales.md. Emite nudge a .planning/evolucion/nudges.jsonl si hay duplicaciones detectadas. No bloquea — kind: claudemd-duplicacion-reglas. Excluye temp/, node_modules/, respositorios-git/, .planning/, ~/.claude/ (user-level). Opt-out: SWL_CLAUDEMD_DUPLICACION=0.",
+      "blocking": false,
+      "async": true,
+      "maxConsecutiveFailures": 5,
+      "degradeOnFailure": "skip"
+    },
     "validar-intent-spec.js": {
       "event": "PostToolUse",
       "matcher": "Write|Edit|MultiEdit",

package/manifiestos/modulos.json

@@ -905,7 +905,9 @@
         "reglas/registro-componentes-nuevos.md",
         "reglas/auditorias-documentales-estructurales.md",
         "reglas/intent-engineering.md",
-        "reglas/tests-cleanup.md"
+        "reglas/tests-cleanup.md",
+        "reglas/verificar-citas-temporales.md",
+        "reglas/sin-duplicacion-reglas-globales.md"
       ],
       "targets": [
         "claude",
@@ -1024,6 +1026,7 @@
         "hooks/inbox-aviso.js",
         "hooks/aiisms-detector.js",
         "hooks/claudemd-bloat-detector.js",
+        "hooks/claudemd-duplicacion-detector.js",
         "hooks/validar-intent-spec.js",
         "hooks/sugerir-regenerar-inventario.js",
         "hooks/sugerir-contribuir.js",
@@ -1219,6 +1222,8 @@
       "tipo": "scripts",
       "archivos": [
         "scripts/auditar-claudemd.js",
+        "scripts/lib/detector-reglas-duplicadas.js",
+        "scripts/lib/reglas-globales-conocidas.json",
         "docs/variables-entorno.md"
       ],
       "targets": [

package/manifiestos/skills-lock.json

@@ -1,8 +1,8 @@
 {
   "lockfileVersion": 1,
-  "generatedAt": "2026-05-21T20:46:43.799Z",
+  "generatedAt": "2026-05-22T23:28:47.439Z",
   "skillsCount": 177,
-  "lockHash": "sha256:f87e22a97a86a4abe7f1da215dc894433c3c8c9dfe9434e53d5a70e5b4912406",
+  "lockHash": "sha256:d0306679d924ecbbd0071f532df9f2cfb499817eb42b0bb5e6e5ebcdacb941f2",
   "skills": [
     {
       "nombre": "accesibilidad-a11y",
@@ -889,9 +889,9 @@
     {
       "nombre": "prevencion-sobreingenieria",
       "path": "habilidades/prevencion-sobreingenieria/SKILL.md",
-      "hash": "sha256:7396e1d8e7c87dd0154e9b34d1eff4124997566ca9a9da63b8a0514680af131e",
-      "bytes": 16468,
-      "version": "\"1.1.0\""
+      "hash": "sha256:9f6d0d4f5c54e29aff3e5fa66d89c42a0dabfd0a59eefcfbf6715ca085984f3e",
+      "bytes": 16812,
+      "version": "\"1.2.0\""
     },
     {
       "nombre": "privacy-memoria",
@@ -1099,9 +1099,9 @@
     {
       "nombre": "swl-claudemd",
       "path": "habilidades/swl-claudemd/SKILL.md",
-      "hash": "sha256:18cef250bd32a7841db3b6362b9303679bf2851e5e1efe7f3d81f0dd514ec5eb",
-      "bytes": 11585,
-      "version": "\"1.0.2\""
+      "hash": "sha256:0f5eed29f3fedb3bca8036ae5680901712520b31190ad416700c732b2b5897e4",
+      "bytes": 21518,
+      "version": "\"1.2.0\""
     },
     {
       "nombre": "swl-dashboard",