@saulwade/swl-ses 2.2.4 → 2.3.1

package/habilidades/validacion-ci-sistema/recursos/validadores-completos.md

@@ -14,7 +14,7 @@ import { readFileSync } from 'fs';
 const CAMPOS_AGENTE = {
   obligatorios: ['name', 'description'],
   opcionales: {
-    model:          ['claude-opus-4-5', 'claude-sonnet-4-6', 'claude-haiku-3-5'],
+    model:          ['opus', 'sonnet', 'haiku', 'inherit'],
     permissionMode: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
     color:          ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'cyan', 'white'],
   },

package/habilidades/validacion-ci-sistema/scripts/validar-sistema.sh

@@ -57,7 +57,7 @@ section "1. Agentes (frontmatter)"
 
 CAMPOS_OBLIGATORIOS_AGENTE=("name" "description")
 # Campos opcionales pero que deben tener valores válidos si están presentes
-MODELOS_VALIDOS=("claude-opus-4-5" "claude-sonnet-4-6" "claude-haiku-3-5")
+MODELOS_VALIDOS=("opus" "sonnet" "haiku" "inherit")
 PERMISOS_VALIDOS=("default" "acceptEdits" "bypassPermissions" "plan")
 COLORES_VALIDOS=("red" "orange" "yellow" "green" "blue" "purple" "cyan" "white")
 

package/hooks/captura-acciones-post.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: captura-acciones-post.js
+ * Tipo: PostToolUse (todas las herramientas)
+ *
+ * Pobla el estado que el hook SessionStart (`captura-acciones-session.js`)
+ * consumirá para detectar señales de acción del usuario (Fase 17):
+ *   - `git commit` del agente → registra el SHA en agent-commits.jsonl
+ *     (base para detectar revert/reset; sin co-author, regla git-coauthor.md).
+ *   - `Write`/`Edit`/`MultiEdit` → registra el hash del archivo en
+ *     agent-writes-index.json (base para detectar edición neta del usuario).
+ *   - `Read` de un archivo que el agente escribió cuyo contenido en disco
+ *     difiere → encola `edicion-manual` en caliente (REQ-17-03).
+ *
+ * Zero-deps salvo la lib `captura-acciones`. Opt-out unificado
+ * SWL_CAPTURAR_FEEDBACK=0. Exit 0 SIEMPRE; nunca bloquea ni muestra al modelo.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// Require con fallback dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`.
+// (Idioma compartido con session-briefing.js/propose-step.js; no se extrae a lib
+// porque cargar esa lib requeriría a su vez el mismo fallback — paradoja de
+// bootstrap del aplanado.)
+function requireDual(nombre) {
+  try {
+    return require(`./lib/${nombre}`);
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    return require(`./${nombre}`);
+  }
+}
+
+let lib;
+try {
+  lib = requireDual('captura-acciones');
+} catch (_) {
+  lib = null;
+}
+
+// Preview crudo amplio: se pasa a encolarAccion para que la sanitización corra
+// sobre el texto íntegro (un bloque PEM cabe) ANTES del truncado final a
+// MAX_EVIDENCIA_LEN. Pre-truncar aquí derrotaría el patrón PEM (sec BAJA-2).
+const PREVIEW_RAW = 4096;
+
+/**
+ * Convierte una ruta (abs o rel) a relativa POSIX respecto a baseDir; null si
+ * escapa. Guard léxico (path.relative): rechaza `..` y rutas absolutas. NO
+ * resuelve symlinks — la defensa real es la sanitización + el confinamiento por
+ * índice + que el contenido se trata como dato (nunca se ejecuta); aceptable
+ * para tooling de dev donde el usuario es dueño del repo (sec BAJA-3).
+ */
+function relPosix(baseDir, filePath) {
+  if (!filePath) return null;
+  const abs = path.isAbsolute(filePath) ? filePath : path.resolve(baseDir, filePath);
+  const rel = path.relative(baseDir, abs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join('/');
+}
+
+function _leer(baseDir, rel) {
+  try {
+    return fs.readFileSync(path.resolve(baseDir, rel), 'utf8');
+  } catch (_) {
+    return null;
+  }
+}
+
+/** (a) git commit del agente → registrar SHA. */
+function _manejarCommit(input, sessionId, baseDir) {
+  if (typeof input.command !== 'string' || !/\bgit\s+commit\b/.test(input.command)) return;
+  let sha = '';
+  try {
+    sha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: baseDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch (_) {
+    sha = '';
+  }
+  if (sha) lib.registrarCommitAgente(baseDir, { sessionId, sha });
+}
+
+/** (b) Write/Edit/MultiEdit → registrar hash del archivo tras la escritura. */
+function _manejarEscritura(input, sessionId, baseDir) {
+  const rel = relPosix(baseDir, input.file_path);
+  if (!rel) return;
+  const contenido = _leer(baseDir, rel);
+  if (contenido === null) return;
+  lib.registrarEscrituraAgente(baseDir, rel, contenido, { sessionId });
+}
+
+/** (c) Read de archivo escrito por el agente cuyo contenido difiere → edición manual. */
+function _manejarLectura(input, sessionId, baseDir) {
+  const rel = relPosix(baseDir, input.file_path);
+  if (!rel) return;
+  const indice = lib.leerIndiceWrites(baseDir);
+  if (!indice[rel]) return;
+  const contenido = _leer(baseDir, rel);
+  if (contenido === null) return;
+  if (lib.detectarEdicionManual(rel, contenido, indice)) {
+    lib.encolarAccion(baseDir, {
+      accion: 'edicion-manual',
+      archivo: rel,
+      evidencia: contenido.slice(0, PREVIEW_RAW),
+      sessionId,
+    });
+  }
+}
+
+/**
+ * Procesa un evento PostToolUse. Orquesta los 3 handlers según la herramienta.
+ * @param {object} data    payload del hook (tool_name, tool_input, session_id...)
+ * @param {string} baseDir raíz del proyecto.
+ */
+function procesarTurno(data, baseDir) {
+  if (process.env.SWL_CAPTURAR_FEEDBACK === '0') return;
+  if (!lib || !data) return;
+  const toolName = String(data.tool_name || data.tool?.name || '');
+  if (!toolName) return;
+  const sessionId = String(data.session_id || 'default');
+  const input = data.tool_input || data.tool?.input || {};
+  try {
+    if (toolName === 'Bash') {
+      _manejarCommit(input, sessionId, baseDir);
+    } else if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
+      if (input.file_path) _manejarEscritura(input, sessionId, baseDir);
+    } else if (toolName === 'Read') {
+      if (input.file_path) _manejarLectura(input, sessionId, baseDir);
+    }
+  } catch (_) {
+    /* nunca bloquear */
+  }
+}
+
+// Listeners de stdin SOLO en modo CLI (evita colgar la suite de tests).
+if (require.main === module) {
+  let inputRaw = '';
+  process.stdin.on('data', (c) => { inputRaw += c; });
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(inputRaw);
+      procesarTurno(data, process.cwd());
+    } catch (_) {
+      /* silencioso */
+    }
+  });
+} else {
+  module.exports = { procesarTurno, relPosix };
+}

