@saulwade/swl-ses 2.6.0 → 2.8.0

package/scripts/detectar-aprendizajes-duplicados.js

@@ -1,151 +1,151 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * detectar-aprendizajes-duplicados.js
- *
- * Detecta pares de entradas en `.planning/APRENDIZAJES.md` con alta similitud
- * de tokens (Jaccard > umbral). Útil para identificar candidatos a fusionar
- * cuando el hook de auto-extracción genera entradas redundantes.
- *
- * Patrón adoptado de `temp/agentmemory-main/src/functions/auto-forget.ts`
- * (contradiction detection con Jaccard >= 0.9). Aquí se usa con threshold
- * configurable más bajo (0.6 default) porque queremos sugerir, no auto-borrar.
- *
- * NO modifica APRENDIZAJES.md. Solo reporta. La acción de fusión queda en
- * manos del usuario o de un comando separado (`/swl:aprender consolidar`).
- *
- * Uso:
- *   node scripts/detectar-aprendizajes-duplicados.js [threshold]
- *
- * Argumentos:
- *   threshold  - Similitud mínima para reportar (default: 0.6, rango [0, 1]).
- *
- * Exit codes:
- *   0 - Ejecución OK (haya o no duplicados)
- *   1 - Error de I/O o parseo
- *
- * Output: tabla legible en stdout. Si se detectan ≥ 1 duplicados, también
- * imprime sugerencia para revisar/consolidar.
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const { tokenize, jaccard } = require('./lib/jaccard-similarity');
-
-const RUTA_APRENDIZAJES = path.join(process.cwd(), '.planning', 'APRENDIZAJES.md');
-const DEFAULT_THRESHOLD = 0.6;
-const MAX_PARES_REPORTADOS = 30;
-
-function parsearEntradas(contenido) {
-  const lineas = contenido.split('\n');
-  const entradas = [];
-  let actual = null;
-
-  for (let i = 0; i < lineas.length; i++) {
-    const linea = lineas[i];
-    if (linea.startsWith('## ')) {
-      if (actual) entradas.push(actual);
-      actual = {
-        lineaInicio: i + 1,
-        titulo: linea.slice(3).trim(),
-        contenido: '',
-      };
-    } else if (actual) {
-      actual.contenido += linea + '\n';
-    }
-  }
-  if (actual) entradas.push(actual);
-
-  // Filtrar entradas vacías o triviales (< 50 chars de contenido real)
-  return entradas.filter(e => e.contenido.replace(/\s/g, '').length >= 50);
-}
-
-function detectarDuplicados(entradas, threshold) {
-  const tokensCache = entradas.map(e => tokenize(e.titulo + ' ' + e.contenido));
-  const pares = [];
-
-  for (let i = 0; i < entradas.length; i++) {
-    for (let j = i + 1; j < entradas.length; j++) {
-      const sim = jaccard(tokensCache[i], tokensCache[j]);
-      if (sim >= threshold) {
-        pares.push({
-          entradaA: entradas[i],
-          entradaB: entradas[j],
-          similitud: sim,
-        });
-      }
-    }
-  }
-
-  pares.sort((a, b) => b.similitud - a.similitud);
-  return pares;
-}
-
-function reportarTexto(pares) {
-  if (pares.length === 0) {
-    console.log('Sin duplicados detectados sobre el umbral.');
-    return;
-  }
-
-  console.log(`Pares con similitud Jaccard ≥ umbral: ${pares.length}`);
-  console.log('');
-
-  const limite = Math.min(pares.length, MAX_PARES_REPORTADOS);
-  for (let i = 0; i < limite; i++) {
-    const p = pares[i];
-    console.log(`  [${(p.similitud * 100).toFixed(1)}%] ` +
-      `L${p.entradaA.lineaInicio} ↔ L${p.entradaB.lineaInicio}`);
-    console.log('         A: ' + p.entradaA.titulo.slice(0, 80));
-    console.log('         B: ' + p.entradaB.titulo.slice(0, 80));
-    console.log('');
-  }
-
-  if (pares.length > limite) {
-    console.log(`  ... ${pares.length - limite} pares adicionales no mostrados`);
-  }
-
-  console.log('Sugerencia: revisa los pares con mayor similitud y considera ' +
-    'fusionarlos en una sola entrada con `/swl:aprender consolidar` o manualmente.');
-}
-
-function main() {
-  const threshold = parseFloat(process.argv[2]) || DEFAULT_THRESHOLD;
-
-  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
-    console.error(`Threshold inválido: ${process.argv[2]}. Usar valor en [0, 1].`);
-    process.exit(1);
-  }
-
-  if (!fs.existsSync(RUTA_APRENDIZAJES)) {
-    console.error(`No existe ${RUTA_APRENDIZAJES}.`);
-    process.exit(1);
-  }
-
-  let contenido;
-  try {
-    contenido = fs.readFileSync(RUTA_APRENDIZAJES, 'utf8');
-  } catch (err) {
-    console.error(`Error leyendo ${RUTA_APRENDIZAJES}: ${err.message}`);
-    process.exit(1);
-  }
-
-  const entradas = parsearEntradas(contenido);
-  console.log(`Entradas encontradas: ${entradas.length}`);
-  console.log(`Threshold de similitud: ${threshold}`);
-  console.log('');
-
-  const pares = detectarDuplicados(entradas, threshold);
-  reportarTexto(pares);
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  parsearEntradas,
-  detectarDuplicados,
-  reportarTexto,
-};
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * detectar-aprendizajes-duplicados.js
+ *
+ * Detecta pares de entradas en `.planning/APRENDIZAJES.md` con alta similitud
+ * de tokens (Jaccard > umbral). Útil para identificar candidatos a fusionar
+ * cuando el hook de auto-extracción genera entradas redundantes.
+ *
+ * Patrón adoptado de `temp/agentmemory-main/src/functions/auto-forget.ts`
+ * (contradiction detection con Jaccard >= 0.9). Aquí se usa con threshold
+ * configurable más bajo (0.6 default) porque queremos sugerir, no auto-borrar.
+ *
+ * NO modifica APRENDIZAJES.md. Solo reporta. La acción de fusión queda en
+ * manos del usuario o de un comando separado (`/swl:aprender consolidar`).
+ *
+ * Uso:
+ *   node scripts/detectar-aprendizajes-duplicados.js [threshold]
+ *
+ * Argumentos:
+ *   threshold  - Similitud mínima para reportar (default: 0.6, rango [0, 1]).
+ *
+ * Exit codes:
+ *   0 - Ejecución OK (haya o no duplicados)
+ *   1 - Error de I/O o parseo
+ *
+ * Output: tabla legible en stdout. Si se detectan ≥ 1 duplicados, también
+ * imprime sugerencia para revisar/consolidar.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const { tokenize, jaccard } = require('./lib/jaccard-similarity');
+
+const RUTA_APRENDIZAJES = path.join(process.cwd(), '.planning', 'APRENDIZAJES.md');
+const DEFAULT_THRESHOLD = 0.6;
+const MAX_PARES_REPORTADOS = 30;
+
+function parsearEntradas(contenido) {
+  const lineas = contenido.split('\n');
+  const entradas = [];
+  let actual = null;
+
+  for (let i = 0; i < lineas.length; i++) {
+    const linea = lineas[i];
+    if (linea.startsWith('## ')) {
+      if (actual) entradas.push(actual);
+      actual = {
+        lineaInicio: i + 1,
+        titulo: linea.slice(3).trim(),
+        contenido: '',
+      };
+    } else if (actual) {
+      actual.contenido += linea + '\n';
+    }
+  }
+  if (actual) entradas.push(actual);
+
+  // Filtrar entradas vacías o triviales (< 50 chars de contenido real)
+  return entradas.filter(e => e.contenido.replace(/\s/g, '').length >= 50);
+}
+
+function detectarDuplicados(entradas, threshold) {
+  const tokensCache = entradas.map(e => tokenize(e.titulo + ' ' + e.contenido));
+  const pares = [];
+
+  for (let i = 0; i < entradas.length; i++) {
+    for (let j = i + 1; j < entradas.length; j++) {
+      const sim = jaccard(tokensCache[i], tokensCache[j]);
+      if (sim >= threshold) {
+        pares.push({
+          entradaA: entradas[i],
+          entradaB: entradas[j],
+          similitud: sim,
+        });
+      }
+    }
+  }
+
+  pares.sort((a, b) => b.similitud - a.similitud);
+  return pares;
+}
+
+function reportarTexto(pares) {
+  if (pares.length === 0) {
+    console.log('Sin duplicados detectados sobre el umbral.');
+    return;
+  }
+
+  console.log(`Pares con similitud Jaccard ≥ umbral: ${pares.length}`);
+  console.log('');
+
+  const limite = Math.min(pares.length, MAX_PARES_REPORTADOS);
+  for (let i = 0; i < limite; i++) {
+    const p = pares[i];
+    console.log(`  [${(p.similitud * 100).toFixed(1)}%] ` +
+      `L${p.entradaA.lineaInicio} ↔ L${p.entradaB.lineaInicio}`);
+    console.log('         A: ' + p.entradaA.titulo.slice(0, 80));
+    console.log('         B: ' + p.entradaB.titulo.slice(0, 80));
+    console.log('');
+  }
+
+  if (pares.length > limite) {
+    console.log(`  ... ${pares.length - limite} pares adicionales no mostrados`);
+  }
+
+  console.log('Sugerencia: revisa los pares con mayor similitud y considera ' +
+    'fusionarlos en una sola entrada con `/swl:aprender consolidar` o manualmente.');
+}
+
+function main() {
+  const threshold = parseFloat(process.argv[2]) || DEFAULT_THRESHOLD;
+
+  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+    console.error(`Threshold inválido: ${process.argv[2]}. Usar valor en [0, 1].`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(RUTA_APRENDIZAJES)) {
+    console.error(`No existe ${RUTA_APRENDIZAJES}.`);
+    process.exit(1);
+  }
+
+  let contenido;
+  try {
+    contenido = fs.readFileSync(RUTA_APRENDIZAJES, 'utf8');
+  } catch (err) {
+    console.error(`Error leyendo ${RUTA_APRENDIZAJES}: ${err.message}`);
+    process.exit(1);
+  }
+
+  const entradas = parsearEntradas(contenido);
+  console.log(`Entradas encontradas: ${entradas.length}`);
+  console.log(`Threshold de similitud: ${threshold}`);
+  console.log('');
+
+  const pares = detectarDuplicados(entradas, threshold);
+  reportarTexto(pares);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  parsearEntradas,
+  detectarDuplicados,
+  reportarTexto,
+};

