@saulwade/swl-ses 2.5.3 → 2.6.1

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;
@@ -166,14 +172,37 @@ async function doctor(opciones = {}) {
   // en un cwd que no es un proyecto swl. Correr `doctor` desde un directorio
   // cualquiera no debe generar clutter. Marcadores de proyecto: .planning/ o
   // _userland/ ya presentes, o un install-state de scope proyecto.
-  const esProyectoSwl =
+  //
+  // El HOME es la EXCEPCIÓN: un install global crea ~/_userland ahí, pero el
+  // HOME NO es un proyecto — doctor no debe sembrar ~/.planning/ (bug 2026-07-15:
+  // sembraba un scaffold espurio y los hooks volcaban telemetría en el HOME vía
+  // raiz-proyecto). Ver scripts/lib/limpiar-basura-global.js.
+  const { esPlanningEspurio, esUserlandVacio, limpiarBasuraGlobal } = require('./lib/limpiar-basura-global');
+  const esHome = path.resolve(cwd) === path.resolve(require('os').homedir());
+  const esProyectoSwl = !esHome && (
     fs.existsSync(path.join(cwd, '.planning')) ||
     fs.existsSync(path.join(cwd, '_userland')) ||
-    fs.existsSync(path.join(cwd, '.swl-install-state.json'));
+    fs.existsSync(path.join(cwd, '.swl-install-state.json'))
+  );
 
   // 3. Verificar .planning/
   const planningDir = path.join(cwd, '.planning');
-  if (fs.existsSync(planningDir)) {
+  const basuraHome = [];
+  if (esHome && esPlanningEspurio(cwd)) basuraHome.push('~/.planning (scaffold de doctor)');
+  if (esHome && esUserlandVacio(cwd)) basuraHome.push('~/_userland (vacío)');
+  if (basuraHome.length > 0) {
+    // Basura de instalación global en el HOME: NO "reparar" (el HOME no es un
+    // proyecto) — OFRECER eliminarla. Ver scripts/lib/limpiar-basura-global.js.
+    console.log(formatearAdvertencia('instalación global', `Directorios basura en el HOME: ${basuraHome.join(', ')} — el HOME no es un proyecto`));
+    advertencias++;
+    reparables.push({
+      descripcion: `Eliminar ${basuraHome.length} directorio(s) basura del HOME: ${basuraHome.join(', ')}`,
+      reparar: () => {
+        const r = limpiarBasuraGlobal({ home: cwd });
+        return r.eliminados.length ? `Eliminado: ${r.eliminados.join(', ')}` : 'Nada que eliminar';
+      },
+    });
+  } else if (fs.existsSync(planningDir)) {
     const archivosEsperados = ['PROYECTO.md', 'REQUISITOS.md', 'HOJA-RUTA.md', 'ESTADO.md'];
     const faltantes = archivosEsperados.filter(
       f => !fs.existsSync(path.join(planningDir, f))
@@ -337,14 +366,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 +716,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/evidencia-valor.js

@@ -1,101 +1,101 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * evidencia-valor.js — CLI `swl-ses valor`: panel de evidencia de valor del
- * harness en el proyecto downstream actual.
- *
- * Uso:
- *   swl-ses valor                # panel legible (ventana 30 días)
- *   swl-ses valor --dias 90      # ventana distinta
- *   swl-ses valor --json         # salida JSON para tooling
- *
- * Reglas duras del panel (docs/evidencia-valor.md):
- *   - Cada métrica declara su PROCEDENCIA (git / GitHub / hook-event) y su
- *     CARÁCTER (evidencia | proxy | contexto). Nunca scores autodeclarados.
- *   - Todo se lee LOCAL. El repo madre no lee estos datos.
- */
-
-const { panelEvidencia } = require('./lib/evidencia-valor.js');
-
-/**
- * Contrato del CLI (bin/swl-ses.js): exportar UNA función(opciones) sin
- * efectos al require. Violarlo = "modulo is not a function" tras imprimir
- * el panel (caso real: SIGM, 2026-07-09).
- */
-function valor(opciones = {}) {
-  const json = !!opciones.json;
-  const ventanaDias = parseInt(opciones.dias, 10) || 30;
-
-  const p = panelEvidencia(process.cwd(), { ventanaDias });
-
-  if (json) {
-    console.log(JSON.stringify(p, null, 2));
-    return;
-  }
-
-  console.log(`Evidencia de valor — ventana ${p.ventanaDias} días (${p.generado})`);
-  console.log(`  ${p.frontera}`);
-  console.log('');
-
-  const i = p.intercepciones;
-  console.log('1. Intercepciones de gates [evidencia · hook-event]');
-  if (!i.disponible) {
-    console.log(`   no disponible — ${i.razon}`);
-  } else {
-    console.log(`   intervenciones: ${i.intervenciones} de ${i.totalEventos} eventos`);
-    const tipos = Object.entries(i.porTipo).sort((a, b) => b[1] - a[1]).slice(0, 6);
-    for (const [t, n] of tipos) console.log(`     - ${t}: ${n}`);
-  }
-  console.log('');
-
-  const d = p.defectos;
-  console.log('2. Presión de defectos [proxy · git log]');
-  if (!d.disponible) {
-    console.log(`   no disponible — ${d.razon}`);
-  } else {
-    console.log(`   commits: ${d.commits} | fix: ${d.fixes} | feat: ${d.feats} | ratio fix/feat: ${d.ratioFixFeat ?? 'n/a'}`);
-    if (d.escapes.disponible) {
-      console.log(`   escapes: ${d.escapes.fixesTrasUltimaVerificacion} fix tras la última verificación (${d.escapes.ultimaVerificacion}) — ${d.escapes.nota}`);
-    } else {
-      console.log(`   escapes: no disponible — ${d.escapes.razon}`);
-    }
-  }
-  console.log('');
-
-  const dc = p.doraCi;
-  console.log('3. DORA-lite + CI [evidencia de tendencia · git + GitHub]');
-  if (!dc.disponible) {
-    console.log(`   no disponible — ${dc.razon}`);
-  } else {
-    const dora = dc.dora;
-    const nd = m => `n/d (${(m && m.razon) || 'sin datos'})`;
-    const df = dora.deploymentFrequency;
-    console.log(`   deployment frequency: ${df && df.disponible !== false && df.valor != null ? `${df.valor} deploys/semana [${df.clasificacion}]` : nd(df)}`);
-    const lt = dora.leadTime;
-    console.log(`   lead time: ${lt && lt.disponible !== false && lt.p50Horas != null ? `p50 ${(+lt.p50Horas).toFixed(1)}h / p95 ${(+lt.p95Horas).toFixed(1)}h [${lt.clasificacion}]` : nd(lt)}`);
-    const cfr = dora.changeFailureRate;
-    console.log(`   change failure rate: ${cfr && cfr.disponible !== false && cfr.valor != null ? `${cfr.valor}% [${cfr.clasificacion || ''}]` : nd(cfr)}`);
-    const mt = dora.mttr;
-    console.log(`   mttr: ${mt && mt.disponible !== false && mt.mttrHoras != null ? `${mt.mttrHoras}h` : nd(mt)}`);
-    console.log('   (correlación con la adopción del flujo — no causalidad)');
-  }
-  console.log('');
-
-  const u = p.uso;
-  console.log('4. Uso del sistema [contexto · telemetría]');
-  if (!u.disponible) {
-    console.log(`   no disponible — ${u.razon}`);
-  } else {
-    console.log(`   invocaciones de skills: ${u.invocaciones} | top: ${u.top5.join(', ')}`);
-  }
-  console.log('');
-  console.log('Compartir agregados con el autor (opt-in): swl-ses field-report — ver docs/evidencia-valor.md');
-}
-
-module.exports = valor;
-
-if (require.main === module) {
-  const { parsearOpciones } = require('./lib/parsear-opciones.js');
-  valor(parsearOpciones(process.argv.slice(2)));
-}
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * evidencia-valor.js — CLI `swl-ses valor`: panel de evidencia de valor del
+ * harness en el proyecto downstream actual.
+ *
+ * Uso:
+ *   swl-ses valor                # panel legible (ventana 30 días)
+ *   swl-ses valor --dias 90      # ventana distinta
+ *   swl-ses valor --json         # salida JSON para tooling
+ *
+ * Reglas duras del panel (docs/evidencia-valor.md):
+ *   - Cada métrica declara su PROCEDENCIA (git / GitHub / hook-event) y su
+ *     CARÁCTER (evidencia | proxy | contexto). Nunca scores autodeclarados.
+ *   - Todo se lee LOCAL. El repo madre no lee estos datos.
+ */
+
+const { panelEvidencia } = require('./lib/evidencia-valor.js');
+
+/**
+ * Contrato del CLI (bin/swl-ses.js): exportar UNA función(opciones) sin
+ * efectos al require. Violarlo = "modulo is not a function" tras imprimir
+ * el panel (caso real: SIGM, 2026-07-09).
+ */
+function valor(opciones = {}) {
+  const json = !!opciones.json;
+  const ventanaDias = parseInt(opciones.dias, 10) || 30;
+
+  const p = panelEvidencia(process.cwd(), { ventanaDias });
+
+  if (json) {
+    console.log(JSON.stringify(p, null, 2));
+    return;
+  }
+
+  console.log(`Evidencia de valor — ventana ${p.ventanaDias} días (${p.generado})`);
+  console.log(`  ${p.frontera}`);
+  console.log('');
+
+  const i = p.intercepciones;
+  console.log('1. Intercepciones de gates [evidencia · hook-event]');
+  if (!i.disponible) {
+    console.log(`   no disponible — ${i.razon}`);
+  } else {
+    console.log(`   intervenciones: ${i.intervenciones} de ${i.totalEventos} eventos`);
+    const tipos = Object.entries(i.porTipo).sort((a, b) => b[1] - a[1]).slice(0, 6);
+    for (const [t, n] of tipos) console.log(`     - ${t}: ${n}`);
+  }
+  console.log('');
+
+  const d = p.defectos;
+  console.log('2. Presión de defectos [proxy · git log]');
+  if (!d.disponible) {
+    console.log(`   no disponible — ${d.razon}`);
+  } else {
+    console.log(`   commits: ${d.commits} | fix: ${d.fixes} | feat: ${d.feats} | ratio fix/feat: ${d.ratioFixFeat ?? 'n/a'}`);
+    if (d.escapes.disponible) {
+      console.log(`   escapes: ${d.escapes.fixesTrasUltimaVerificacion} fix tras la última verificación (${d.escapes.ultimaVerificacion}) — ${d.escapes.nota}`);
+    } else {
+      console.log(`   escapes: no disponible — ${d.escapes.razon}`);
+    }
+  }
+  console.log('');
+
+  const dc = p.doraCi;
+  console.log('3. DORA-lite + CI [evidencia de tendencia · git + GitHub]');
+  if (!dc.disponible) {
+    console.log(`   no disponible — ${dc.razon}`);
+  } else {
+    const dora = dc.dora;
+    const nd = m => `n/d (${(m && m.razon) || 'sin datos'})`;
+    const df = dora.deploymentFrequency;
+    console.log(`   deployment frequency: ${df && df.disponible !== false && df.valor != null ? `${df.valor} deploys/semana [${df.clasificacion}]` : nd(df)}`);
+    const lt = dora.leadTime;
+    console.log(`   lead time: ${lt && lt.disponible !== false && lt.p50Horas != null ? `p50 ${(+lt.p50Horas).toFixed(1)}h / p95 ${(+lt.p95Horas).toFixed(1)}h [${lt.clasificacion}]` : nd(lt)}`);
+    const cfr = dora.changeFailureRate;
+    console.log(`   change failure rate: ${cfr && cfr.disponible !== false && cfr.valor != null ? `${cfr.valor}% [${cfr.clasificacion || ''}]` : nd(cfr)}`);
+    const mt = dora.mttr;
+    console.log(`   mttr: ${mt && mt.disponible !== false && mt.mttrHoras != null ? `${mt.mttrHoras}h` : nd(mt)}`);
+    console.log('   (correlación con la adopción del flujo — no causalidad)');
+  }
+  console.log('');
+
+  const u = p.uso;
+  console.log('4. Uso del sistema [contexto · telemetría]');
+  if (!u.disponible) {
+    console.log(`   no disponible — ${u.razon}`);
+  } else {
+    console.log(`   invocaciones de skills: ${u.invocaciones} | top: ${u.top5.join(', ')}`);
+  }
+  console.log('');
+  console.log('Compartir agregados con el autor (opt-in): swl-ses field-report — ver docs/evidencia-valor.md');
+}
+
+module.exports = valor;
+
+if (require.main === module) {
+  const { parsearOpciones } = require('./lib/parsear-opciones.js');
+  valor(parsearOpciones(process.argv.slice(2)));
+}

package/scripts/field-report.js

@@ -196,20 +196,20 @@ function generarReporte() {
   console.log(`\n> Generado por \`node scripts/field-report.js\``);
 }
 
-function fieldReport(opciones = {}) {
-  DAYS = parseInt(opciones.days || opciones.dias, 10) || 0;
-  PROJECT = opciones.project || null;
-  OUTPUT = opciones.output || 'md';
-  generarReporte();
-}
-
-module.exports = fieldReport;
-
-if (require.main === module) {
-  const args = process.argv.slice(2).reduce((acc, arg) => {
-    const [k, v] = arg.replace(/^--/, '').split('=');
-    acc[k] = v || true;
-    return acc;
-  }, {});
-  fieldReport(args);
+function fieldReport(opciones = {}) {
+  DAYS = parseInt(opciones.days || opciones.dias, 10) || 0;
+  PROJECT = opciones.project || null;
+  OUTPUT = opciones.output || 'md';
+  generarReporte();
+}
+
+module.exports = fieldReport;
+
+if (require.main === module) {
+  const args = process.argv.slice(2).reduce((acc, arg) => {
+    const [k, v] = arg.replace(/^--/, '').split('=');
+    acc[k] = v || true;
+    return acc;
+  }, {});
+  fieldReport(args);
 }