package/hooks/captura-acciones-session.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: captura-acciones-session.js
+ * Tipo: SessionStart
+ *
+ * Al abrir sesión en un repo git con `.planning/`, contrasta el git real contra
+ * los índices que pobló `captura-acciones-post.js` (PostToolUse) para detectar
+ * señales de ACCIÓN del usuario ocurridas fuera de sesión (Fase 17):
+ *   - revert/reset de commits del agente (SHA registrado ausente del historial),
+ *   - edición neta de archivos que el agente escribió (hash en disco ≠ registrado),
+ *   - rechazo de plan (PLAN en borrador sin lock G1 con fase cerrada),
+ *   - override de veredicto (VERIFICACION no-aprobatoria — caso determinista).
+ *
+ * Encola en el mismo `feedback-queue.jsonl` con `tipo:"accion"`. A diferencia
+ * del briefing (Fase 12), este hook NO emite `additionalContext`: solo persiste
+ * señales (alcance Fase 17 = capturar + telemetría). Zero-deps salvo la lib.
+ * Opt-out SWL_CAPTURAR_FEEDBACK=0. Skip si no hay repo git (REQ-17-11). Exit 0.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// Require dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`. (Idioma
+// compartido; no se extrae a lib por la paradoja de bootstrap del aplanado.)
+function requireDual(nombre) {
+  try {
+    return require(`./lib/${nombre}`);
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    return require(`./${nombre}`);
+  }
+}
+
+let lib;
+try {
+  lib = requireDual('captura-acciones');
+} catch (_) {
+  lib = null;
+}
+
+const PREVIEW_RAW = 4096; // ver nota en captura-acciones-post.js (no derrotar PEM)
+const SHA_PREFIX_LEN = 12; // < 32 chars: no dispara PATRONES_REDACT[0] del sanitizador
+const MAX_LOG = 2000; // horizonte de git log; el agente no registra commits previos a ~5 años
+
+function esRepoGit(baseDir) {
+  try {
+    execFileSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: baseDir, stdio: 'ignore' });
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+function historialShas(baseDir) {
+  try {
+    return execFileSync('git', ['log', `--max-count=${MAX_LOG}`, '--format=%H'], { cwd: baseDir, encoding: 'utf8' })
+      .split(/\r?\n/)
+      .filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+/** (1) Revert/reset de commits del agente — REQ-17-01. */
+function _encolarReverts(baseDir) {
+  const reverts = lib.detectarRevert(lib.leerCommitsAgente(baseDir), historialShas(baseDir));
+  for (const sha of reverts) {
+    lib.encolarAccion(baseDir, { accion: 'revert', evidencia: `commit ${sha.slice(0, SHA_PREFIX_LEN)} ausente del historial actual` });
+  }
+  return reverts.length;
+}
+
+/** (2) Edición neta de archivos escritos por el agente — REQ-17-02. */
+function _encolarEdicionesNetas(baseDir) {
+  const indice = lib.leerIndiceWrites(baseDir);
+  const hashActual = {};
+  for (const rel of Object.keys(indice)) {
+    try {
+      hashActual[rel] = lib.hashContenido(fs.readFileSync(path.resolve(baseDir, rel), 'utf8'));
+    } catch (_) {
+      /* archivo borrado/ilegible → detectarEdicionNeta lo ignora */
+    }
+  }
+  const netas = lib.detectarEdicionNeta(indice, hashActual);
+  for (const rel of netas) {
+    let ev = '';
+    try {
+      ev = fs.readFileSync(path.resolve(baseDir, rel), 'utf8').slice(0, PREVIEW_RAW);
+    } catch (_) {
+      /* sin evidencia */
+    }
+    lib.encolarAccion(baseDir, { accion: 'edicion-manual', archivo: rel, evidencia: ev });
+  }
+  return netas.length;
+}
+
+/** (3) Rechazo de plan — REQ-17-04. */
+function _encolarPlanesRechazados(baseDir) {
+  const señales = lib.detectarPlanRechazado(baseDir);
+  for (const s of señales) {
+    lib.encolarAccion(baseDir, { accion: 'plan-rechazado', archivo: s.archivo, evidencia: `plan de fase ${s.fase} en borrador sin lock G1` });
+  }
+  return señales.length;
+}
+
+/** (4) Override de veredicto — REQ-17-05 (caso determinista). */
+function _encolarVeredictosOverride(baseDir) {
+  const señales = lib.detectarVeredictoOverride(baseDir);
+  for (const s of señales) {
+    lib.encolarAccion(baseDir, { accion: 'veredicto-override', archivo: s.archivo, evidencia: `veredicto ${s.veredicto} en ${s.archivo}` });
+  }
+  return señales.length;
+}
+
+/**
+ * Inspecciona el repo y encola las señales de acción detectadas.
+ * @param {string} baseDir raíz del proyecto.
+ * @returns {{encolados:number, skip?:string}}
+ */
+function inspeccionar(baseDir) {
+  if (process.env.SWL_CAPTURAR_FEEDBACK === '0') return { skip: 'opt-out', encolados: 0 };
+  if (!lib) return { skip: 'no-lib', encolados: 0 };
+  if (!esRepoGit(baseDir)) return { skip: 'no-git', encolados: 0 }; // REQ-17-11
+  if (!fs.existsSync(path.join(baseDir, '.planning'))) return { skip: 'no-planning', encolados: 0 };
+
+  let n = 0;
+  try {
+    n += _encolarReverts(baseDir);
+    n += _encolarEdicionesNetas(baseDir);
+    n += _encolarPlanesRechazados(baseDir);
+    n += _encolarVeredictosOverride(baseDir);
+  } catch (_) {
+    /* nunca bloquear */
+  }
+  return { encolados: n };
+}
+
+// Listeners de stdin SOLO en modo CLI.
+if (require.main === module) {
+  let inputRaw = '';
+  process.stdin.on('data', (c) => { inputRaw += c; });
+  process.stdin.on('end', () => {
+    try {
+      inspeccionar(process.cwd());
+    } catch (_) {
+      /* silencioso: el hook nunca bloquea la sesión */
+    }
+    // No emite additionalContext: solo persiste señales (alcance Fase 17).
+  });
+} else {
+  module.exports = { inspeccionar, esRepoGit, historialShas };
+}

package/hooks/ciclo-evolucion-subagente.js

@@ -1,26 +1,26 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: ciclo-evolucion-subagente.js
- * Tipo: SubagentStop (async: true — fire-and-forget)
- *
- * Entry point del ciclo de evolución en el evento SubagentStop. Delega a la
- * sub-etapa de auto-evolución (antes `auto-evolucion.js`), que analiza el
- * payload del subagente, registra en el log y emite nudges de evolución
- * (fallos/volumen/loop/drift). Fase 11, D-12.
- *
- * Nunca bloquea (siempre exit 0). Zero-deps fuera de hooks/lib/.
- */
-
-const cicloEvolucion = require('./lib/ciclo-evolucion');
-
-let inputRaw = '';
-process.stdin.on('data', chunk => { inputRaw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    cicloEvolucion.ejecutarSubagentStop(inputRaw);
-  } catch {
-    // El hook nunca bloquea por error interno.
-  }
-});
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: ciclo-evolucion-subagente.js
+ * Tipo: SubagentStop (async: true — fire-and-forget)
+ *
+ * Entry point del ciclo de evolución en el evento SubagentStop. Delega a la
+ * sub-etapa de auto-evolución (antes `auto-evolucion.js`), que analiza el
+ * payload del subagente, registra en el log y emite nudges de evolución
+ * (fallos/volumen/loop/drift). Fase 11, D-12.
+ *
+ * Nunca bloquea (siempre exit 0). Zero-deps fuera de hooks/lib/.
+ */
+
+const cicloEvolucion = require('./lib/ciclo-evolucion');
+
+let inputRaw = '';
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+process.stdin.on('end', () => {
+  try {
+    cicloEvolucion.ejecutarSubagentStop(inputRaw);
+  } catch {
+    // El hook nunca bloquea por error interno.
+  }
+});

package/hooks/ciclo-evolucion.js

@@ -1,26 +1,26 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: ciclo-evolucion.js
- * Tipo: Stop (async: true — fire-and-forget)
- *
- * Entry point del ciclo de evolución en el evento Stop. Ejecuta en UN solo
- * proceso las sub-etapas que antes eran dos hooks separados
- * (`metricas-evolucion.js` + `actualizar-perfil-usuario.js`), reduciendo de
- * dos arranques de Node por sesión a uno (Fase 11, D-12).
- *
- * Nunca bloquea (siempre exit 0). Zero-deps fuera de hooks/lib/.
- */
-
-const cicloEvolucion = require('./lib/ciclo-evolucion');
-
-let inputRaw = '';
-process.stdin.on('data', chunk => { inputRaw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    cicloEvolucion.ejecutarStop(inputRaw);
-  } catch {
-    // El hook nunca bloquea por error interno.
-  }
-});
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: ciclo-evolucion.js
+ * Tipo: Stop (async: true — fire-and-forget)
+ *
+ * Entry point del ciclo de evolución en el evento Stop. Ejecuta en UN solo
+ * proceso las sub-etapas que antes eran dos hooks separados
+ * (`metricas-evolucion.js` + `actualizar-perfil-usuario.js`), reduciendo de
+ * dos arranques de Node por sesión a uno (Fase 11, D-12).
+ *
+ * Nunca bloquea (siempre exit 0). Zero-deps fuera de hooks/lib/.
+ */
+
+const cicloEvolucion = require('./lib/ciclo-evolucion');
+
+let inputRaw = '';
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+process.stdin.on('end', () => {
+  try {
+    cicloEvolucion.ejecutarStop(inputRaw);
+  } catch {
+    // El hook nunca bloquea por error interno.
+  }
+});