package/scripts/doctor.js

@@ -168,18 +168,41 @@ async function doctor(opciones = {}) {
     advertencias++;
   }
 
-  // C-2: doctor DIAGNOSTICA; no siembra dirs de proyecto (.planning/_userland)
-  // 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 =
-    fs.existsSync(path.join(cwd, '.planning')) ||
-    fs.existsSync(path.join(cwd, '_userland')) ||
-    fs.existsSync(path.join(cwd, '.swl-install-state.json'));
-
-  // 3. Verificar .planning/
+  // C-2: doctor DIAGNOSTICA según la CLASE del directorio (clasificar-directorio):
+  //  - 'home'     : ubicación de una instalación global, NUNCA un proyecto. Un
+  //                 ~/.planning (backups del install, scaffold de doctor,
+  //                 telemetría mal dirigida) o ~/_userland vacío es basura →
+  //                 OFRECER eliminar, jamás scaffoldear marcadores.
+  //  - 'proyecto' : proyecto de desarrollo real (.git/stack/.planning) →
+  //                 verificar/reparar/inicializar la estructura .planning.
+  //  - 'nuevo'/'otro' : no scaffoldear a ciegas — "No aplica".
+  // Origen del rediseño (bug 2026-07-15): `install --global` desde el HOME
+  // sembraba ~/.planning/backups y doctor ofrecía scaffoldear marcadores ahí.
+  const { clasificarDirectorio } = require('./lib/clasificar-directorio');
+  const { esUserlandVacio, esPlanningRemovibleEnHome, limpiarBasuraGlobal } = require('./lib/limpiar-basura-global');
+  const claseDir = clasificarDirectorio(cwd);
+  const esProyectoSwl = claseDir === 'proyecto'; // consumido también por la sección 4 (_userland)
+
+  // 3. Verificar .planning/ según la clase del directorio
   const planningDir = path.join(cwd, '.planning');
