@saulwade/swl-ses 2.5.3 → 2.6.1

package/hooks/session-briefing.js

@@ -19,7 +19,9 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
+const { spawn } = require('child_process');
 
 // Require con fallback dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`
 // en el destino, pero en el repo madre vive en `lib/`. Cubre ambos layouts (D-17).
@@ -32,6 +34,116 @@ function requireDual(nombre) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Fallback de disparo del ciclo autónomo (Fase 21, T-11, ADR-0041/0042,
+// REQ-21-11). El scheduler cron (`gateway/cron/jobs.example.json`) es el
+// disparador primario de la Fase A; este fallback cubre proyectos sin
+// scheduler configurado, disparando desde el propio SessionStart cuando toca.
+//
+// Fuera de alcance intencional en instalaciones destino (Fase 26): las libs
+// `scripts/lib/ciclo-autonomo/*.js` viajan en `hooks-core` (resuelven cross-dir
+// igual que `git-metricas`/`npm-version`), pero el wrapper `scripts/cli/
+// ciclo-autonomo.js` se distribuye SOLO por `package.json#files` — en destino
+// puede no resolver. Cuando no resuelve: silencio, nunca crashea el hook.
+// ---------------------------------------------------------------------------
+
+/**
+ * Resuelve la lib pura de decisión del fallback (`scripts/lib/ciclo-autonomo/
+ * fallback.js`). Dual: repo madre / destino copy-mode (`../scripts/lib/...`)
+ * vs destino aplanado (`./lib/ciclo-autonomo/fallback`, mismo criterio que
+ * `hooks/check-update.js` con `scripts/lib/npm-version.js`). Ausente → null.
+ */
+function resolverFallbackCiclo() {
+  try {
+    return require('../scripts/lib/ciclo-autonomo/fallback');
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    try {
+      return require('./lib/ciclo-autonomo/fallback');
+    } catch (e2) {
+      if (e2 && e2.code !== 'MODULE_NOT_FOUND') throw e2;
+      return null;
+    }
+  }
+}
+
+/**
+ * Resuelve la ruta absoluta del wrapper CLI del ciclo
+ * (`scripts/cli/ciclo-autonomo.js`) SIN requerirlo — `require.resolve` nunca
+ * ejecuta el módulo, evita cargar en este proceso el árbol completo del ciclo
+ * (config/lock/writer/drenador/puente) solo para calcular un path.
+ */
+function resolverRutaCliCiclo() {
+  try {
+    return require.resolve('../scripts/cli/ciclo-autonomo');
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    try {
+      return require.resolve('./lib/ciclo-autonomo/ciclo-autonomo');
+    } catch (e2) {
+      if (e2 && e2.code !== 'MODULE_NOT_FOUND') throw e2;
+      return null;
+    }
+  }
+}
+
+/**
+ * Dispara la Fase A del ciclo autónomo en un proceso separado
+ * (fire-and-forget, `detached` + `unref`) cuando el motor está habilitado y
+ * pasaron >=24h desde la última corrida (o nunca corrió). Guard barato
+ * PRIMERO: si no existe `.planning/evolution/ciclo-config.json`, retorna sin
+ * requerir ninguna lib del ciclo — la inmensa mayoría de proyectos nunca lo
+ * habilitó y el presupuesto de este hook (<200ms) no debe pagar ese costo.
+ * El hook NO espera el resultado; el lock propio del ciclo (T-02) garantiza
+ * que no haya doble corrida con el scheduler cron.
+ */
+function dispararCicloAutonomoSiToca(cwd, hoy) {
+  if (!fs.existsSync(path.join(cwd, '.planning', 'evolution', 'ciclo-config.json'))) return;
+
+  const fallback = resolverFallbackCiclo();
+  if (!fallback) return;
+
+  const { disparar } = fallback.debeDisparar(cwd, { ahora: hoy });
+  if (!disparar) return;
+
+  const rutaCli = resolverRutaCliCiclo();
+  if (!rutaCli) return; // no resuelve en esta instalación: silencio, nunca crashea
+
+  spawn(
+    process.execPath,
+    ['-e', `require(${JSON.stringify(rutaCli)})({})`],
+    { detached: true, stdio: 'ignore', cwd }
+  ).unref();
+}
+
+/** Texto de un archivo o `null` si no existe / no se puede leer. */
+function leerTextoSeguro(p) {
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Línea de resumen de la última corrida del ciclo autónomo para el digest,
+ * cuando `ciclo-config.json` existe y tiene `ultima_corrida` registrada.
+ */
+function lineaResumenCiclo(cwd) {
+  const txt = leerTextoSeguro(path.join(cwd, '.planning', 'evolution', 'ciclo-config.json'));
+  if (!txt) return null;
+  let cfg;
+  try {
+    cfg = JSON.parse(txt);
+  } catch (_) {
+    return null;
+  }
+  const u = cfg && cfg.ultima_corrida;
+  if (!u) return null;
+  return `Ciclo autónomo: última corrida ${cfg.last_run || 'desconocida'} — ` +
+    `promovió ${u.promovidos || 0}, degradó ${u.degradados || 0}, drenó ${u.drenados || 0}`;
+}
+
 let briefing;
 let atomicWriteJSON;
 try {
@@ -53,7 +165,7 @@ process.stdin.on('end', () => {
     if (process.env.SWL_BRIEFING === '0') return; // opt-out
     if (!briefing) return;                          // lib ausente: degradar a silencio
 
-    const cwd = process.cwd();
+    const cwd = raizProyecto(process.cwd());
     if (!fs.existsSync(path.join(cwd, '.planning'))) return; // zero-config
 
     const hoy = new Date();
@@ -78,8 +190,22 @@ process.stdin.on('end', () => {
     const digest = briefing.armarDigest(items, estadoPrevio, dia, {
       categoriasSilenciadas: silenciadas,
     });
+
+    // Fallback de disparo del ciclo autónomo (Fase 21, T-11, REQ-21-11): aislado
+    // en su propio try/catch y evaluado ANTES del early-return de silencio total
+    // — es una acción de fondo independiente de si hay señales que mostrar hoy.
+    try {
+      dispararCicloAutonomoSiToca(cwd, hoy);
+    } catch (_) { /* fire-and-forget best-effort: nunca bloquear la sesión */ }
+
     if (!digest) return; // silencio total: sin señales nuevas
 
+    // Línea de resumen del ciclo autónomo (si hubo corrida reciente registrada).
+    try {
+      const lineaCiclo = lineaResumenCiclo(cwd);
+      if (lineaCiclo) digest.texto = `${digest.texto}\n${lineaCiclo}`;
+    } catch (_) { /* best-effort: no romper el digest por esto */ }
+
     // Persistir el estado de dedupe (best-effort).
     try {
       const dir = path.join(cwd, '.planning', 'user-profile');

package/hooks/spec-gate.js

@@ -32,6 +32,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -180,7 +181,7 @@ function main() {
     process.exit(0);
   }
 
-  const cwd = process.cwd();
+  const cwd = raizProyecto(process.cwd());
   const toolName = evento?.tool_name;
   const filePath = evento?.tool_input?.file_path;
 

package/hooks/sugerir-contribuir.js

@@ -33,6 +33,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 let isPackageRoot, readEvolutionMeta;
@@ -52,7 +53,7 @@ const CARPETAS_EVOLUCIONABLES = [
 ];
 
 const STATE_FILE = path.join(
-  process.cwd(),
+  raizProyecto(process.cwd()),
   '.planning',
   'comms',
   'sugerir-contribuir-cooldown.json'
@@ -68,7 +69,7 @@ function rutaRelativaAlProyecto(rutaRaw) {
   let normalizada = normalizarSeparadores(rutaRaw);
 
   if (path.isAbsolute(normalizada)) {
-    const cwd = normalizarSeparadores(process.cwd());
+    const cwd = normalizarSeparadores(raizProyecto(process.cwd()));
     if (normalizada.toLowerCase().startsWith(cwd.toLowerCase())) {
       normalizada = normalizada.slice(cwd.length).replace(/^\/+/, '');
     } else {
@@ -174,7 +175,9 @@ function evaluar(toolName, toolInput) {
   if (!ruta) return null;
   if (!esEvolucionable(ruta)) return null;
 
-  const rutaAbsoluta = path.isAbsolute(rutaRaw) ? rutaRaw : path.join(process.cwd(), ruta);
+  // `ruta` ya es relativa a la raíz del proyecto (rutaRelativaAlProyecto la
+  // despoja contra esa misma ancla) — reconstruir contra la raíz, no el cwd.
+  const rutaAbsoluta = path.isAbsolute(rutaRaw) ? rutaRaw : path.join(raizProyecto(process.cwd()), ruta);
   if (!fs.existsSync(rutaAbsoluta)) return null;
 
   const evo = readEvolutionMeta(rutaAbsoluta);

package/hooks/sugerir-regenerar-inventario.js

@@ -27,6 +27,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 // Carpetas cuyo cambio invalida los contadores de INVENTARIO.md
@@ -38,7 +39,7 @@ const CARPETAS_INVENTARIADAS = [
   { ruta: 'reglas/',       etiqueta: 'reglas' },
 ];
 
-const STATE_FILE = path.join(process.cwd(), '.planning', 'inventario-aviso-state.json');
+const STATE_FILE = path.join(raizProyecto(process.cwd()), '.planning', 'inventario-aviso-state.json');
 const COOLDOWN_MS = 30 * 60 * 1000; // 30 min
 
 function normalizarSeparadores(p) {
@@ -52,7 +53,7 @@ function detectarCarpeta(rutaRaw) {
   // Solo nos interesan rutas relativas al proyecto. Si es absoluta, intentamos
   // hacerla relativa al CWD actual.
   if (path.isAbsolute(normalizada)) {
-    const cwd = normalizarSeparadores(process.cwd());
+    const cwd = normalizarSeparadores(raizProyecto(process.cwd()));
     if (normalizada.toLowerCase().startsWith(cwd.toLowerCase())) {
       normalizada = normalizada.slice(cwd.length).replace(/^\/+/, '');
     } else {

package/hooks/tdd-gate.js

@@ -30,6 +30,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
@@ -209,7 +210,7 @@ function main() {
 
   if (evento?.tool_name !== 'Bash') process.exit(0);
   const comando = evento?.tool_input?.command;
-  const cwd = process.cwd();
+  const cwd = raizProyecto(process.cwd());
 
   // Zero-config: sin .planning/ no hay ciclo GSD que vigilar.
   if (!fs.existsSync(path.join(cwd, '.planning'))) process.exit(0);

package/hooks/telemetria-agentes.js

@@ -17,6 +17,7 @@
  */
 
 const { registrar } = require('./lib/otlp-exporter');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 
 // Importar esquema de spans con guard de robustez — el hook no debe fallar
 // si el módulo aún no existe en instalaciones anteriores del sistema.
@@ -27,7 +28,7 @@ try {
   // Módulo no disponible — continuar sin tipado de span
 }
 
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 
 // ---------------------------------------------------------------------------
 // Mapping de eventos a tipos de span

package/hooks/telemetria-skill-routing.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+const { raizProyecto } = require('./lib/raiz-proyecto');
 
 /**
  * Hook: telemetria-skill-routing.js
@@ -91,7 +92,7 @@ if (!require.main || require.main === module) {
     process.stdin.on('data', (chunk) => { inputRaw += chunk; });
     process.stdin.on('end', () => {
       try {
-        procesar(JSON.parse(inputRaw), process.cwd());
+        procesar(JSON.parse(inputRaw), raizProyecto(process.cwd()));
       } catch (_) {
         // Silencioso — nunca interrumpir la sesión por un fallo de telemetría.
       }

package/hooks/tracking-costos.js

@@ -21,6 +21,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const os   = require('os');
 
@@ -75,10 +76,10 @@ const PRESUPUESTO_DEFAULT = {
 };
 
 /** Ruta del manifesto de configuración de hooks. */
-const RUTA_HOOKS_CONFIG = path.join(process.cwd(), 'manifiestos', 'hooks-config.json');
+const RUTA_HOOKS_CONFIG = path.join(raizProyecto(process.cwd()), 'manifiestos', 'hooks-config.json');
 
 /** Ruta del archivo de métricas de sesión. */
-const RUTA_METRICS = path.join(process.cwd(), '.planning', 'METRICAS.md');
+const RUTA_METRICS = path.join(raizProyecto(process.cwd()), '.planning', 'METRICAS.md');
 
 // ---------------------------------------------------------------------------
 // Utilidades de configuración
@@ -673,7 +674,7 @@ process.stdin.on('end', () => {
     if (estado.toolCalls % INTERVALO_ACTUALIZACION === 0) {
       try {
         const { actualizarSesion } = require('./lib/session-store');
-        const cwd = process.cwd();
+        const cwd = raizProyecto(process.cwd());
         actualizarSesion(cwd, {
           toolCall: toolName,
           tokensEstimated: estado.tokensTotal,

package/hooks/validar-formato-post-subagente.js

@@ -23,9 +23,10 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const SCHEMAS_PATH = path.join(CWD, 'manifiestos', 'agent-output-schemas.json');
 const LOG_PATH     = path.join(CWD, '.planning', 'evolution', 'formato-violaciones.jsonl');
 

package/hooks/validar-intent-spec.js

@@ -44,6 +44,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -188,7 +189,7 @@ if (faltan.length === 0) {
 }
 
 // ─── Emitir nudge ─────────────────────────────────────────────────────────
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const rutaRelativa = path.relative(CWD, filePath).replace(/\\/g, '/');
 const nombreAgente = path.basename(filePath, '.md');
 

package/hooks/validar-memoria-hook.js

@@ -34,6 +34,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
@@ -49,8 +50,17 @@ const ARCHIVOS_MEMORIA = [
   'instintos/global.yaml',
 ];
 
-/** Path del validador. */
-const VALIDADOR = path.join(process.cwd(), 'scripts', 'validar-memoria.js');
+/**
+ * Path del validador — EJECUTABLE de la distribución SWL: se resuelve SOLO
+ * desde la ubicación instalada del hook (__dirname), NUNCA desde el árbol
+ * del proyecto (un repo no confiable podría plantar el script; hallazgo
+ * revisor-seguridad 2026-07-10). Los DATOS que valida sí anclan a la raíz
+ * del proyecto (cwd del spawn).
+ */
+const VALIDADOR = [
+  path.join(__dirname, '..', 'scripts', 'validar-memoria.js'), // repo madre
+  path.join(__dirname, 'validar-memoria.js'),                  // destino aplanado
+].find(p => { try { return fs.existsSync(p); } catch (_) { return false; } }) || '';
 
 /** Timeout para el validador (ms). Si tarda más, se aborta sin bloquear. */
 const TIMEOUT_MS = 5000;
@@ -106,7 +116,7 @@ function ejecutarValidador() {
   if (!fs.existsSync(VALIDADOR)) return null;
   try {
     const r = spawnSync(process.execPath, [VALIDADOR, '--json'], {
-      cwd: process.cwd(),
+      cwd: raizProyecto(process.cwd()),
       encoding: 'utf8',
       timeout: TIMEOUT_MS,
       windowsHide: true,

package/hooks/validar-planning-paths.js

@@ -19,6 +19,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -76,7 +77,7 @@ const DIRS_CANONICOS = [
 ];
 
 // ─── Cargar allowlist (manifest si existe, embebida si no) ──────────────────
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const allowlistPath = path.join(CWD, 'manifiestos', 'planning-paths.json');
 let permitidos;
 try {