@saulwade/swl-ses 2.5.3 → 2.6.1

package/hooks/lib/mcp-health.js

@@ -17,6 +17,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 const os = require('os');
 
@@ -151,7 +152,7 @@ function getHealthReport() {
  * @returns {string[]} Nombres de servidores MCP configurados.
  */
 function detectConfiguredMCPs(cwd) {
-  const dir = cwd || process.cwd();
+  const dir = cwd || raizProyecto(process.cwd());
   const mcpPath = path.join(dir, '.mcp.json');
   try {
     const config = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));

package/hooks/lib/memory-search.js

@@ -246,6 +246,10 @@ function _buscarEnSesionesFallback(baseDir, terminos) {
  * @returns {object|null}
  */
 function obtenerSesion(baseDir, id) {
+  // El id interpola en un path: solo caracteres de id legítimo (ses-...,
+  // apr-N) — sin separadores ni '..' que resuelvan fuera de sessions/
+  // (defensa en profundidad para el CLI `swl-ses memoria-search fetch`).
+  if (!/^[a-zA-Z0-9_-]+$/.test(String(id))) return null;
   const sessionPath = path.join(baseDir, '.planning', 'sessions', `${id}.json`);
   if (!fs.existsSync(sessionPath)) return null;
 

package/hooks/lib/merkle-audit.js

@@ -18,8 +18,34 @@
 const crypto = require('crypto');
 const fs     = require('fs');
 
-function _sha256(data) {
-  return crypto.createHash('sha256').update(data).digest('hex');
+/**
+ * Hash de cada entrada de la cadena. Si `SWL_AUDIT_HMAC_KEY` está definida, usa
+ * HMAC-SHA256 con esa clave; si no, SHA256 plano (default zero-config).
+ *
+ * MODELO DE AMENAZA (resuelve el residual "SHA256 sin clave"):
+ *  - SIN clave (default): la cadena es tamper-EVIDENTE ante corrupción
+ *    accidental (escrituras parciales, error de disco, edición por una
+ *    herramienta buggy) y ediciones parciales. NO defiende contra quien tenga
+ *    acceso de escritura Y pueda recomputar hashes — pero en una máquina local
+ *    de un solo usuario ESE es el dueño, que es la raíz de confianza: no hay
+ *    adversario distinto del dueño. Correcto por diseño para audit local.
+ *  - CON clave en env (opt-in): defiende contra un adversario a nivel de
+ *    ARCHIVO —dependencia npm maliciosa, ransomware, conflicto de sync— que
+ *    puede escribir `.planning/` pero NO leer el entorno del proceso del hook.
+ *    Sin la clave del env no puede forjar HMACs válidos → la manipulación se
+ *    detecta. NO defiende contra quien lea el env del proceso (el dueño);
+ *    para eso hace falta anclaje externo (publicar el último hash en un store
+ *    append-only inmutable), fuera del alcance de este módulo.
+ *  - La clave vive en el ENV (no en disco): `setx SWL_AUDIT_HMAC_KEY <valor>`
+ *    o export. Cambiar la clave inicia una época nueva e invalida cadenas
+ *    previas (esperado). Cargar la clave desde el env en cada llamada para
+ *    respetar rotación sin reiniciar procesos de larga vida.
+ */
+function _hash(data) {
+  const clave = process.env.SWL_AUDIT_HMAC_KEY;
+  return clave
+    ? crypto.createHmac('sha256', clave).update(data).digest('hex')
+    : crypto.createHash('sha256').update(data).digest('hex');
 }
 
 function crearEntrada(datos, hashAnterior) {
@@ -32,7 +58,7 @@ function crearEntrada(datos, hashAnterior) {
     result: datos.result || 'ok',
     prev: hashAnterior,
   });
-  const hash = _sha256(payload);
+  const hash = _hash(payload);
   return { payload, hash };
 }
 
@@ -56,12 +82,38 @@ function appendAudit(rutaArchivo, datos) {
   return hash;
 }
 
-function verificarCadena(rutaArchivo) {
+/**
+ * Verifica la integridad de la cadena Merkle de un archivo de auditoría.
+ *
+ * @param {string} rutaArchivo
+ * @param {object} [opts]
+ * @param {string} [opts.hashInicial] - Hash del que la cadena continúa. Por
+ *   defecto el génesis ('0'*64). Tras una rotación, el archivo activo empieza
+ *   en una entrada cuyo `prev` apunta a una entrada ya archivada (no al
+ *   génesis) — pasar aquí el `hashInicial` del checkpoint
+ *   (`.checkpoint-<archivo>.json`) para validar el activo como CONTINUACIÓN de
+ *   la cadena archivada, sin falso positivo de rotura (nemesis iter-1 S3-5).
+ *
+ *   LÍMITE (re-auditoría nemesis iter-2): con `hashInicial` esto prueba la
+ *   consistencia INTERNA del activo, NO que continúe la cadena archivada — el
+ *   check `prev===hashInicial` de la entrada-0 es tautológico si `hashInicial`
+ *   viene del propio checkpoint auto-derivado. Un consumidor que quiera probar
+ *   la continuidad archivo↔activo debe recomputar independientemente el hash de
+ *   la última entrada del `.gz` archivado y verificar que coincide con
+ *   `hashInicial`. La fuerza criptográfica de la cadena depende de `_hash`
+ *   (ver su docstring): SHA256 plano (accidental) o HMAC con `SWL_AUDIT_HMAC_KEY`
+ *   (defensa contra manipulación a nivel de archivo sin la clave del env).
+ *   verificarCadena usa la MISMA función `_hash`, así que recomputa con la
+ *   clave activa del env — verificar con la clave con que se escribió.
+ */
+function verificarCadena(rutaArchivo, opts = {}) {
   if (!fs.existsSync(rutaArchivo)) return { valido: true, entradas: 0 };
 
   const contenido = fs.readFileSync(rutaArchivo, 'utf8').trim();
   const lineas = contenido.split('\n').filter(Boolean);
-  let hashEsperado = '0'.repeat(64);
+  let hashEsperado = (typeof opts.hashInicial === 'string' && opts.hashInicial)
+    ? opts.hashInicial
+    : '0'.repeat(64);
   let roturaEn = -1;
 
   for (let i = 0; i < lineas.length; i++) {
@@ -73,7 +125,7 @@ function verificarCadena(rutaArchivo) {
       }
       const { hash: storedHash, ...resto } = entrada;
       const payloadRecalc = JSON.stringify(resto);
-      const hashRecalc = _sha256(payloadRecalc);
+      const hashRecalc = _hash(payloadRecalc);
       if (hashRecalc !== storedHash) {
         roturaEn = i;
         break;

package/hooks/lib/notificacion-formato.js

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * notificacion-formato.js — Formato del cuerpo de las notificaciones.
+ *
+ * Módulo sin efectos secundarios (solo funciones puras), separado del hook
+ * `notificacion-telegram.js` para poder unit-testearlo sin disparar el `run()`
+ * del hook (que se ejecuta al `require`, porque los hooks se invocan vía el
+ * wrapper `node -e "require('./hooks/X.js')"` — no admiten gate de entrypoint).
+ *
+ * Zero-deps.
+ *
+ * @module hooks/lib/notificacion-formato
+ */
+
+/**
+ * Resume el último mensaje del asistente para una notificación: una alerta debe
+ * ser un extracto BREVE y legible, no el volcado crudo del mensaje completo (que
+ * mete tablas markdown, encabezados y cientos de líneas). Quita el ruido
+ * estructural de markdown (fences de código, filas de tabla, reglas horizontales)
+ * y el markdown inline (negritas, itálicas, código, enlaces, viñetas), y trunca a
+ * `maxChars`.
+ *
+ * @param {string} texto - Mensaje completo del asistente (markdown).
+ * @param {number} [maxChars=400] - Largo máximo del extracto.
+ * @returns {string} Extracto limpio y corto en texto plano.
+ */
+function resumirParaNotificacion(texto, maxChars = 400) {
+  if (!texto) return '';
+  const limpias = [];
+  let enFence = false;
+  for (const raw of String(texto).split(/\r?\n/)) {
+    const l = raw.trim();
+    if (/^```/.test(l)) { enFence = !enFence; continue; } // abre/cierra bloque de código
+    if (enFence) continue;                                 // omitir contenido de código
+    if (/^\|.*\|$/.test(l)) continue;                      // omitir filas de tabla
+    if (/^[-=_*]{3,}$/.test(l)) continue;                  // omitir reglas horizontales
+    if (l === '') {
+      if (limpias.length && limpias[limpias.length - 1] !== '') limpias.push('');
+      continue;
+    }
+    const t = l
+      .replace(/^#{1,6}\s+/, '')                 // encabezados
+      .replace(/^>\s?/, '')                      // citas
+      .replace(/^[-*+]\s+/, '• ')                // viñetas → •
+      .replace(/^\d+\.\s+/, '')                  // listas numeradas
+      .replace(/\*\*([^*]+)\*\*/g, '$1')         // negritas
+      .replace(/(^|[^*])\*([^*]+)\*/g, '$1$2')   // itálicas
+      .replace(/`([^`]+)`/g, '$1')               // código inline
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');  // enlaces → texto
+    limpias.push(t);
+  }
+  const resumen = limpias.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+  if (resumen.length <= maxChars) return resumen;
+  return resumen.slice(0, maxChars - 1).trimEnd() + '…';
+}
+
+module.exports = { resumirParaNotificacion };

package/hooks/lib/nudge-tracker.js

@@ -22,6 +22,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
 // Escritura atómica para reescritura completa del JSONL (marcar accionado).
@@ -45,7 +46,7 @@ try {
 // Configuración
 // ---------------------------------------------------------------------------
 
-const DIR_EVOL = path.join(process.cwd(), '.planning', 'evolution');
+const DIR_EVOL = path.join(raizProyecto(process.cwd()), '.planning', 'evolution');
 const LOG_PATH = path.join(DIR_EVOL, 'nudges.jsonl');
 const ALERT_PATH = path.join(DIR_EVOL, 'alertas-persistentes.json');
 

package/hooks/lib/otlp-exporter.js

@@ -19,6 +19,7 @@
  */
 
 const fs     = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path   = require('path');
 const crypto = require('crypto');
 const http   = require('http');
@@ -277,7 +278,7 @@ class OtlpLocalProcessor extends TracingProcessor {
   constructor(cwd) {
     super();
     /** @type {string} */
-    this._cwd = String(cwd || process.cwd());
+    this._cwd = String(cwd || raizProyecto(process.cwd()));
   }
 
   /**

package/hooks/lib/propose-step.js

@@ -20,6 +20,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
@@ -209,7 +210,7 @@ const UMBRAL = {
 };
 
 function telemetriaPath(baseDir) {
-  return path.join(baseDir || process.cwd(), ...TELE_PATH);
+  return path.join(baseDir || raizProyecto(process.cwd()), ...TELE_PATH);
 }
 
 function _catVacia() {
@@ -332,7 +333,7 @@ function main(argv) {
   for (const a of args) {
     if (a.startsWith('--rango=')) rango = a.slice('--rango='.length);
   }
-  const baseDir = process.cwd();
+  const baseDir = raizProyecto(process.cwd());
   const { paths, diff } = _gitDiff(rango);
   const { señales } = evaluarSenales(paths, diff);
   registrarPropose(baseDir, señales);

package/hooks/lib/raiz-proyecto.js

@@ -0,0 +1,127 @@
+'use strict';
+
+/**
+ * raiz-proyecto.js — Resolución de la raíz del proyecto para hooks que
+ * escriben telemetría/memoria en `.planning/`.
+ *
+ * El CWD de arranque de una sesión NO es la frontera del proyecto: en un
+ * monorepo con sesiones abiertas en subdirectorios (`backend/`, `frontend/`),
+ * anclar `.planning/` a `process.cwd()` fragmenta la memoria del proyecto en
+ * árboles huérfanos (DT-HOOKS-RAIZ-GIT; misma clase que el fix de
+ * proteccion-rutas). La frontera correcta es la raíz del repositorio git,
+ * con una excepción: un sub-proyecto anidado que ya tiene su propio
+ * `.planning/` REAL (con marcadores de proyecto) conserva su árbol local.
+ *
+ * Reglas de resolución (en orden):
+ *   1. Ascendiendo desde `desde`, el primer directorio cuyo `.planning/`
+ *      contiene un marcador de proyecto (PROYECTO.md, HOJA-RUTA.md,
+ *      ESTADO.md) gana — respeta sub-proyectos legítimos en monorepos.
+ *      Un `.planning/` sin marcadores (solo telemetría huérfana de hooks)
+ *      NO cuenta: eso es el síntoma del bug, no un proyecto.
+ *   2. Si ningún nivel tiene `.planning/` real, gana la raíz del repo git
+ *      (`.git` como directorio o como archivo — worktrees).
+ *   3. Sin `.git` alcanzable: fallback al propio `desde`.
+ *
+ * La ascensión se detiene en el HOME del usuario (sin incluirlo) cuando se
+ * llega ahí subiendo: un dotfiles-repo en `~` — o un `~/.planning` sembrado
+ * por `swl-ses doctor` en una instalación global — no debe capturar la
+ * memoria de un proyecto sin git que viva debajo. La comparación con el HOME
+ * se hace en forma CANÓNICA (realpath): en Windows `os.tmpdir()` puede
+ * devolver el nombre corto 8.3 (`C:\Users\SAUL~1.WAD`) mientras `os.homedir()`
+ * devuelve el largo (`C:\Users\saul.wade`); sin canonicalizar, la frontera no
+ * dispararía y capturaría `~/.planning` o `~/.git` (rompía 38 tests locales
+ * en Windows, verde en CI Linux porque `/tmp` no cuelga de `$HOME`).
+ *
+ * Zero-deps (regla de hooks/lib/). Consumidor inicial:
+ * hooks/extraccion-aprendizajes.js; la flota completa migró el 2026-07-10
+ * (cierre de DT-HOOKS-RAIZ-GIT).
+ *
+ * LÍMITE DE USO (hallazgo revisor-seguridad 2026-07-10): esta ancla es SOLO
+ * para DATOS (.planning/, instintos/, lecturas de config del proyecto).
+ * NUNCA resolver con ella EJECUTABLES ni módulos a require()/spawn(): la
+ * raíz resuelta pertenece al árbol del proyecto, y un repositorio no
+ * confiable puede plantar el script (marcador .planning/PROYECTO.md +
+ * scripts/x.js hostil = ejecución de código al disparar el hook). Los
+ * ejecutables de la distribución SWL se resuelven desde __dirname
+ * (ubicación instalada del hook). Test guardián:
+ * tests/hooks/ejecutables-desde-instalacion.test.js.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MARCADORES_PROYECTO = ['PROYECTO.md', 'HOJA-RUTA.md', 'ESTADO.md'];
+const MAX_NIVELES = 40;
+
+/**
+ * ¿El directorio tiene un `.planning/` de proyecto real (no huérfano)?
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function tienePlanningReal(dir) {
+  try {
+    return MARCADORES_PROYECTO.some(m =>
+      fs.existsSync(path.join(dir, '.planning', m))
+    );
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Canonicaliza un path resolviendo enlaces simbólicos y el nombre corto 8.3
+ * de Windows (`C:\Users\SAUL~1.WAD` → `C:\Users\saul.wade`). Solo se usa para
+ * la comparación de la frontera del HOME: el valor de RETORNO de raizProyecto
+ * conserva la forma del argumento recibido, no la canónica. Si el path no
+ * existe (no se puede resolver), cae a `path.resolve`.
+ * @param {string} p
+ * @returns {string}
+ */
+function canonicalizar(p) {
+  try {
+    return fs.realpathSync.native(p);
+  } catch (_) {
+    return path.resolve(p);
+  }
+}
+
+/**
+ * Resuelve la raíz del proyecto a la que deben anclarse las escrituras
+ * de `.planning/`.
+ *
+ * @param {string} [desde] - Directorio de partida (default: process.cwd()).
+ * @returns {string} Ruta absoluta de la raíz del proyecto.
+ */
+function raizProyecto(desde) {
+  const inicio = path.resolve(desde || process.cwd());
+  let actual = inicio;
+  let homedirCanon = null;
+  try {
+    homedirCanon = canonicalizar(path.resolve(os.homedir()));
+  } catch (_) { /* sin home resolvible — seguir sin el guard */ }
+
+  for (let i = 0; i < MAX_NIVELES; i++) {
+    // Frontera del HOME: si llegamos aquí ASCENDIENDO, no seguir — un
+    // dotfiles-repo (o un ~/.planning sembrado por doctor) en ~ no es la raíz
+    // de un proyecto que vive debajo. Comparación canónica: iguala el nombre
+    // corto 8.3 heredado de os.tmpdir() con el HOME largo de os.homedir().
+    if (homedirCanon && i > 0 && canonicalizar(actual) === homedirCanon) break;
+
+    if (tienePlanningReal(actual)) return actual;
+
+    try {
+      if (fs.existsSync(path.join(actual, '.git'))) return actual;
+    } catch (_) {
+      break;
+    }
+
+    const padre = path.dirname(actual);
+    if (padre === actual) break; // raíz del filesystem
+    actual = padre;
+  }
+
+  return inicio;
+}
+
+module.exports = { raizProyecto, tienePlanningReal, canonicalizar };

package/hooks/lib/run-log.js

@@ -38,6 +38,7 @@
  */
 
 const fs      = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path    = require('path');
 const readline = require('readline');
 const os      = require('os');
@@ -50,7 +51,7 @@ const os      = require('os');
  * Directorio donde se almacenan los JSONL de runs.
  * Relativo al cwd del proceso (raíz del proyecto SWL).
  */
-const RUNS_DIR = path.join(process.cwd(), '.planning', 'runs');
+const RUNS_DIR = path.join(raizProyecto(process.cwd()), '.planning', 'runs');
 
 /**
  * Número máximo de runs a mantener por directorio.