@saulwade/swl-ses 1.3.8 → 1.4.0

package/scripts/benchmark-memoria.js

@@ -1,167 +1,167 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * benchmark-memoria.js — CLI runner para benchmark de retrieval sobre memoria SWL.
- *
- * Ejecuta queries de un dataset JSONL contra `hooks/lib/memory-search`
- * (que usa RRF fusion sobre aprendizajes/sesiones/instintos) y reporta
- * métricas R@5, R@10, R@20, MRR, nDCG@10, P@5.
- *
- * Patrón adoptado de `temp/agentmemory-main/benchmark/longmemeval-bench.ts`.
- * Adaptado para swl-ses: file-based, sin embeddings ML, dataset SWL-específico.
- *
- * Uso:
- *   node scripts/benchmark-memoria.js [opciones]
- *
- * Opciones:
- *   --dataset <ruta>   Dataset JSONL (default: .planning/benchmark/dataset.jsonl)
- *   --limit <n>        Top-k a recuperar por query (default: 20)
- *   --json             Output en JSON (para scripts)
- *   --verbose          Detalle por query
- *
- * Exit codes:
- *   0 - OK
- *   1 - Error de I/O o dataset inválido
- *   2 - Argumentos inválidos
- *
- * Persistencia opcional: si se setea SWL_BENCHMARK_PERSIST=1, escribe
- * el resultado agregado a `.planning/evolucion/benchmark-memoria.jsonl`
- * para tracking histórico.
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const { ejecutarDataset } = require('./lib/longmemeval-runner');
-
-const DATASET_DEFAULT = '.planning/benchmark/dataset.jsonl';
-const HISTORICO_PATH  = '.planning/evolucion/benchmark-memoria.jsonl';
-
-function uso() {
-  console.error('Uso: node scripts/benchmark-memoria.js [--dataset <ruta>] [--limit <n>] [--json] [--verbose]');
-  process.exit(2);
-}
-
-function parseArgs(argv) {
-  const opts = {
-    dataset: DATASET_DEFAULT,
-    limit: 20,
-    json: false,
-    verbose: false,
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === '--dataset') opts.dataset = argv[++i];
-    else if (arg === '--limit') opts.limit = parseInt(argv[++i], 10) || 20;
-    else if (arg === '--json') opts.json = true;
-    else if (arg === '--verbose') opts.verbose = true;
-    else if (arg === '--help' || arg === '-h') uso();
-  }
-  return opts;
-}
-
-function persistirHistorico(baseDir, resumen) {
-  if (process.env.SWL_BENCHMARK_PERSIST !== '1') return;
-  try {
-    const dirEvolucion = path.join(baseDir, '.planning', 'evolucion');
-    if (!fs.existsSync(dirEvolucion)) fs.mkdirSync(dirEvolucion, { recursive: true });
-    const linea = JSON.stringify({
-      timestamp: new Date().toISOString(),
-      ...resumen,
-    });
-    fs.appendFileSync(path.join(baseDir, HISTORICO_PATH), linea + '\n', 'utf8');
-  } catch (_) {
-    // best-effort
-  }
-}
-
-function reportarTexto(resultado, opts) {
-  const { promedio, dataset, entries } = resultado;
-
-  console.log('================================================================');
-  console.log('   Benchmark de retrieval de memoria SWL');
-  console.log('================================================================');
-  console.log('');
-  console.log(`Dataset:      ${opts.dataset}`);
-  console.log(`Total queries: ${dataset.total}`);
-  console.log(`  Reales:      ${dataset.real}`);
-  console.log(`  Placeholder: ${dataset.placeholder}`);
-  console.log(`Significativo: ${dataset.significativo ? 'sí' : 'NO (requiere ≥30 reales)'}`);
-  console.log('');
-
-  if (!dataset.significativo) {
-    console.log('⚠ ADVERTENCIA: dataset con menos de 30 queries reales.');
-    console.log('  Las métricas son INDICATIVAS, no estadísticamente significativas.');
-    console.log('  Para usar como gate de release, expandir el dataset con preguntas');
-    console.log('  curadas extraídas de uso real (ver SKILL.md de benchmark-memoria).');
-    console.log('');
-  }
-
-  console.log('────────────── Métricas agregadas ──────────────');
-  console.log(`  Recall @ 5:     ${(promedio.recall_at_5 * 100).toFixed(1)}%`);
-  console.log(`  Recall @ 10:    ${(promedio.recall_at_10 * 100).toFixed(1)}%`);
-  console.log(`  Recall @ 20:    ${(promedio.recall_at_20 * 100).toFixed(1)}%`);
-  console.log(`  MRR:            ${promedio.mrr.toFixed(3)}`);
-  console.log(`  nDCG @ 10:      ${promedio.ndcg_at_10.toFixed(3)}`);
-  console.log(`  Precision @ 5:  ${(promedio.precision_at_5 * 100).toFixed(1)}%`);
-  console.log('');
-
-  if (opts.verbose) {
-    console.log('────────────── Detalle por query ──────────────');
-    for (const r of entries) {
-      const mark = r.metricas.recall_at_5 > 0 ? '✓' : '✗';
-      console.log(`  ${mark} ${r.question_id} [${r.category || 'n/a'}, ${r.status}] ` +
-        `R@5=${r.metricas.recall_at_5} R@10=${r.metricas.recall_at_10} ` +
-        `MRR=${r.metricas.mrr.toFixed(2)} (${r.latencyMs}ms)`);
-      if (r.metricas.recall_at_5 === 0 && opts.verbose) {
-        console.log(`      Q: ${r.question.slice(0, 80)}`);
-        console.log(`      Gold:      ${r.goldIds.slice(0, 3).join(', ')}${r.goldIds.length > 3 ? '...' : ''}`);
-        console.log(`      Retrieved: ${r.retrievedIds.slice(0, 5).join(', ')}`);
-      }
-    }
-    console.log('');
-  }
-}
-
-function main() {
-  const opts = parseArgs(process.argv.slice(2));
-  const baseDir = process.cwd();
-
-  if (!fs.existsSync(opts.dataset)) {
-    console.error(`Dataset no encontrado: ${opts.dataset}`);
-    console.error(`Crea uno o usa el placeholder en ${DATASET_DEFAULT}.`);
-    process.exit(1);
-  }
-
-  let resultado;
-  try {
-    resultado = ejecutarDataset(baseDir, opts.dataset, { limit: opts.limit });
-  } catch (err) {
-    console.error(`Error ejecutando benchmark: ${err.message}`);
-    process.exit(1);
-  }
-
-  if (opts.json) {
-    console.log(JSON.stringify(resultado, null, 2));
-  } else {
-    reportarTexto(resultado, opts);
-  }
-
-  persistirHistorico(baseDir, {
-    dataset: opts.dataset,
-    n: resultado.dataset.total,
-    significativo: resultado.dataset.significativo,
-    promedio: resultado.promedio,
-  });
-
-  process.exit(0);
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  parseArgs,
-};
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * benchmark-memoria.js — CLI runner para benchmark de retrieval sobre memoria SWL.
+ *
+ * Ejecuta queries de un dataset JSONL contra `hooks/lib/memory-search`
+ * (que usa RRF fusion sobre aprendizajes/sesiones/instintos) y reporta
+ * métricas R@5, R@10, R@20, MRR, nDCG@10, P@5.
+ *
+ * Patrón adoptado de `temp/agentmemory-main/benchmark/longmemeval-bench.ts`.
+ * Adaptado para swl-ses: file-based, sin embeddings ML, dataset SWL-específico.
+ *
+ * Uso:
+ *   node scripts/benchmark-memoria.js [opciones]
+ *
+ * Opciones:
+ *   --dataset <ruta>   Dataset JSONL (default: .planning/benchmark/dataset.jsonl)
+ *   --limit <n>        Top-k a recuperar por query (default: 20)
+ *   --json             Output en JSON (para scripts)
+ *   --verbose          Detalle por query
+ *
+ * Exit codes:
+ *   0 - OK
+ *   1 - Error de I/O o dataset inválido
+ *   2 - Argumentos inválidos
+ *
+ * Persistencia opcional: si se setea SWL_BENCHMARK_PERSIST=1, escribe
+ * el resultado agregado a `.planning/evolucion/benchmark-memoria.jsonl`
+ * para tracking histórico.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { ejecutarDataset } = require('./lib/longmemeval-runner');
+
+const DATASET_DEFAULT = '.planning/benchmark/dataset.jsonl';
+const HISTORICO_PATH  = '.planning/evolucion/benchmark-memoria.jsonl';
+
+function uso() {
+  console.error('Uso: node scripts/benchmark-memoria.js [--dataset <ruta>] [--limit <n>] [--json] [--verbose]');
+  process.exit(2);
+}
+
+function parseArgs(argv) {
+  const opts = {
+    dataset: DATASET_DEFAULT,
+    limit: 20,
+    json: false,
+    verbose: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--dataset') opts.dataset = argv[++i];
+    else if (arg === '--limit') opts.limit = parseInt(argv[++i], 10) || 20;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '--verbose') opts.verbose = true;
+    else if (arg === '--help' || arg === '-h') uso();
+  }
+  return opts;
+}
+
+function persistirHistorico(baseDir, resumen) {
+  if (process.env.SWL_BENCHMARK_PERSIST !== '1') return;
+  try {
+    const dirEvolucion = path.join(baseDir, '.planning', 'evolucion');
+    if (!fs.existsSync(dirEvolucion)) fs.mkdirSync(dirEvolucion, { recursive: true });
+    const linea = JSON.stringify({
+      timestamp: new Date().toISOString(),
+      ...resumen,
+    });
+    fs.appendFileSync(path.join(baseDir, HISTORICO_PATH), linea + '\n', 'utf8');
+  } catch (_) {
+    // best-effort
+  }
+}
+
+function reportarTexto(resultado, opts) {
+  const { promedio, dataset, entries } = resultado;
+
+  console.log('================================================================');
+  console.log('   Benchmark de retrieval de memoria SWL');
+  console.log('================================================================');
+  console.log('');
+  console.log(`Dataset:      ${opts.dataset}`);
+  console.log(`Total queries: ${dataset.total}`);
+  console.log(`  Reales:      ${dataset.real}`);
+  console.log(`  Placeholder: ${dataset.placeholder}`);
+  console.log(`Significativo: ${dataset.significativo ? 'sí' : 'NO (requiere ≥30 reales)'}`);
+  console.log('');
+
+  if (!dataset.significativo) {
+    console.log('⚠ ADVERTENCIA: dataset con menos de 30 queries reales.');
+    console.log('  Las métricas son INDICATIVAS, no estadísticamente significativas.');
+    console.log('  Para usar como gate de release, expandir el dataset con preguntas');
+    console.log('  curadas extraídas de uso real (ver SKILL.md de benchmark-memoria).');
+    console.log('');
+  }
+
+  console.log('────────────── Métricas agregadas ──────────────');
+  console.log(`  Recall @ 5:     ${(promedio.recall_at_5 * 100).toFixed(1)}%`);
+  console.log(`  Recall @ 10:    ${(promedio.recall_at_10 * 100).toFixed(1)}%`);
+  console.log(`  Recall @ 20:    ${(promedio.recall_at_20 * 100).toFixed(1)}%`);
+  console.log(`  MRR:            ${promedio.mrr.toFixed(3)}`);
+  console.log(`  nDCG @ 10:      ${promedio.ndcg_at_10.toFixed(3)}`);
+  console.log(`  Precision @ 5:  ${(promedio.precision_at_5 * 100).toFixed(1)}%`);
+  console.log('');
+
+  if (opts.verbose) {
+    console.log('────────────── Detalle por query ──────────────');
+    for (const r of entries) {
+      const mark = r.metricas.recall_at_5 > 0 ? '✓' : '✗';
+      console.log(`  ${mark} ${r.question_id} [${r.category || 'n/a'}, ${r.status}] ` +
+        `R@5=${r.metricas.recall_at_5} R@10=${r.metricas.recall_at_10} ` +
+        `MRR=${r.metricas.mrr.toFixed(2)} (${r.latencyMs}ms)`);
+      if (r.metricas.recall_at_5 === 0 && opts.verbose) {
+        console.log(`      Q: ${r.question.slice(0, 80)}`);
+        console.log(`      Gold:      ${r.goldIds.slice(0, 3).join(', ')}${r.goldIds.length > 3 ? '...' : ''}`);
+        console.log(`      Retrieved: ${r.retrievedIds.slice(0, 5).join(', ')}`);
+      }
+    }
+    console.log('');
+  }
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  const baseDir = process.cwd();
+
+  if (!fs.existsSync(opts.dataset)) {
+    console.error(`Dataset no encontrado: ${opts.dataset}`);
+    console.error(`Crea uno o usa el placeholder en ${DATASET_DEFAULT}.`);
+    process.exit(1);
+  }
+
+  let resultado;
+  try {
+    resultado = ejecutarDataset(baseDir, opts.dataset, { limit: opts.limit });
+  } catch (err) {
+    console.error(`Error ejecutando benchmark: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    console.log(JSON.stringify(resultado, null, 2));
+  } else {
+    reportarTexto(resultado, opts);
+  }
+
+  persistirHistorico(baseDir, {
+    dataset: opts.dataset,
+    n: resultado.dataset.total,
+    significativo: resultado.dataset.significativo,
+    promedio: resultado.promedio,
+  });
+
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parseArgs,
+};

package/scripts/comandos/skills.js

@@ -1,8 +1,13 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
 const { listarComponentes, agregarComponente } = require('../lib/gestor-componentes');
 const { descubrirSkills, limpiarDescubrimiento } = require('../lib/resolver-externo');
 const { selectorCheckbox, mostrarBanner, mostrarInfoFuente } = require('../lib/selector-interactivo');
+const { atomicWriteJSON } = require('../../hooks/lib/atomic-write');
 
 const AYUDA = `
 swl-ses skills — Gestión de skills
@@ -13,16 +18,30 @@ USO:
 SUBCOMANDOS:
   list                          Lista skills instalados
   add <fuente> [--skill <n>]    Agrega skill desde repo Git o path local
+  auto                          Auto-detecta stack e instala skills oficiales
+                                de comunidad (envuelve "npx autoskills" con
+                                "-a claude-code" por default para evitar
+                                duplicar en .agents/skills/)
   remove <nombre>               Remueve un skill
 
-OPCIONES:
+OPCIONES (add):
   --target <runtime>    Runtime destino (default: claude)
   --skill <nombre>      Nombre del skill a instalar directamente (sin selector)
   --global              Operar en directorio global
   --force               Sobreescribir sin confirmar
   --all                 Instalar todos los skills sin preguntar
 
-FUENTES SOPORTADAS:
+OPCIONES (auto):
+  --dry-run             Solo mostrar qué se instalaría (no instala)
+  -y, --yes             Sin confirmación interactiva
+  --runtimes <csv>      Lista de runtimes destino (default: claude-code).
+                        Ejemplos: claude-code,cursor,codex,opencode,gemini-cli
+  --clean-agents        Eliminar .agents/skills/ residual tras instalar
+                        (útil si se ejecutó "npx autoskills" sin flag antes
+                         y solo se usa Claude Code en este proyecto)
+  --verbose             Mostrar output completo de autoskills
+
+FUENTES SOPORTADAS (add):
   owner/repo                    GitHub shorthand
   github:user/repo              GitHub con prefijo
   https://github.com/user/repo  URL completa
@@ -34,6 +53,11 @@ EJEMPLOS:
   swl-ses skills add anthropics/skills --skill docx
   swl-ses skills add https://github.com/user/repo --all
   swl-ses skills add ./path/local/mi-skill
+  swl-ses skills auto                          # Auto-detectar y instalar
+  swl-ses skills auto --dry-run                # Solo ver qué instalaría
+  swl-ses skills auto -y                       # Sin confirmación
+  swl-ses skills auto --runtimes claude-code,cursor   # Multi-runtime
+  swl-ses skills auto --clean-agents           # Instalar + limpiar residuos
   swl-ses skills remove mi-skill
 `;
 
@@ -75,6 +99,11 @@ async function skills(subcomando, opciones) {
       break;
     }
 
+    case 'auto': {
+      await ejecutarAuto(opciones);
+      break;
+    }
+
     case 'remove': {
       const nombre = opciones._args && opciones._args[0];
       if (!nombre) {
@@ -208,4 +237,224 @@ function mostrarResultadoInstalacion(resultado) {
   console.log('');
 }
 
+// ---------------------------------------------------------------------------
+// `skills auto` — wrapper de npx autoskills con default Claude Code-only
+// ---------------------------------------------------------------------------
+
+/**
+ * Construye los argumentos para `npx autoskills` a partir de las opciones
+ * del subcomando `skills auto`. Default fuerza `-a claude-code` para evitar
+ * duplicación en .agents/skills/ cuando el proyecto solo usa Claude Code.
+ *
+ * @param {object} opciones
+ * @returns {string[]} argv para npx
+ */
+function construirArgsAutoskills(opciones) {
+  const args = ['autoskills'];
+
+  if (opciones['dry-run']) args.push('--dry-run');
+  if (opciones.yes || opciones.y) args.push('-y');
+  if (opciones.verbose) args.push('-v');
+
+  // Distinguir "no especificó --runtimes" (usar default) de "--runtimes ''"
+  // (uso explícito inválido — lanza error).
+  const especificado = Object.prototype.hasOwnProperty.call(opciones, 'runtimes');
+  const runtimesRaw = especificado ? opciones.runtimes : 'claude-code';
+  const runtimes = String(runtimesRaw)
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+
+  if (runtimes.length === 0) {
+    throw new Error('--runtimes no puede estar vacío');
+  }
+
+  args.push('-a', ...runtimes);
+  return args;
+}
+
+/**
+ * Captura un snapshot de los directorios de skills (.claude/skills/ y
+ * .agents/skills/) para mostrar el delta tras la instalación.
+ */
+function snapshotSkills(cwd) {
+  const recolectar = (dir) => {
+    try {
+      if (!fs.existsSync(dir)) return [];
+      return fs.readdirSync(dir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name)
+        .sort();
+    } catch (_) {
+      return [];
+    }
+  };
+  return {
+    claude: recolectar(path.join(cwd, '.claude', 'skills')),
+    agents: recolectar(path.join(cwd, '.agents', 'skills')),
+  };
+}
+
+function delta(antes, despues) {
+  const set = new Set(antes);
+  return despues.filter(n => !set.has(n));
+}
+
+/**
+ * Path del marker que indica que `skills auto` se ejecutó. El hook
+ * inyeccion-contexto.js revisa este archivo para evitar sugerir la
+ * instalación cuando ya se hizo.
+ */
+function rutaMarkerAutoskills(cwd) {
+  return path.join(cwd, '.claude', 'skills', '.autoskills-installed.json');
+}
+
+function escribirMarkerAutoskills(cwd, datos) {
+  const ruta = rutaMarkerAutoskills(cwd);
+  // Crear el directorio padre primero — atomicWriteJSON espera que exista.
+  // Usar atomicWriteJSON de hooks/lib/atomic-write.js (CLAUDE.md: "Escrituras
+  // atómicas obligatorias [...] NUNCA fs.writeFileSync directo en archivos
+  // del sistema"). El marker es archivo del sistema porque hooks/inyeccion-
+  // contexto.js lo lee como señal canónica.
+  fs.mkdirSync(path.dirname(ruta), { recursive: true });
+  atomicWriteJSON(ruta, datos, 2);
+}
+
+function leerMarkerAutoskills(cwd) {
+  try {
+    const ruta = rutaMarkerAutoskills(cwd);
+    if (!fs.existsSync(ruta)) return null;
+    return JSON.parse(fs.readFileSync(ruta, 'utf8'));
+  } catch (_) {
+    return null;
+  }
+}
+
+function leerVersionCli() {
+  try {
+    return require('../../package.json').version;
+  } catch (_) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Elimina .agents/skills/ si existe. La carpeta es huérfana cuando el
+ * proyecto solo usa Claude Code y autoskills la creó por defecto sin el
+ * flag -a claude-code.
+ */
+function limpiarAgentsSkills(cwd) {
+  const dir = path.join(cwd, '.agents', 'skills');
+  if (!fs.existsSync(dir)) return { eliminado: false, razon: 'no existe' };
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+    // Si .agents/ quedó vacío, eliminar también el padre
+    const padre = path.join(cwd, '.agents');
+    if (fs.existsSync(padre) && fs.readdirSync(padre).length === 0) {
+      fs.rmdirSync(padre);
+    }
+    return { eliminado: true };
+  } catch (err) {
+    return { eliminado: false, razon: err.message };
+  }
+}
+
+async function ejecutarAuto(opciones) {
+  const cwd = process.cwd();
+  let args;
+
+  try {
+    args = construirArgsAutoskills(opciones);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+
+  console.log('\n  \x1b[36m›\x1b[0m swl-ses skills auto');
+  console.log(`  Comando: npx ${args.join(' ')}`);
+  console.log('');
+
+  const antes = snapshotSkills(cwd);
+
+  // Ejecutar autoskills heredando stdio para preservar interactividad
+  const result = spawnSync('npx', ['-y', ...args], {
+    cwd,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  if (result.error) {
+    console.error(`\n  Error al ejecutar npx autoskills: ${result.error.message}`);
+    console.error('  Verifica que tienes Node.js y npm instalados.');
+    process.exit(1);
+  }
+
+  if (result.status !== 0) {
+    console.error(`\n  autoskills termino con codigo ${result.status}`);
+    process.exit(result.status || 1);
+  }
+
+  // Si fue dry-run, no hay cambios reales para reportar
+  if (opciones['dry-run']) {
+    console.log('\n  (dry-run: no se instaló nada)\n');
+    return;
+  }
+
+  const despues = snapshotSkills(cwd);
+  const nuevosClaude = delta(antes.claude, despues.claude);
+  const nuevosAgents = delta(antes.agents, despues.agents);
+
+  console.log('\n  \x1b[36m›\x1b[0m Reporte post-instalación:');
+  console.log(`  .claude/skills/: ${despues.claude.length} skills (${nuevosClaude.length} nuevos)`);
+  if (nuevosClaude.length > 0) {
+    for (const n of nuevosClaude) console.log(`    + ${n}`);
+  }
+  if (despues.agents.length > 0) {
+    console.log(`  .agents/skills/: ${despues.agents.length} skills (${nuevosAgents.length} nuevos)`);
+    if (nuevosAgents.length > 0) {
+      for (const n of nuevosAgents) console.log(`    + ${n}`);
+    }
+  }
+
+  // Escribir marker para que hooks/inyeccion-contexto.js detecte que
+  // los skills de comunidad ya están instalados. Sin este marker el
+  // hook seguiría sugiriendo `skills auto` aunque ya se haya ejecutado
+  // (no puede distinguir skills SWL de skills de comunidad en .claude/skills/).
+  try {
+    escribirMarkerAutoskills(cwd, {
+      installed_at: new Date().toISOString(),
+      runtimes: (opciones.runtimes || 'claude-code').split(',').map(s => s.trim()).filter(Boolean),
+      skills_claude: despues.claude,
+      skills_agents: despues.agents,
+      cli_version: leerVersionCli(),
+    });
+  } catch (err) {
+    console.log(`\n  (advertencia: no se pudo escribir marker autoskills: ${err.message})`);
+  }
+
+  // Limpieza opcional de .agents/skills/
+  if (opciones['clean-agents']) {
+    const res = limpiarAgentsSkills(cwd);
+    if (res.eliminado) {
+      console.log('\n  \x1b[32m✓\x1b[0m .agents/skills/ eliminado (Claude Code-only).');
+    } else {
+      console.log(`\n  (--clean-agents: ${res.razon})`);
+    }
+  } else if (despues.agents.length > 0) {
+    const runtimes = (opciones.runtimes || 'claude-code').split(',').map(s => s.trim());
+    if (runtimes.length === 1 && runtimes[0] === 'claude-code') {
+      console.log('\n  \x1b[33m!\x1b[0m .agents/skills/ tiene contenido pero el proyecto usa solo Claude Code.');
+      console.log('    Considera ejecutar de nuevo con --clean-agents para limpiarlo.');
+    }
+  }
+
+  console.log('');
+}
+
 module.exports = skills;
+module.exports.construirArgsAutoskills = construirArgsAutoskills;
+module.exports.snapshotSkills = snapshotSkills;
+module.exports.delta = delta;
+module.exports.rutaMarkerAutoskills = rutaMarkerAutoskills;
+module.exports.leerMarkerAutoskills = leerMarkerAutoskills;
+module.exports.escribirMarkerAutoskills = escribirMarkerAutoskills;