@saulwade/swl-ses 2.5.2 → 2.6.0

package/scripts/cli/ciclo-fase-b.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses ciclo-fase-b [status] [--dry-run]` — CLI headless de la
+ * Fase B del ciclo autónomo (Fase 22, T-07, ADR-0042 gate G-B, REQ-22-07).
+ *
+ * Espeja el patrón de `scripts/cli/ciclo-autonomo.js` (contrato del bin: cada
+ * subcomando exporta UNA función(opciones) sin efectos al require).
+ *
+ *   (nada) | --dry-run → corre `runner-fase-b.correrFaseB` con `dryRun:true`
+ *     SIEMPRE, se pase o no el flag. En Fase 22 el runner NUNCA invoca LLM ni
+ *     gasta bajo ninguna combinación de argumentos — el modo real
+ *     (`dryRun:false` + `invocador` cableado) llega en Fase 24; hasta
+ *     entonces `--dry-run` es un no-op explícito frente al default.
+ *   status → reporta `fase_b_habilitada`, `last_run_fase_b`, candidatos
+ *     pendientes (conteo tolerante de `evolution/candidatos-fase-b.jsonl` —
+ *     NUNCA `candidatos.detectar`, que tiene efecto de escritura; `status`
+ *     jamás muta disco) y el estado de presupuesto (`gasto_mes`,
+ *     `presupuesto_usd_mes`, `pausado_por_presupuesto`) vía
+ *     `presupuesto.estado`.
+ *
+ * Uso: swl-ses ciclo-fase-b [status] [--dry-run]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { correrFaseB } = require('../lib/ciclo-autonomo/runner-fase-b');
+const config = require('../lib/ciclo-autonomo/config');
+const presupuesto = require('../lib/ciclo-autonomo/presupuesto');
+
+const RUTA_CANDIDATOS_RELATIVA = path.join('.planning', 'evolution', 'candidatos-fase-b.jsonl');
+
+/**
+ * Conteo tolerante de líneas JSON válidas en `candidatos-fase-b.jsonl`.
+ * `status` es de solo lectura: nunca invoca `candidatos.detectar` (que
+ * persiste candidatos nuevos) — solo cuenta lo que YA quedó registrado por
+ * una corrida previa de la Fase A o del runner.
+ *
+ * @param {string} baseDir - Directorio raíz del proyecto.
+ * @returns {number}
+ */
+function contarCandidatosPendientes(baseDir) {
+  let crudo;
+  try {
+    crudo = fs.readFileSync(path.join(baseDir, RUTA_CANDIDATOS_RELATIVA), 'utf8');
+  } catch (_) {
+    return 0;
+  }
+  return crudo.split(/\r\n|\n/)
+    .filter((linea) => linea.trim() !== '')
+    .filter((linea) => {
+      try {
+        JSON.parse(linea);
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }).length;
+}
+
+function cicloFaseB(opciones = {}) {
+  const accion = (opciones._args || [])[0];
+  const baseDir = opciones.dir || process.cwd();
+
+  if (accion === 'status') {
+    const cfg = config.leerConfig(baseDir);
+    const presu = presupuesto.estado(baseDir);
+    const estado = {
+      fase_b_habilitada: config.estaFaseBHabilitada(baseDir),
+      last_run_fase_b: cfg.last_run_fase_b,
+      candidatos_pendientes: contarCandidatosPendientes(baseDir),
+      gasto_mes: presu.gasto_mes,
+      presupuesto_usd_mes: presu.tope,
+      pausado_por_presupuesto: presu.pausado_por_presupuesto,
+    };
+    console.log(`[ciclo-fase-b] fase_b_habilitada: ${estado.fase_b_habilitada}`);
+    console.log(`[ciclo-fase-b] last_run_fase_b: ${estado.last_run_fase_b || 'nunca'}`);
+    console.log(`[ciclo-fase-b] candidatos_pendientes: ${estado.candidatos_pendientes}`);
+    console.log(`[ciclo-fase-b] gasto_mes: $${estado.gasto_mes} / $${estado.presupuesto_usd_mes} · pausado_por_presupuesto: ${estado.pausado_por_presupuesto}`);
+    return estado;
+  }
+
+  if (accion !== undefined && accion !== '--dry-run') {
+    console.error(`[ciclo-fase-b] acción desconocida: "${accion}". Uso: swl-ses ciclo-fase-b [status] [--dry-run]`);
+    process.exitCode = 1;
+    return null;
+  }
+
+  // Fase 22: dryRun forzado a true sin importar el flag — el runner valida
+  // toda la tubería (lock, catch-up, guard, credencial, presupuesto) y
+  // registra la corrida SIN invocar LLM. El modo real llega en Fase 24.
+  const resultado = correrFaseB(baseDir, { dryRun: true });
+  if (!resultado.ejecutado) {
+    console.log(`[ciclo-fase-b] sin corrida: ${resultado.razon}`);
+  } else {
+    console.log(`[ciclo-fase-b] corrida dry-run completada — candidatos: ${resultado.candidatos}`);
+  }
+  return resultado;
+}
+
+module.exports = cicloFaseB;

package/scripts/cli/guardrail-metrics.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses guardrail-metrics` — métricas y diagnóstico de los
+ * guardrails de la sesión (bridge en tmpdir por sessionId). Reemplaza el
+ * `node -e "require('./hooks/lib/guardrail-metrics')..."` relativo al
+ * proyecto que swl-dashboard instruía — roto downstream (ver
+ * docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso: swl-ses guardrail-metrics [--session=ID] [--json]
+ *   --session  default: env CLAUDE_SESSION_ID o "default"
+ *   --json     imprime {metricas, advertencias} crudo
+ */
+
+const { getMetrics, formatearResumen, diagnosticar } = require('../../hooks/lib/guardrail-metrics');
+
+function guardrailMetrics(opciones = {}) {
+  const sessionId = (opciones.session != null && opciones.session !== true)
+    ? String(opciones.session)
+    : (process.env.CLAUDE_SESSION_ID || 'default');
+
+  const metricas = getMetrics(sessionId);
+  const advertencias = diagnosticar(metricas);
+
+  if (opciones.json) {
+    console.log(JSON.stringify({ metricas, advertencias }, null, 2));
+    return;
+  }
+
+  console.log(formatearResumen(metricas));
+  if (advertencias.length > 0) {
+    console.log('\n⚠ Diagnóstico:');
+    for (const a of advertencias) console.log('  - ' + a);
+  } else {
+    console.log('\n✓ Guardrails sin anomalías detectadas.');
+  }
+}
+
+module.exports = guardrailMetrics;

package/scripts/cli/loop-telemetry.js

@@ -16,6 +16,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const lt = require('../../hooks/lib/loop-telemetry');
+const { raizProyecto } = require('../../hooks/lib/raiz-proyecto');
 
 // Parseo no degradante: si el flag está presente pero su JSON es inválido,
 // reporta y devuelve {ok:false} en vez de silenciar a fallback (anti-fallback
@@ -89,8 +90,9 @@ function loopTelemetry(opciones = {}) {
     return;
   }
 
-  // listar (default)
-  const base = path.join(process.cwd(), lt.DIR_LOOPS);
+  // listar (default) — misma ancla que iniciar/registrar (raíz del proyecto),
+  // o listaría un .planning/loops/ distinto al que las corridas escriben.
+  const base = path.join(raizProyecto(process.cwd()), lt.DIR_LOOPS);
   let dirs = [];
   try {
     dirs = fs

package/scripts/cli/memoria-search.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses memoria-search <op>` — búsqueda en la memoria del
+ * proyecto (.planning/sessions/, APRENDIZAJES.md, diary). Reemplaza los
+ * `require('./hooks/lib/memory-search')` relativos al proyecto que
+ * memoria-busqueda y benchmark-memoria instruían — rotos downstream (ver
+ * docs/invocacion-cli-cross-scope.md).
+ *
+ * Ops:
+ *   search   --query="..." [--limit=N] [--tipo=aprendizaje|sesion|instinto]
+ *            [--desde=YYYY-MM-DD] [--hasta=YYYY-MM-DD]   (default)
+ *   timeline --ids=id1,id2,...
+ *   fetch    --id=<id>
+ *
+ * Salida: JSON a stdout. La base es la RAÍZ del proyecto (raizProyecto),
+ * no el cwd crudo — misma semántica que los hooks (DT-HOOKS-RAIZ-GIT).
+ */
+
+const ms = require('../../hooks/lib/memory-search');
+const { raizProyecto } = require('../../hooks/lib/raiz-proyecto');
+
+function memoriaSearch(opciones = {}) {
+  const op = (opciones._args && opciones._args[0]) || 'search';
+  const base = raizProyecto(process.cwd());
+
+  if (op === 'search') {
+    const query = opciones.query != null && opciones.query !== true ? String(opciones.query) : '';
+    if (!query) {
+      console.error('Error: falta --query="<términos>"');
+      process.exitCode = 1;
+      return;
+    }
+    const filtros = {};
+    const limit = parseInt(opciones.limit, 10);
+    if (!isNaN(limit) && limit > 0) filtros.limit = limit;
+    if (opciones.tipo != null && opciones.tipo !== true) filtros.tipo = String(opciones.tipo);
+    if (opciones.desde != null && opciones.desde !== true) filtros.fecha_desde = String(opciones.desde);
+    if (opciones.hasta != null && opciones.hasta !== true) filtros.fecha_hasta = String(opciones.hasta);
+    console.log(JSON.stringify(ms.search(base, query, filtros), null, 2));
+    return;
+  }
+
+  if (op === 'timeline') {
+    const ids = String(opciones.ids || '').split(',').map(s => s.trim()).filter(Boolean);
+    if (ids.length === 0) {
+      console.error('Error: falta --ids=id1,id2,...');
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(ms.timeline(base, ids), null, 2));
+    return;
+  }
+
+  if (op === 'fetch') {
+    if (opciones.id == null || opciones.id === true) {
+      console.error('Error: falta --id=<id>');
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(ms.fetch(base, String(opciones.id)), null, 2));
+    return;
+  }
+
+  console.error(`Error: op desconocida "${op}" (usa search|timeline|fetch)`);
+  process.exitCode = 1;
+}
+
+module.exports = memoriaSearch;

package/scripts/cli/nudge-accionar.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Subcomando `swl-ses nudge-accionar <id> --por <consumidor>` — cierra el
+ * ciclo de un nudge (T-09, Fase 21 / ADR-0041).
+ *
+ * Lo invocan los comandos /swl:aprender y /swl:evolucionar (y el agente
+ * auto-evolucion-swl) tras atender la sugerencia de un nudge, para que
+ * `evolution/nudges.jsonl` registre quién lo accionó. Sin este cierre los
+ * nudges se acumulan sin consumidor (174 emitidos / 0 accionados al crear
+ * la Fase 21).
+ *
+ * Uso: swl-ses nudge-accionar <id> [--por <consumidor>]
+ */
+
+const { marcarAccionado } = require('../lib/ciclo-autonomo/higiene-nudges');
+
+function nudgeAccionar(opciones = {}) {
+  const id = (opciones._args || [])[0];
+  const baseDir = opciones.dir || process.cwd();
+
+  if (!id) {
+    console.error('[nudge-accionar] falta el id. Uso: swl-ses nudge-accionar <id> [--por <consumidor>]');
+    process.exitCode = 1;
+    return null;
+  }
+
+  const por = opciones.por || opciones.by || 'desconocido';
+  const resultado = marcarAccionado(baseDir, { id, por });
+
+  if (resultado.marcados === 0) {
+    console.error(`[nudge-accionar] nudge "${id}" no encontrado o ya accionado`);
+  } else {
+    console.log(`[nudge-accionar] nudge "${id}" marcado como accionado por "${por}"`);
+  }
+  return resultado;
+}
+
+module.exports = nudgeAccionar;

package/scripts/cli/run-eval.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Wrapper CLI `swl-ses run-eval` — ejecuta un eval del framework de validación
+ * de outputs estructurados (scripts/run-eval.js). Reemplaza el
+ * `node scripts/run-eval.js` relativo al proyecto que eval-framework
+ * instruía — roto downstream (ver docs/invocacion-cli-cross-scope.md).
+ *
+ * Uso:
+ *   swl-ses run-eval <ruta-eval.json>
+ *   swl-ses run-eval --rebuild-aggregate
+ *
+ * ADVERTENCIA (nemesis iter-1 S3-6): el main() envuelto llama process.exit()
+ * en todas sus ramas — este wrapper TERMINA el proceso host. Correcto vía
+ * `bin/swl-ses.js` (proceso fresco por invocación); NO invocar in-process
+ * (batch runners, tests que compongan varios wrappers) o matará el proceso.
+ */
+
+const { main } = require('../run-eval.js');
+
+function runEval(opciones = {}) {
+  const args = [];
+  if (opciones['rebuild-aggregate'] || opciones.rebuild_aggregate) {
+    args.push('--rebuild-aggregate');
+  } else if (opciones._args && opciones._args[0]) {
+    args.push(String(opciones._args[0]));
+  }
+
+  const argvOriginal = process.argv;
+  process.argv = ['node', 'run-eval.js', ...args];
+  try {
+    main();
+  } finally {
+    process.argv = argvOriginal;
+  }
+}
+
+module.exports = runEval;

package/scripts/cli/run-skill-evals.js

@@ -11,10 +11,17 @@
  *   --list                 → listar evals del skill
  *   --json                 → output JSON
  *   --record-baseline      → registrar score baseline
- *   --record-after         → registrar score post-cambio
- *   --score=<N>            → score numérico (acompaña --record-*)
+ *   --record-after         → registrar score post-cambio (el score se LEE del
+ *                            artefacto de evaluación con procedencia — ver abajo)
+ *   --score=<N>            → score numérico (baseline/revert; en record-after
+ *                            solo como verificación de coincidencia)
  *   --hypothesis=<texto>   → hipótesis de la mutación
  *   --invariantes-ok       → marcar invariantes como OK
+ *   --emitir-evaluacion    → escribir artefacto de procedencia (lo invoca
+ *                            /swl:evaluar-skill; exige --score y --producido-por)
+ *   --producido-por=<a>    → actor que corrió la evaluación (≠ target)
+ *   --badge=<b>            → badge asignado (opcional, acompaña emitir)
+ *   --evaluacion=<path>    → override del path del artefacto en record-after
  */
 
 const path = require('path');
@@ -32,6 +39,10 @@ function runSkillEvals(opciones) {
   if (opciones && opciones.score !== undefined) args.push(`--score=${opciones.score}`);
   if (opciones && opciones.hypothesis) args.push(`--hypothesis=${opciones.hypothesis}`);
   if (opciones && opciones['invariantes-ok']) args.push('--invariantes-ok');
+  if (opciones && opciones['emitir-evaluacion']) args.push('--emitir-evaluacion');
+  if (opciones && opciones['producido-por']) args.push(`--producido-por=${opciones['producido-por']}`);
+  if (opciones && opciones.badge) args.push(`--badge=${opciones.badge}`);
+  if (opciones && opciones.evaluacion) args.push(`--evaluacion=${opciones.evaluacion}`);
 
   const argvOriginal = process.argv;
   process.argv = ['node', 'run-skill-evals.js', ...args];

package/scripts/derivar-feature-list.js

@@ -102,22 +102,23 @@ function parsearTablaResumen(contenido, fases) {
 
     const celdas = trim.split('|').map(c => c.trim()).filter(c => c !== '');
 
-    // Detectar header
-    if (idxFase === -1) {
-      const lowered = celdas.map(c => c.toLowerCase());
-      const fa = lowered.findIndex(c => c === 'fase' || c === 'phase' || c === '#');
-      const no = lowered.findIndex(c => c === 'nombre' || c === 'name');
-      const ob = lowered.findIndex(c => c === 'objetivo' || c === 'objective');
-      const es = lowered.findIndex(c => c === 'estado' || c === 'status');
-      if (fa !== -1 && no !== -1 && es !== -1) {
-        idxFase = fa;
-        idxNombre = no;
-        idxObjetivo = ob;
-        idxEstado = es;
-        enTabla = true;
-      }
+    // Detectar header — en CADA línea de tabla, no solo en la primera del
+    // archivo: el HOJA-RUTA real acumula varias tablas de fase (una por
+    // iniciativa) y fijar los índices de la primera ignoraba las demás en
+    // silencio (--check daba verde con fases ausentes del JSON).
+    const lowered = celdas.map(c => c.toLowerCase());
+    const fa = lowered.findIndex(c => c === 'fase' || c === 'phase' || c === '#');
+    const no = lowered.findIndex(c => c === 'nombre' || c === 'name');
+    const es = lowered.findIndex(c => c === 'estado' || c === 'status');
+    if (fa !== -1 && no !== -1 && es !== -1) {
+      idxFase = fa;
+      idxNombre = no;
+      idxObjetivo = lowered.findIndex(c => c === 'objetivo' || c === 'objective');
+      idxEstado = es;
+      enTabla = true;
       continue;
     }
+    if (idxFase === -1) continue;
 
     // Línea separadora (|---|---|)
     if (celdas.every(c => /^-+$/.test(c.replace(/:/g, '')))) continue;

package/scripts/desinstalar.js

@@ -140,6 +140,17 @@ function uninstall(opciones) {
         `  - ${archivo.destino}`
       );
       eliminados++;
+      // Subdirectorios creados por el instalador (hooks/lib/, rules/<lang>/)
+      // quedan vacíos tras borrar sus archivos: rmdir no-recursivo — solo
+      // cae si el dir quedó realmente vacío; cualquier contenido del usuario
+      // lo preserva (ENOTEMPTY ignorado). Acotado a rutas.base: un
+      // install-state manipulado no puede dirigir el rmdir fuera del árbol
+      // gestionado (endurecimiento, revisor-seguridad 2026-07-10).
+      try {
+        const padre = path.resolve(path.dirname(archivo.destino));
+        const baseGestionada = path.resolve(rutas.base);
+        if (padre.startsWith(baseGestionada + path.sep)) fs.rmdirSync(padre);
+      } catch (_) { /* no vacío o raíz gestionada */ }
     } catch (err) {
       _emitir(
         { tipo: 'error', archivo: archivo.destino, mensaje: err.message },

package/scripts/doctor.js

@@ -31,7 +31,13 @@ async function obtenerVersionRemota() {
 }
 
 async function doctor(opciones = {}) {
-  const force = opciones.force || !ES_TTY;
+  // Reparar exige intención EXPLÍCITA (--force). El default previo
+  // (`|| !ES_TTY`) auto-reparaba en headless: los reparadores invocan al
+  // INSTALADOR contra el cwd — en un checkout del repo eso materializaba
+  // copias dentro del fuente, reescribía settings.json y disparaba
+  // `git rm --cached` masivo vía limpiarTracked (incidente 2026-07-10,
+  // tests/CI). Sin TTY y sin --force: doctor solo DIAGNOSTICA.
+  const force = !!opciones.force;
   const cwd = process.cwd();
 
   let errores = 0;
@@ -337,14 +343,18 @@ async function doctor(opciones = {}) {
                   });
                 }
                 if (resultado.incorrectos.length > 0) {
-                  const reparacion = repararHooks(settingsPath);
-                  if (reparacion.reparados > 0) {
-                    console.log(formatearPaso(`Hooks ${runtime.nombre}`, `${reparacion.reparados} hooks reparados automáticamente`));
-                    ok++;
-                  } else {
-                    console.log(formatearAdvertencia(`Hooks ${runtime.nombre}`, `${resultado.incorrectos.length} hooks con problemas`));
-                    advertencias++;
-                  }
+                  // NO reparar en la fase de diagnóstico: repararHooks muta
+                  // settings.json. Debe pasar por el gate --force como todo lo
+                  // demás (incidente 2026-07-10 — reparación no consentida).
+                  console.log(formatearAdvertencia(`Hooks ${runtime.nombre}`, `${resultado.incorrectos.length} hooks con problemas`));
+                  advertencias++;
+                  reparables.push({
+                    descripcion: `Reparar ${resultado.incorrectos.length} hooks con formato incorrecto en settings.json`,
+                    reparar: () => {
+                      const reparacion = repararHooks(settingsPath);
+                      return `${reparacion.reparados} hooks reparados en settings.json`;
+                    },
+                  });
                 }
               }
             }
@@ -683,10 +693,14 @@ async function doctor(opciones = {}) {
     console.log('');
 
     let proceder = force;
-    if (!proceder) {
+    if (!proceder && ES_TTY) {
       proceder = await preguntarSiNo('¿Reparar automáticamente?');
       console.log('');
     }
+    if (!proceder && !ES_TTY) {
+      console.log(`  ${color.dim('Modo no interactivo: reparación omitida. Ejecuta `swl-ses doctor --force` para reparar.')}`);
+      console.log('');
+    }
 
     if (proceder) {
       let reparados = 0;

package/scripts/instalador.js

@@ -21,7 +21,7 @@ const { preguntarSiNo, ES_TTY } = require('./lib/ui');
 const { resolverPerfil, generarPlan } = require('./lib/manifiestos');
 const { crearEstado, registrarArchivo, registrarComponente, guardarEstado, cargarEstado } = require('./lib/estado');
 const { validarRuta, esArchivoSensible, filtrarSecretos } = require('./lib/seguridad');
-const { registrarHooks, registrarOptimizaciones, rutaSettings, cargarHooksConfig } = require('./lib/hooks-settings');
+const { registrarHooks, registrarOptimizaciones, rutaSettings, cargarHooksConfig, hooksSWLRegistrados } = require('./lib/hooks-settings');
 const { obtenerTransformador } = require('./lib/transformadores');
 const {
   esProtegido,
@@ -84,6 +84,27 @@ function nombreLegibleEvolucion(rutaAbs) {
  * El comportamiento sin TUI no cambia.
  */
 async function install(opciones) {
+  // Camino "solo hooks" (DT-HOOKS-SOLO-PROYECTO): registra en el settings.json
+  // del PROYECTO los hooks del scope GLOBAL ya instalado, sin copiar ningún
+  // componente — evita duplicar agentes/comandos en la UI de Claude Code
+  // (que lee ambos scopes) solo para encender la telemetría.
+  if (opciones['solo-hooks'] || opciones.solo_hooks) {
+    const { activarHooksProyecto } = require('./lib/activar-hooks-proyecto');
+    const r = activarHooksProyecto({ target: opciones.target || 'claude' });
+    if (!r.ok) {
+      console.error(`\n✘ --solo-hooks: ${r.error}`);
+      process.exitCode = 1;
+      return r;
+    }
+    console.log('\n✔ Hooks activados a nivel proyecto SIN copiar componentes:');
+    console.log(`  settings:  ${r.settingsPath}`);
+    console.log(`  hooks de:  ${r.hooksDirGlobal} (scope global — update global los refresca aquí también)`);
+    console.log(`  registrados: ${r.registrados} | externos preservados: ${r.preservados}`);
+    console.log('\n  La telemetría (.planning/evolution/nudges.jsonl, skill-metrics.json)');
+    console.log('  empieza a acumularse desde la siguiente sesión de Claude en este proyecto.');
+    return r;
+  }
+
   // Leer manifest .swl-ses si existe — sus valores son defaults que el CLI puede sobreescribir
   const manifest = leerManifest(process.cwd());
   if (manifest && !opciones.target && !opciones.profile) {
@@ -143,6 +164,28 @@ async function install(opciones) {
               || perfilDeState
               || 'completo';
 
+  // DT-MODULOS-OPT-IN: preservar los módulos extra (--with) registrados por
+  // instalaciones previas en el install-state. Corre SIEMPRE (independiente
+  // de si el usuario pasó --profile): sin esto, cada update/reinstalación
+  // perdía en silencio los módulos opt-in (p. ej. reglas-personales).
+  let extrasDeState = [];
+  try {
+    const runtimeParaState = obtenerRuntime(target);
+    const dirDestino = esGlobal ? runtimeParaState.global : path.resolve(runtimeParaState.local);
+    const stateExistente = fs.existsSync(dirDestino) ? cargarEstado(dirDestino) : null;
+    if (stateExistente && Array.isArray(stateExistente.modulosExtra) && stateExistente.modulosExtra.length > 0) {
+      extrasDeState = stateExistente.modulosExtra;
+      console.log(`[install-state] Preservando módulos extra previos: ${extrasDeState.join(', ')}`);
+      console.log(`[install-state] Para quitarlos pasa --without <modulo> explícito.`);
+    }
+  } catch { /* state ilegible: seguir solo con --with del CLI */ }
+
+  // Unión de los extras del CLI (--with) y los preservados del state.
+  const withCombinado = [
+    ...String(opciones.with || '').split(',').map(s => s.trim()).filter(Boolean),
+    ...extrasDeState,
+  ].filter((m, i, arr) => arr.indexOf(m) === i);
+
   console.log(`swl-ses install v${VERSION}`);
   console.log(`${'='.repeat(40)}`);
 
@@ -209,7 +252,7 @@ async function install(opciones) {
   try {
     resolucion = resolverPerfil(perfil, {
       target,
-      with: opciones.with,
+      with: withCombinado.join(',') || undefined,
       without: opciones.without,
     });
   } catch (err) {
@@ -554,6 +597,9 @@ async function install(opciones) {
     // desde el cwd actual del doctor). Fix v1.4.3.
     allLangs: allLangs === true,
     stackInstalado: stackDetectado instanceof Set ? [...stackDetectado] : null,
+    // Solo los extras que el perfil realmente resolvió (existen y no fueron
+    // excluidos con --without) — DT-MODULOS-OPT-IN.
+    modulosExtra: withCombinado.filter(m => resolucion.modulos.includes(m)),
   });
 
   let instalados = 0;
@@ -706,6 +752,19 @@ async function install(opciones) {
     registrarComponente(estado, modulo);
   }
 
+  // Persistencia INTERMEDIA (DT-INSTALL-STATE-TRANSACCIONAL, nemesis sub1-S3):
+  // todos los archivos ya están en disco. Sin este save, una interrupción
+  // durante el registro de hooks (settings.json) o la generación de
+  // CLAUDE.md/AGENTS.md dejaría archivos copiados que el install-state NO
+  // registra → huérfanos que ni doctor ni uninstall ven. guardarEstado es
+  // atómico e idempotente; el save final (abajo) fija hooksRegistrados.
+  // Best-effort: un fallo aquí no aborta la instalación.
+  try {
+    guardarEstado(estado, rutas.base);
+  } catch (err) {
+    console.error(`  ! Aviso: no se pudo persistir el estado intermedio: ${err.message}`);
+  }
+
   // 7. Registrar hooks en settings.json del runtime
   // Los hooks solo se registran a nivel PROYECTO (no global) para evitar
   // ejecucion duplicada cuando Claude Code combina hooks de ambos scopes.
@@ -717,8 +776,15 @@ async function install(opciones) {
     // No filtrar por tipo de módulo porque hooks como grafo-contexto.js
     // pueden pertenecer a módulos con tipo distinto a "hooks".
     const hooksConfig = cargarHooksConfig();
-    const hookFilesInstalados = resolucion.archivos
-      .filter(a => (a.rutaRelativa || a.origen).endsWith('.js') && hooksConfig[path.basename(a.origen)])
+    // Registrar SOLO los hooks realmente copiados (estado.archivosInstalados),
+    // no los del PLAN (resolucion.archivos) — un hook cuyo .js falló al copiar
+    // (throw, colisión, origen inexistente) no debe quedar en settings.json
+    // apuntando a un archivo ausente: el wrapper traga el MODULE_NOT_FOUND y
+    // el hook muere en silencio (DT-REGISTRAR-HOOKS-PLAN, nemesis sub1-S2).
+    // Los hooks nunca entran a la rama `evolucionado` (no son componentes
+    // evolucionables) → un hook exitoso siempre queda en archivosInstalados.
+    const hookFilesInstalados = (estado.archivosInstalados || [])
+      .filter(a => (a.origen || '').endsWith('.js') && hooksConfig[path.basename(a.origen)])
       .map(a => path.basename(a.origen));
 
     if (hookFilesInstalados.length > 0) {
@@ -727,12 +793,22 @@ async function install(opciones) {
         console.log('    Los hooks se activan al instalar a nivel proyecto con: npx @saulwade/swl-ses@latest install --target claude');
       } else {
         const settingsPath = rutaSettings(runtime, rutas.base);
+        // UNIÓN con los hooks SWL YA registrados cuyo .js sigue en disco:
+        // registrarHooks reconstruye la sección SWL de settings.json, así que
+        // pasar solo lo recién copiado DESREGISTRARÍA los hooks pre-existentes
+        // que colisionaron sin --force pero siguen funcionando (regresión
+        // detectada por la re-auditoría nemesis iter-2). El plan-base ya no se
+        // usa: solo entra lo copiado ∪ lo pre-registrado-con-archivo-en-disco.
+        const preRegistrados = hooksSWLRegistrados(settingsPath).filter(
+          nombre => cargarHooksConfig()[nombre] && fs.existsSync(path.join(rutas.hooks, nombre))
+        );
+        const hookFilesFinal = [...new Set([...hookFilesInstalados, ...preRegistrados])];
         try {
           const resultado = registrarHooks({
             settingsPath,
             hooksDir: rutas.hooks,
             esGlobal: false,
-            hookFiles: hookFilesInstalados,
+            hookFiles: hookFilesFinal,
           });
           hooksRegistrados = resultado.registrados;
           hooksPreservados = resultado.preservados;
@@ -1151,12 +1227,35 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     } else {
       destino = path.join(dirDestino, nombreArchivo);
     }
+  } else if (
+    archivo.tipo === 'hooks' &&
+    archivo.rutaRelativa &&
+    (archivo.rutaRelativa.startsWith('hooks/lib/') || archivo.rutaRelativa.startsWith('scripts/lib/'))
+  ) {
+    // Contrato de layout de hooks: los hooks requieren sus libs como
+    // './lib/X' (y check-update/session-briefing usan ese fallback
+    // explícito). El aplanado total dejaba TODOS esos require() muertos en
+    // instalaciones frescas — MODULE_NOT_FOUND tragado por el wrapper de
+    // settings; los installs de campo sobrevivían por el lib/ residual de
+    // versiones previas. Preservar el subárbol lib/ (incluye subdirs como
+    // lib/ciclo-autonomo/) restaura el contrato. scripts/ NO-lib sigue
+    // aplanado en la raíz de hooks (status quo: rotar-audit-logs, etc.).
+    const resto = archivo.rutaRelativa.replace(/^(?:hooks|scripts)\/lib\//, '');
+    const partes = resto.split('/');
+    const subdirLib = path.join(dirDestino, 'lib', ...partes.slice(0, -1));
+    if (!fs.existsSync(subdirLib)) {
+      fs.mkdirSync(subdirLib, { recursive: true });
+    }
+    destino = path.join(subdirLib, partes[partes.length - 1]);
   } else {
     destino = path.join(dirDestino, nombreArchivo);
   }
 
-  // Seguridad: validar ruta
-  validarRuta(dirDestino, nombreArchivo);
+  // Seguridad: validar el DESTINO calculado completo, no solo el basename —
+  // cubre también las ramas con subdirectorios (reglas/lenguajes, hooks/lib)
+  // contra un rutaRelativa con traversal (endurecimiento, revisor-seguridad
+  // 2026-07-10; el manifiesto es artefacto confiable, defensa en profundidad).
+  validarRuta(dirDestino, path.relative(dirDestino, destino));
 
   // Verificar archivo sensible
   if (esArchivoSensible(nombreArchivo)) {