-  if (fs.existsSync(planningDir)) {
+  if (claseDir === 'home') {
+    const basura = [];
+    if (esPlanningRemovibleEnHome(cwd)) basura.push('~/.planning');
+    if (esUserlandVacio(cwd)) basura.push('~/_userland (vacío)');
+    if (basura.length > 0) {
+      console.log(formatearAdvertencia('instalación global', `Directorios basura en el HOME: ${basura.join(', ')} — el HOME no es un proyecto`));
+      advertencias++;
+      reparables.push({
+        descripcion: `Eliminar del HOME: ${basura.join(', ')}`,
+        reparar: () => {
+          const r = limpiarBasuraGlobal({ home: cwd });
+          return r.eliminados.length ? `Eliminado: ${r.eliminados.join(', ')}` : 'Nada que eliminar';
+        },
+      });
+    } else {
+      console.log(formatearPaso('.planning/', 'No aplica — el HOME es la ubicación de instalación global, no un proyecto'));
+    }
+  } else if (claseDir === 'proyecto' && 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))
@@ -238,9 +261,10 @@ async function doctor(opciones = {}) {
     });
   }
 
-  // 4. Verificar _userland/
+  // 4. Verificar _userland/ (solo relevante en un proyecto de desarrollo; en el
+  //    HOME un _userland vacío ya se ofreció eliminar en la sección 3).
   const userlandDir = path.join(cwd, '_userland');
