@saulwade/swl-ses 1.0.0

package/scripts/publicar.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+// publicar.js — Dual-publish: npmjs.org (canónico) + GitHub Packages (mirror)
+// Uso: node scripts/publicar.js [--solo-github | --solo-npmjs | --dry-run]
+//
+// Tras el rebrand v1.0.0 (rebranding de @saulwadeleon/swl-software-engineering-system):
+//   - npmjs.org    → @saulwade/swl-ses        (canónico, scope sin guion)
+//   - GH Packages  → @saul-wade/swl-ses       (mirror, scope con guion = org GitHub)
+//
+// El package.json del repo declara el nombre canónico (npmjs). Para GitHub
+// Packages se genera un package.json temporal con scope/registry sobreescritos.
+// Exit: 0=éxito, 1=error
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const {
+  NOMBRE_GITHUB_MIRROR: GITHUB_NAME,
+  REGISTRY_GITHUB:      GITHUB_REGISTRY,
+  REGISTRY_NPMJS:       NPMJS_REGISTRY,
+} = require('./lib/paquetes-conocidos');
+
+const {
+  esDirArtefacto,
+  esArchivoArtefacto,
+} = require('./lib/artefactos-python');
+
+const ROOT     = path.resolve(__dirname, '..');
+const PKG_PATH = path.join(ROOT, 'package.json');
+
+/**
+ * Resuelve el binario de npm a invocar. Usa node + npm-cli.js cuando es
+ * posible para evitar shell:true en Windows (mismo enfoque que la lib
+ * scripts/lib/npm-version.js).
+ */
+const NPM_CLI_JS = (() => {
+  const dir = path.dirname(process.execPath);
+  for (const c of [
+    path.join(dir, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(dir, '..', 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ]) {
+    try { if (fs.existsSync(c)) return c; } catch { /* continuar */ }
+  }
+  return null;
+})();
+
+function npmExec(args, opts = {}) {
+  const defaults = { cwd: ROOT, stdio: 'inherit', timeout: 300_000 };
+  if (NPM_CLI_JS) {
+    return execFileSync(process.execPath, [NPM_CLI_JS, ...args], { ...defaults, ...opts });
+  }
+  // Fallback a npm/npm.cmd como ejecutable nombrado. NO usamos shell:true:
+  // todos los args son strings ya separados, sin interpolación.
+  const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  return execFileSync(bin, args, { ...defaults, ...opts });
+}
+
+function leerPkg() {
+  return JSON.parse(fs.readFileSync(PKG_PATH, 'utf-8'));
+}
+
+function verificarLogin(registry) {
+  try {
+    const result = npmExec(['whoami', `--registry=${registry}`], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+      timeout:  15_000,
+    });
+    return String(result).trim();
+  } catch (err) {
+    // Distinguir "no autenticado" (lo más común) de "error de red" o "npm
+    // no en PATH" requiere inspección del mensaje. Emitir el motivo real
+    // a stderr para que el usuario lo vea pero retornar null al caller
+    // que ya tiene un mensaje específico para "No autenticado".
+    const motivo = String(err.message || err).split('\n')[0].slice(0, 120);
+    process.stderr.write(`[verificarLogin ${registry}] ${motivo}\n`);
+    return null;
+  }
+}
+
+function copiarDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    // Excluir artefactos Python (lista canónica en lib/artefactos-python.js)
+    if (entry.isDirectory() && esDirArtefacto(entry.name)) continue;
+    if (!entry.isDirectory() && esArchivoArtefacto(entry.name)) continue;
+
+    const srcPath  = path.join(src,  entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copiarDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function limpiar(tmpDir) {
+  try {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  } catch (err) {
+    // En Windows el filesystem puede mantener locks transitorios sobre
+    // archivos recién copiados. La limpieza eventual la hace el SO; no
+    // bloqueamos el flujo, pero anotamos el path para inspección manual.
+    process.stderr.write(`[publicar] no se pudo limpiar tmpDir ${tmpDir}: ${String(err.message).slice(0, 80)}\n`);
+  }
+}
+
+function construirPkgTemporal(pkg, nombre, registry) {
+  const tmpPkg = {
+    ...pkg,
+    name: nombre,
+    publishConfig: { registry, access: 'public' },
+  };
+  // Quitar prepack/prepublishOnly del temp para evitar recursión.
+  // npm publish desde tmpDir invocaría prepack apuntando a un script
+  // que ya no existe en ese path, y prepublishOnly correría el suite
+  // de tests dos veces.
+  if (tmpPkg.scripts) {
+    delete tmpPkg.scripts.prepack;
+    delete tmpPkg.scripts.prepublishOnly;
+  }
+  return tmpPkg;
+}
+
+function copiarArchivosFiles(pkg, tmpDir) {
+  for (const entry of pkg.files || []) {
+    const src = path.join(ROOT, entry);
+    const dest = path.join(tmpDir, entry);
+    if (!fs.existsSync(src)) continue;
+    if (fs.statSync(src).isDirectory()) {
+      copiarDir(src, dest);
+    } else {
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function copiarMetadatos(tmpDir) {
+  // npm incluye README/LICENSE/CHANGELOG automáticamente al publicar.
+  for (const meta of ['README.md', 'LICENSE', 'CHANGELOG.md', 'CHANGELOG-LEGACY.md']) {
+    const src = path.join(ROOT, meta);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(tmpDir, meta));
+    }
+  }
+}
+
+function prepararDirectorioTemporal(pkg, nombrePersonalizado, registryPersonalizado) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-ses-publish-'));
+  const tmpPkg = construirPkgTemporal(pkg, nombrePersonalizado, registryPersonalizado);
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify(tmpPkg, null, 2));
+  copiarArchivosFiles(pkg, tmpDir);
+  copiarMetadatos(tmpDir);
+  return tmpDir;
+}
+
+function publicarNpmjs(pkg, dryRun) {
+  console.log('\n=== 1/2 — npmjs.org (canónico) ===');
+  console.log(`Paquete: ${pkg.name}@${pkg.version}`);
+  console.log(`Registry: ${NPMJS_REGISTRY}`);
+
+  const usuario = verificarLogin(NPMJS_REGISTRY);
+  if (!usuario) {
+    console.error('ERROR: No autenticado en npmjs.');
+    console.error(`Ejecuta: npm login --registry=${NPMJS_REGISTRY}`);
+    return false;
+  }
+  console.log(`Autenticado como: ${usuario}`);
+
+  const args = ['publish', `--registry=${NPMJS_REGISTRY}`, '--access', 'public'];
+  if (dryRun) args.push('--dry-run');
+  try {
+    npmExec(args);
+    console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${pkg.name}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en npmjs`);
+    return true;
+  } catch (err) {
+    console.error(`ERROR publicando en npmjs: ${err.message}`);
+    return false;
+  }
+}
+
+function publicarGitHub(pkg, dryRun) {
+  console.log('\n=== 2/2 — GitHub Packages (mirror) ===');
+  console.log(`Paquete: ${GITHUB_NAME}@${pkg.version}`);
+  console.log(`Registry: ${GITHUB_REGISTRY}`);
+
+  const usuario = verificarLogin(GITHUB_REGISTRY);
+  if (!usuario) {
+    console.error('ERROR: No autenticado en GitHub Packages.');
+    console.error(`Ejecuta: npm login --registry=${GITHUB_REGISTRY}`);
+    return false;
+  }
+  console.log(`Autenticado como: ${usuario}`);
+
+  const tmpDir = prepararDirectorioTemporal(pkg, GITHUB_NAME, GITHUB_REGISTRY);
+
+  const args = ['publish', `--registry=${GITHUB_REGISTRY}`];
+  if (dryRun) args.push('--dry-run');
+  try {
+    npmExec(args, { cwd: tmpDir });
+    console.log(`${dryRun ? '[DRY-RUN] ' : ''}OK: ${GITHUB_NAME}@${pkg.version} ${dryRun ? 'se publicaría' : 'publicado'} en GitHub Packages`);
+    if (dryRun) console.log(`Directorio temporal: ${tmpDir}`);
+    limpiar(tmpDir);
+    return true;
+  } catch (err) {
+    console.error(`ERROR publicando en GitHub Packages: ${err.message}`);
+    limpiar(tmpDir);
+    return false;
+  }
+}
+
+function parsearArgs(argv) {
+  return {
+    dryRun:     argv.includes('--dry-run'),
+    soloGithub: argv.includes('--solo-github'),
+    soloNpmjs:  argv.includes('--solo-npmjs'),
+  };
+}
+
+function imprimirEncabezado(version, dryRun) {
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║  @saulwade/swl-ses — Publicación dual    ║');
+  console.log('╚══════════════════════════════════════════╝');
+  console.log(`Versión: ${version}`);
+  if (dryRun) console.log('Modo: DRY-RUN (sin cambios)');
+}
+
+function avisarSiHayCambiosSinCommit(dryRun) {
+  try {
+    const status = String(execFileSync('git', ['status', '--porcelain'], {
+      cwd: ROOT, encoding: 'utf-8',
+    })).trim();
+    if (status && !dryRun) {
+      console.warn('\nADVERTENCIA: Hay cambios sin commitear.');
+      console.warn('Se recomienda hacer commit antes de publicar.\n');
+    }
+  } catch (err) {
+    // No es repo git, o git no está disponible. No bloquea el publish.
+    process.stderr.write(`[publicar] git status falló (no bloqueante): ${String(err.message).slice(0, 80)}\n`);
+  }
+}
+
+function reportarResultado(pkg, opts, npmjsOk, githubOk) {
+  console.log('\n=== Resultado ===');
+  if (!opts.soloGithub) console.log(`npmjs.org:        ${npmjsOk ? 'OK' : 'FALLÓ'} — ${pkg.name}@${pkg.version}`);
+  if (!opts.soloNpmjs)  console.log(`GitHub Packages:  ${githubOk ? 'OK' : 'FALLÓ'} — ${GITHUB_NAME}@${pkg.version}`);
+  if (!opts.soloNpmjs && !opts.soloGithub && npmjsOk && githubOk) {
+    console.log('\nAmbos paquetes publicados. Los usuarios pueden instalar con:');
+    console.log(`  npx ${pkg.name}@latest doctor                    (canónico, recomendado)`);
+    console.log(`  npx ${GITHUB_NAME}@latest doctor                 (mirror GitHub Packages)`);
+  }
+}
+
+function main() {
+  const opts = parsearArgs(process.argv.slice(2));
+  const pkg  = leerPkg();
+  imprimirEncabezado(pkg.version, opts.dryRun);
+  avisarSiHayCambiosSinCommit(opts.dryRun);
+
+  const npmjsOk  = opts.soloGithub ? true : publicarNpmjs(pkg, opts.dryRun);
+  const githubOk = opts.soloNpmjs  ? true : publicarGitHub(pkg, opts.dryRun);
+
+  reportarResultado(pkg, opts, npmjsOk, githubOk);
+  process.exit(npmjsOk && githubOk ? 0 : 1);
+}
+
+// Solo ejecutar el flujo completo cuando el script se invoca como CLI.
+// Cuando se importa como módulo (tests), expone helpers para verificar
+// invariantes de prepararDirectorioTemporal sin hacer publish real.
+if (require.main === module) {
+  main();
+} else {
+  module.exports = {
+    prepararDirectorioTemporal,
+    copiarDir,
+    limpiar,
+    GITHUB_NAME,
+    GITHUB_REGISTRY,
+    NPMJS_REGISTRY,
+  };
+}

package/scripts/reflect-skills.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * reflect-skills.js — Análisis de historial JSONL de Claude Code para detectar
+ * patrones repetidos que sean candidatos a nuevos skills o comandos SWL.
+ *
+ * Inspirado en claude-reflect (Karpathy) — descubrimiento semántico ligero
+ * basado en tokens y verbos de acción, sin dependencias externas.
+ *
+ * Fuentes:
+ *   - ~/.claude/projects/<slug-proyecto>/*.jsonl
+ *   - .planning/evolucion/feedback-queue.jsonl (si existe)
+ *
+ * Salida:
+ *   - stdout: reporte de clusters con N >= UMBRAL_REPETICIONES
+ *   - .planning/evolucion/reflect-skills-report.json: reporte estructurado
+ *
+ * Uso:
+ *   node scripts/reflect-skills.js [--ventana 30] [--umbral 3] [--json]
+ *
+ * @module scripts/reflect-skills
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ---------------------------------------------------------------------------
+// Parámetros por defecto
+// ---------------------------------------------------------------------------
+
+const VENTANA_DIAS_DEFAULT  = 30;   // Analizar últimos N días
+const UMBRAL_REPETICIONES   = 3;    // Mínimo de ocurrencias para reportar cluster
+const MAX_PROMPTS_POR_ARCHIVO = 500; // Cap por JSONL (performance)
+
+// Palabras vacías a excluir del token matching
+const STOPWORDS = new Set([
+  'de','la','que','el','en','y','a','los','del','se','las','por','un','para',
+  'con','no','una','su','al','lo','como','más','pero','sus','le','ya','o','este',
+  'sí','porque','esta','entre','cuando','muy','sin','sobre','también','me','hasta',
+  'hay','donde','quien','desde','todo','nos','durante','todos','uno','les','ni',
+  'contra','otros','ese','eso','ante','ellos','e','esto','mí','antes','algunos',
+  'qué','unos','yo','otro','otras','otra','él','tanto','esa','estos','mucho',
+  'quienes','nada','muchos','cual','poco','ella','estar','estas','algunas','algo',
+  'nosotros','mi','mis','tú','te','ti','tu','tus','ellas','nosotras','vosotros',
+  'vosotras','os','mío','mía','míos','mías','tuyo','tuya','tuyos','tuyas','suyo',
+  'suya','suyos','suyas','nuestro','nuestra','nuestros','nuestras','vuestro',
+  'vuestra','vuestros','vuestras','esos','esas','estoy','estás','está','estamos',
+  'estáis','están','esté','estés','estemos','estéis','estén','estaré','estarás',
+  'estará','estaremos','estaréis','estarán',
+  // Inglés
+  'the','is','at','which','on','and','a','an','in','to','of','for','with','that',
+  'this','it','as','by','be','are','was','were','been','being','have','has','had',
+  'do','does','did','will','would','should','could','may','might','must','can',
+  'if','then','else','when','where','why','how','what','who','whom','or','but',
+  'not','no','yes','so','very','just','also','than','too','only','own','same',
+  'such','from','into','over','under','again','further','once','here','there',
+  'these','those','am','i','you','he','she','we','they','me','him','her','us',
+  'them','my','your','his','its','our','their',
+]);
+
+// Verbos de acción frecuentes en prompts de desarrollo
+const VERBOS_ACCION = [
+  'implementa','implementar','crea','crear','agrega','agregar','escribe','escribir',
+  'modifica','modificar','cambia','cambiar','corrige','corregir','arregla','arreglar',
+  'revisa','revisar','audita','auditar','analiza','analizar','verifica','verificar',
+  'valida','validar','prueba','probar','testea','testear','ejecuta','ejecutar',
+  'documenta','documentar','refactoriza','refactorizar','optimiza','optimizar',
+  'migra','migrar','instala','instalar','actualiza','actualizar','libera','release',
+  'commit','push','merge','debug','depura','depurar','investiga','investigar',
+  'planifica','planificar','diseña','diseñar','genera','generar','integra','integrar',
+  // Inglés
+  'implement','create','add','write','modify','change','fix','review','audit',
+  'analyze','verify','validate','test','run','document','refactor','optimize',
+  'migrate','install','update','release','debug','investigate','plan','design',
+  'generate','integrate',
+];
+
+// ---------------------------------------------------------------------------
+// Lectura del historial JSONL de Claude Code
+// ---------------------------------------------------------------------------
+
+/**
+ * Construye el slug de proyecto que Claude Code usa para nombrar el directorio
+ * de historial. Ejemplo: D:\Python\swl-ses → D--Python-swl-ses
+ */
+function slugProyecto(cwd) {
+  return cwd.replace(/:/g, '-').replace(/[\\/]/g, '-');
+}
+
+/**
+ * Localiza los JSONL del proyecto actual.
+ */
+function localizarJsonlProyecto(cwd) {
+  const home = os.homedir();
+  const base = path.join(home, '.claude', 'projects', slugProyecto(cwd));
+  if (!fs.existsSync(base)) return [];
+  try {
+    return fs.readdirSync(base)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => path.join(base, f));
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Lee un JSONL y extrae prompts del usuario con timestamp.
+ */
+function extraerPrompts(jsonlPath, ventanaMs) {
+  const cutoff = Date.now() - ventanaMs;
+  const prompts = [];
+  try {
+    const stat = fs.statSync(jsonlPath);
+    if (stat.mtimeMs < cutoff) return [];
+
+    const raw = fs.readFileSync(jsonlPath, 'utf8');
+    const lineas = raw.trim().split(/\r?\n/).slice(-MAX_PROMPTS_POR_ARCHIVO);
+    for (const linea of lineas) {
+      try {
+        const ev = JSON.parse(linea);
+        const msg = ev.message || ev;
+        const role = msg.role || msg.type;
+        if (role !== 'user') continue;
+        const ts = ev.timestamp || ev.ts;
+        const tms = ts ? new Date(ts).getTime() : stat.mtimeMs;
+        if (tms < cutoff) continue;
+
+        const content = msg.content;
+        let texto = '';
+        if (typeof content === 'string') {
+          texto = content;
+        } else if (Array.isArray(content)) {
+          for (const b of content) {
+            if (b && b.type === 'text' && b.text) texto += b.text + ' ';
+          }
+        }
+        texto = texto.trim();
+        if (!texto || texto.length < 10) continue;
+        // Filtrar slash-commands y mensajes de sistema
+        if (texto.startsWith('<')) continue;
+        if (texto.startsWith('/')) continue;
+        if (texto.startsWith('[Request interrupted')) continue;
+        // Filtrar invocaciones de skills y comandos del harness (pastes largos de SKILL.md o .md)
+        if (texto.startsWith('# /swl:') || texto.startsWith('# SKILL')) continue;
+        if (texto.includes('<command-name>') || texto.includes('</command-message>')) continue;
+        if (texto.includes('<system-reminder>')) continue;
+        // Filtrar tool result echoes o pastes > 2000 chars (son transcripts, no intenciones)
+        if (texto.length > 2000) continue;
+        prompts.push({ texto, ts: tms });
+      } catch (_) { /* línea corrupta */ }
+    }
+  } catch (_) { /* archivo inaccesible */ }
+  return prompts;
+}
+
+// ---------------------------------------------------------------------------
+// Tokenización y clustering
+// ---------------------------------------------------------------------------
+
+/**
+ * Normaliza y tokeniza un texto.
+ */
+function tokenizar(texto) {
+  const norm = texto.toLowerCase()
+    .normalize('NFD').replace(/[̀-ͯ]/g, '') // quitar acentos
+    .replace(/[^a-z0-9áéíóúñü\s-]/gi, ' ');
+  return norm.split(/\s+/).filter(t => t.length > 2 && !STOPWORDS.has(t));
+}
+
+/**
+ * Extrae el verbo de acción principal y un objeto (noun) candidato.
+ */
+function extraerIntencion(texto) {
+  const tokens = tokenizar(texto);
+  if (tokens.length === 0) return null;
+
+  let verbo = null;
+  let verboIdx = -1;
+  for (let i = 0; i < tokens.length; i++) {
+    if (VERBOS_ACCION.includes(tokens[i])) {
+      verbo = tokens[i];
+      verboIdx = i;
+      break;
+    }
+  }
+  if (!verbo) return null;
+
+  // Objeto: los 2-3 tokens que siguen al verbo
+  const objeto = tokens.slice(verboIdx + 1, verboIdx + 4)
+    .filter(t => !VERBOS_ACCION.includes(t))
+    .slice(0, 2)
+    .join('-');
+  if (!objeto) return null;
+
+  return { verbo, objeto };
+}
+
+/**
+ * Agrupa prompts por intención (verbo + objeto principal).
+ */
+function clusterizarPrompts(prompts) {
+  const clusters = new Map();
+  for (const p of prompts) {
+    const intencion = extraerIntencion(p.texto);
+    if (!intencion) continue;
+    const clave = `${intencion.verbo}::${intencion.objeto}`;
+    if (!clusters.has(clave)) {
+      clusters.set(clave, {
+        clave,
+        verbo: intencion.verbo,
+        objeto: intencion.objeto,
+        ejemplos: [],
+        count: 0,
+      });
+    }
+    const c = clusters.get(clave);
+    c.count += 1;
+    if (c.ejemplos.length < 3) {
+      c.ejemplos.push(p.texto.slice(0, 180));
+    }
+  }
+  return Array.from(clusters.values()).sort((a, b) => b.count - a.count);
+}
+
+// ---------------------------------------------------------------------------
+// Feedback queue
+// ---------------------------------------------------------------------------
+
+function leerFeedbackQueue(cwd, ventanaMs) {
+  const queuePath = path.join(cwd, '.planning', 'evolucion', 'feedback-queue.jsonl');
+  if (!fs.existsSync(queuePath)) return [];
+  const cutoff = Date.now() - ventanaMs;
+  const items = [];
+  try {
+    const raw = fs.readFileSync(queuePath, 'utf8');
+    const lineas = raw.trim().split(/\r?\n/);
+    for (const l of lineas) {
+      try {
+        const obj = JSON.parse(l);
+        const ts = obj.ts ? new Date(obj.ts).getTime() : 0;
+        if (ts < cutoff) continue;
+        items.push(obj);
+      } catch (_) {}
+    }
+  } catch (_) {}
+  return items;
+}
+
+function resumirFeedback(items) {
+  const porTipo = {};
+  for (const it of items) {
+    porTipo[it.tipo] = (porTipo[it.tipo] || 0) + 1;
+  }
+  return porTipo;
+}
+
+// ---------------------------------------------------------------------------
+// Reporte
+// ---------------------------------------------------------------------------
+
+function armarReporte(clusters, feedback, opts) {
+  const candidatos = clusters
+    .filter(c => c.count >= opts.umbral)
+    .map(c => ({
+      intencion:    `${c.verbo} ${c.objeto.replace(/-/g, ' ')}`,
+      ocurrencias:  c.count,
+      ejemplos:     c.ejemplos,
+      propuesta:    proponerSkillOComando(c),
+    }));
+
+  return {
+    ventanaDias:   opts.ventanaDias,
+    umbral:        opts.umbral,
+    totalPrompts:  opts.totalPrompts,
+    generadoEn:    new Date().toISOString(),
+    candidatos,
+    feedback: {
+      items:   feedback.length,
+      porTipo: resumirFeedback(feedback),
+    },
+  };
+}
+
+function proponerSkillOComando(cluster) {
+  // Heurística simple: si el verbo es de acción CRUD clara → candidato a comando.
+  // Si el objeto es un dominio técnico (ej: "api rest") → candidato a skill.
+  const verbosComando = ['ejecuta','ejecutar','run','verifica','verificar','valida','validar','audita','auditar','libera','release'];
+  const esVerboComando = verbosComando.includes(cluster.verbo);
+  if (esVerboComando) {
+    return {
+      tipo:    'comando',
+      nombre:  `/swl:${cluster.objeto.split('-')[0]}-${cluster.verbo}`,
+      motivo:  `Verbo operativo "${cluster.verbo}" repetido ${cluster.count}× → candidato a automatización por comando slash.`,
+    };
+  }
+  return {
+    tipo:    'skill',
+    nombre:  `${cluster.objeto}-${cluster.verbo}`.replace(/--+/g, '-'),
+    motivo:  `Intención "${cluster.verbo} ${cluster.objeto}" repetida ${cluster.count}× → candidato a skill que encapsule el patrón.`,
+  };
+}
+
+function formatearReporteTexto(reporte) {
+  const lineas = [];
+  lineas.push('━━━ Reflect Skills — análisis de historial ━━━');
+  lineas.push(`  Ventana: últimos ${reporte.ventanaDias} días`);
+  lineas.push(`  Prompts analizados: ${reporte.totalPrompts}`);
+  lineas.push(`  Umbral de repetición: ${reporte.umbral}`);
+  lineas.push('');
+  if (reporte.candidatos.length === 0) {
+    lineas.push('  Sin patrones repetidos arriba del umbral. No hay candidatos a skill/comando emergente.');
+  } else {
+    lineas.push(`  ${reporte.candidatos.length} candidato(s) detectado(s):`);
+    lineas.push('');
+    reporte.candidatos.forEach((c, i) => {
+      lineas.push(`  ${i + 1}. [${c.propuesta.tipo.toUpperCase()}] ${c.propuesta.nombre}`);
+      lineas.push(`     Intención: "${c.intencion}" (${c.ocurrencias}×)`);
+      lineas.push(`     Motivo: ${c.propuesta.motivo}`);
+      lineas.push(`     Ejemplos:`);
+      for (const ej of c.ejemplos) {
+        lineas.push(`       • ${ej.replace(/\n/g, ' ')}`);
+      }
+      lineas.push('');
+    });
+  }
+  if (reporte.feedback.items > 0) {
+    lineas.push(`  Feedback del usuario capturado: ${reporte.feedback.items} entradas`);
+    for (const [tipo, n] of Object.entries(reporte.feedback.porTipo)) {
+      lineas.push(`    - ${tipo}: ${n}`);
+    }
+    lineas.push('  → Revisar con perfilador-usuario-swl y /swl:aprender.');
+  }
+  lineas.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  return lineas.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint CLI
+// ---------------------------------------------------------------------------
+
+function parseArgs(argv) {
+  const opts = { ventanaDias: VENTANA_DIAS_DEFAULT, umbral: UMBRAL_REPETICIONES, json: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--ventana' || a === '-v') opts.ventanaDias = parseInt(argv[++i], 10) || opts.ventanaDias;
+    else if (a === '--umbral' || a === '-u') opts.umbral = parseInt(argv[++i], 10) || opts.umbral;
+    else if (a === '--json') opts.json = true;
+  }
+  return opts;
+}
+
+function main() {
+  const opts = parseArgs(process.argv);
+  const cwd = process.cwd();
+  const ventanaMs = opts.ventanaDias * 24 * 60 * 60 * 1000;
+
+  const jsonls = localizarJsonlProyecto(cwd);
+  let todos = [];
+  for (const j of jsonls) {
+    const ps = extraerPrompts(j, ventanaMs);
+    todos = todos.concat(ps);
+  }
+
+  const clusters = clusterizarPrompts(todos);
+  const feedback = leerFeedbackQueue(cwd, ventanaMs);
+  const reporte  = armarReporte(clusters, feedback, {
+    ventanaDias: opts.ventanaDias,
+    umbral:      opts.umbral,
+    totalPrompts: todos.length,
+  });
+
+  // Guardar reporte estructurado
+  try {
+    const dir = path.join(cwd, '.planning', 'evolucion');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'reflect-skills-report.json'),
+      JSON.stringify(reporte, null, 2),
+      'utf8',
+    );
+  } catch (_) {}
+
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(reporte, null, 2) + '\n');
+  } else {
+    process.stdout.write(formatearReporteTexto(reporte) + '\n');
+  }
+  return reporte;
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  extraerPrompts,
+  clusterizarPrompts,
+  extraerIntencion,
+  tokenizar,
+  main,
+};