-  if (fs.existsSync(userlandDir)) {
+  if (claseDir === 'proyecto' && fs.existsSync(userlandDir)) {
     console.log(formatearPaso('_userland/', 'Presente'));
     ok++;
 
@@ -671,6 +695,30 @@ async function doctor(opciones = {}) {
     }
   }
 
+  // X. Diagnóstico Core-3 (Claude Code, Codex CLI, Gemini CLI) — F31-T07.
+  // Puramente informativo: read-only, best-effort, nunca repara ni evalúa
+  // canarios conductuales. Disponibilidad != certificación (ADR-0047); por
+  // eso no suma a ok/advertencias/errores — un runtime experimental ausente
+  // no es un problema de instalación de SWL.
+  try {
+    const { diagnosticarCore3 } = require('./lib/runtime-doctor-core3');
+    const { pathEntriesFromEnv, emptyRuntimeMap } = require('./lib/runtime-doctor-input');
+    const diagnosticoCore3 = await diagnosticarCore3({
+      now: new Date().toISOString(),
+      pathEntries: pathEntriesFromEnv(),
+      bundles: emptyRuntimeMap(),
+      buildEvents: emptyRuntimeMap(),
+    });
+    console.log(formatearPaso('Runtimes Core-3', 'experimental/unverified — `swl-ses runtime-doctor --json` para detalle'));
+    for (const runtime of diagnosticoCore3.runtimes) {
+      const detalle = runtime.availability.status === 'available'
+        ? `available v${runtime.availability.version}`
+        : runtime.availability.status;
+      console.log(`      ${color.dim(`${runtime.runtimeId}: ${detalle}`)}`);
+    }
+    console.log('');
+  } catch { /* nunca bloquear el doctor por este check */ }
+
   // Reporte final
   console.log('');
   console.log(`  ${lineaSeparadora()}`);

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);
 }