@saulwade/swl-ses 1.0.0

package/hooks/calidad-typescript.js

@@ -0,0 +1,511 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: calidad-typescript.js
+ * Tipo: PreToolUse (aplica a: Bash — comandos git commit)
+ *
+ * Verifica calidad TypeScript en archivos staged ANTES de que Claude Code
+ * ejecute un `git commit`. Complementa a calidad-pre-commit.js con
+ * verificaciones específicas del sistema de tipos de TypeScript.
+ *
+ * Verificaciones (sin dependencias externas):
+ *   1. Nuevas introducciones de `any` explícito en el diff
+ *   2. @ts-ignore sin comentario de justificación en la línea anterior
+ *   3. `as unknown as T` (double cast para evadir el type system)
+ *   4. Funciones async sin tipo de retorno cuando el retorno no es void/any
+ *   5. Errores de tsc --noEmit si el proyecto tiene tsconfig.json
+ *
+ * Verificaciones con ts-morph (si está instalado en el proyecto):
+ *   6. Imports no usados (más precisos que grep)
+ *   7. Variables declaradas con `var` en archivos TypeScript
+ *
+ * Resultado:
+ *   - Violaciones CRÍTICAS → stdout + exit code 2 (bloquea el commit)
+ *   - Advertencias         → stdout + exit code 0 (no bloquea)
+ *   - Sin violaciones      → sin output, exit natural
+ *   - Error interno        → sin output (nunca bloquear por fallo del hook)
+ *
+ * Escenario C — integración con ts-morph:
+ *   Si el proyecto tiene ts-morph instalado (`node_modules/ts-morph`),
+ *   este hook lo usa automáticamente para análisis más profundo.
+ *   Si no está disponible, las verificaciones básicas de grep siguen funcionando.
+ *
+ * Performance:
+ *   Usa hooks/lib/performance-marks.js para medir tiempos de cada verificación.
+ *   El reporte de tiempos se incluye en el output cuando hay violaciones.
+ *
+ * @module hooks/calidad-typescript
+ */
+
+const fs            = require('fs');
+const path          = require('path');
+const { execSync }  = require('child_process');
+const perf          = require('./lib/performance-marks');
+const { normalizeForDetection } = require('./lib/normalize-input');
+
+// ---------------------------------------------------------------------------
+// Configuración
+// ---------------------------------------------------------------------------
+
+const CWD = process.cwd();
+
+/**
+ * Directorios excluidos de verificación.
+ * Los archivos en estos paths no se verifican aunque estén en el diff.
+ */
+const EXCLUIR_DIRS = [
+  'node_modules', '.next', 'dist', 'build', 'out', 'coverage',
+  '.planning', 'temp', '.cache',
+];
+
+// ---------------------------------------------------------------------------
+// Utilidades
+// ---------------------------------------------------------------------------
+
+/**
+ * Verifica si el comando actual es un git commit.
+ * @param {string} cmd
+ * @returns {boolean}
+ */
+function esGitCommit(cmd) {
+  return /\bgit\s+commit\b/.test(cmd);
+}
+
+/**
+ * Obtiene los archivos TypeScript staged para commit.
+ * @returns {string[]} rutas de archivos .ts/.tsx staged
+ */
+function obtenerArchivosTSStagged() {
+  try {
+    const out = execSync('git diff --cached --name-only --diff-filter=ACMR', {
+      cwd: CWD, encoding: 'utf8', stdio: ['pipe','pipe','pipe'],
+    });
+    return out.trim().split('\n')
+      .filter(f => f && (f.endsWith('.ts') || f.endsWith('.tsx')))
+      .filter(f => !EXCLUIR_DIRS.some(d => f.startsWith(d + '/')))
+      .filter(f => !f.includes('.d.ts'));
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Obtiene el contenido del diff staged para los archivos TS.
+ * @returns {string}
+ */
+function obtenerDiffTS() {
+  try {
+    return execSync('git diff --cached -- "*.ts" "*.tsx"', {
+      cwd: CWD, encoding: 'utf8', stdio: ['pipe','pipe','pipe'],
+    });
+  } catch (_) {
+    return '';
+  }
+}
+
+/**
+ * Extrae solo las líneas añadidas del diff (líneas con + al inicio).
+ * Excluye encabezados de archivos (+++ ...).
+ * @param {string} diff
+ * @returns {{ archivo: string, linea: number, contenido: string }[]}
+ */
+function extraerLineasAgregadas(diff) {
+  const resultado = [];
+  let archivoActual = '';
+  let lineaActual   = 0;
+
+  for (const linea of diff.split('\n')) {
+    // Encabezado de archivo nuevo
+    const matchArchivo = linea.match(/^\+\+\+ b\/(.+)/);
+    if (matchArchivo) {
+      archivoActual = matchArchivo[1];
+      lineaActual   = 0;
+      continue;
+    }
+
+    // Número de línea en el nuevo archivo
+    const matchHunk = linea.match(/^@@.*\+(\d+)/);
+    if (matchHunk) {
+      lineaActual = parseInt(matchHunk[1], 10) - 1;
+      continue;
+    }
+
+    if (linea.startsWith('+') && !linea.startsWith('+++')) {
+      lineaActual++;
+      resultado.push({
+        archivo: archivoActual,
+        linea: lineaActual,
+        contenido: linea.slice(1), // quitar el + del diff
+      });
+    } else if (!linea.startsWith('-')) {
+      lineaActual++;
+    }
+  }
+
+  return resultado;
+}
+
+// ---------------------------------------------------------------------------
+// Verificaciones de calidad TypeScript
+// ---------------------------------------------------------------------------
+
+/**
+ * 1. Detecta introducciones nuevas de `any` explícito sin justificación.
+ *    Busca en líneas agregadas del diff.
+ *
+ * @param {Array} lineasAgregadas
+ * @returns {{ archivo: string, linea: number, descripcion: string }[]}
+ */
+function verificarAnyExplicito(lineasAgregadas) {
+  perf.mark('anyCheck_start');
+  const violaciones = [];
+
+  const patronAny = /(?<!\/\/.*)(?<!\w)(?::\s*any\b|as\s+any\b|<any>|Array<any>|Promise<any>|Record<string,\s*any>)/;
+  const patronJustificado = /\/\/\s*(eslint-disable|ts-ignore|any justificado|FIXME|TODO|hack)/i;
+
+  for (const { archivo, linea, contenido } of lineasAgregadas) {
+    if (!patronAny.test(contenido)) continue;
+    // Si la línea tiene un comentario de justificación, no es violación
+    if (patronJustificado.test(contenido)) continue;
+    // Si es en un archivo de test, es advertencia no crítica
+    const esTest = archivo.includes('.test.') || archivo.includes('.spec.') || archivo.includes('__tests__');
+    violaciones.push({
+      archivo, linea,
+      descripcion: `'any' introducido sin justificación${esTest ? ' (en test)' : ''}`,
+      severidad: esTest ? 'advertencia' : 'critica',
+    });
+  }
+
+  perf.mark('anyCheck_end');
+  perf.measure('anyCheck', 'anyCheck_start', 'anyCheck_end');
+  return violaciones;
+}
+
+/**
+ * 2. Detecta @ts-ignore sin comentario explicativo en la línea anterior.
+ *
+ * @param {string[]} archivos — lista de rutas relativas
+ * @returns {{ archivo: string, linea: number, descripcion: string }[]}
+ */
+function verificarTsIgnore(archivos) {
+  perf.mark('tsIgnoreCheck_start');
+  const violaciones = [];
+
+  for (const archivo of archivos) {
+    let contenido;
+    try {
+      contenido = fs.readFileSync(path.join(CWD, archivo), 'utf8');
+    } catch (_) {
+      continue;
+    }
+
+    const lineas = contenido.split('\n');
+    for (let i = 0; i < lineas.length; i++) {
+      const linea = lineas[i];
+      if (!/@ts-ignore/.test(linea)) continue;
+
+      // Verificar que la línea actual o la anterior tiene un comentario explicativo
+      const lineaAnterior = i > 0 ? lineas[i - 1] : '';
+      const tieneJustificacion =
+        /\/\/\s*.{5,}/.test(lineaAnterior) ||  // comentario con texto en línea anterior
+        /\/\/\s*.{5,}/.test(linea.replace('@ts-ignore', '').trim()); // comentario en misma línea
+
+      if (!tieneJustificacion) {
+        violaciones.push({
+          archivo, linea: i + 1,
+          descripcion: '@ts-ignore sin comentario de justificación (¿por qué no se puede tipar correctamente?)',
+          severidad: 'critica',
+        });
+      }
+    }
+  }
+
+  perf.mark('tsIgnoreCheck_end');
+  perf.measure('tsIgnoreCheck', 'tsIgnoreCheck_start', 'tsIgnoreCheck_end');
+  return violaciones;
+}
+
+/**
+ * 3. Detecta double cast `as unknown as T` para evadir el type system.
+ *
+ * @param {Array} lineasAgregadas
+ * @returns {{ archivo: string, linea: number, descripcion: string }[]}
+ */
+function verificarDoubleCast(lineasAgregadas) {
+  perf.mark('doubleCastCheck_start');
+  const violaciones = [];
+  const patron = /as\s+unknown\s+as\s+\w/;
+
+  for (const { archivo, linea, contenido } of lineasAgregadas) {
+    if (!patron.test(contenido)) continue;
+    violaciones.push({
+      archivo, linea,
+      descripcion: "'as unknown as T' — double cast para evadir el type system. Tipar la fuente correctamente o usar type guard",
+      severidad: 'critica',
+    });
+  }
+
+  perf.mark('doubleCastCheck_end');
+  perf.measure('doubleCastCheck', 'doubleCastCheck_start', 'doubleCastCheck_end');
+  return violaciones;
+}
+
+/**
+ * 4. Detecta catch blocks con tipo any o Error en lugar de unknown.
+ *
+ * @param {Array} lineasAgregadas
+ * @returns {{ archivo: string, linea: number, descripcion: string }[]}
+ */
+function verificarCatchTipos(lineasAgregadas) {
+  perf.mark('catchCheck_start');
+  const violaciones = [];
+
+  const patronCatchAny   = /catch\s*\(\s*\w+\s*:\s*any\s*\)/;
+  const patronCatchError = /catch\s*\(\s*\w+\s*:\s*Error\s*\)/;
+
+  for (const { archivo, linea, contenido } of lineasAgregadas) {
+    if (patronCatchAny.test(contenido)) {
+      violaciones.push({
+        archivo, linea,
+        descripcion: "catch (e: any) — usar 'unknown' y narrowing con instanceof",
+        severidad: 'critica',
+      });
+    } else if (patronCatchError.test(contenido)) {
+      violaciones.push({
+        archivo, linea,
+        descripcion: "catch (e: Error) — el tipo en catch es siempre 'unknown' en TS moderno. Usar instanceof Error para narrowing",
+        severidad: 'mayor',
+      });
+    }
+  }
+
+  perf.mark('catchCheck_end');
+  perf.measure('catchCheck', 'catchCheck_start', 'catchCheck_end');
+  return violaciones;
+}
+
+/**
+ * 5. Ejecuta tsc --noEmit si el proyecto tiene tsconfig.json.
+ *    Captura los primeros errores (no bloquea si tsc no está disponible).
+ *
+ * @returns {{ errores: string[], tiempoMs: number }}
+ */
+function ejecutarTsc() {
+  perf.mark('tsc_start');
+  const resultado = { errores: [], tiempoMs: 0 };
+
+  const tsconfigPath = path.join(CWD, 'tsconfig.json');
+  if (!fs.existsSync(tsconfigPath)) {
+    perf.mark('tsc_end');
+    perf.measure('tsc', 'tsc_start', 'tsc_end');
+    return resultado;
+  }
+
+  try {
+    execSync('npx tsc --noEmit 2>&1', {
+      cwd: CWD, encoding: 'utf8', stdio: ['pipe','pipe','pipe'], timeout: 60_000,
+    });
+  } catch (err) {
+    const output = (err.stdout || err.stderr || '').toString();
+    // Extraer solo los primeros 10 errores — evitar output masivo
+    const lineas = output.split('\n').filter(l => l.includes(': error TS'));
+    resultado.errores = lineas.slice(0, 10);
+  }
+
+  perf.mark('tsc_end');
+  perf.measure('tsc', 'tsc_start', 'tsc_end');
+  return resultado;
+}
+
+/**
+ * 6. Verificaciones con ts-morph si está disponible.
+ *    Graceful degradation: si no está instalado, retorna vacío.
+ *
+ * @param {string[]} archivos
+ * @returns {{ violaciones: Array, disponible: boolean }}
+ */
+function verificarConTsMorph(archivos) {
+  perf.mark('tsMorph_start');
+  const resultado = { violaciones: [], disponible: false };
+
+  // Verificar si ts-morph está disponible
+  const tsMorphPath = path.join(CWD, 'node_modules', 'ts-morph');
+  if (!fs.existsSync(tsMorphPath)) {
+    perf.mark('tsMorph_end');
+    perf.measure('tsMorph', 'tsMorph_start', 'tsMorph_end');
+    return resultado;
+  }
+
+  try {
+    const { Project } = require(tsMorphPath);
+    resultado.disponible = true;
+
+    const project = new Project({
+      tsConfigFilePath: path.join(CWD, 'tsconfig.json'),
+      skipAddingFilesFromTsConfig: true,
+    });
+
+    for (const rutaRelativa of archivos.slice(0, 20)) { // Limitar a 20 archivos
+      const rutaAbsoluta = path.join(CWD, rutaRelativa);
+      if (!fs.existsSync(rutaAbsoluta)) continue;
+
+      const sourceFile = project.addSourceFileAtPath(rutaAbsoluta);
+
+      // Detectar variables declaradas con `var`
+      sourceFile.getVariableDeclarations().forEach(decl => {
+        const declarationList = decl.getParent();
+        if (declarationList && declarationList.getDeclarationKind &&
+            declarationList.getDeclarationKind().toString() === 'var') {
+          resultado.violaciones.push({
+            archivo: rutaRelativa,
+            linea: decl.getStartLineNumber(),
+            descripcion: `var '${decl.getName()}' — usar const o let`,
+            severidad: 'menor',
+          });
+        }
+      });
+
+      // Detectar console.log en producción (refuerza calidad-pre-commit)
+      sourceFile.getDescendantsOfKind(274 /* CallExpression */).forEach(call => {
+        const expr = call.getExpression();
+        if (expr && expr.getText && /^console\.(log|debug|warn)/.test(expr.getText())) {
+          const ruta = call.getSourceFile().getFilePath();
+          if (!ruta.includes('.test.') && !ruta.includes('.spec.')) {
+            resultado.violaciones.push({
+              archivo: rutaRelativa,
+              linea: call.getStartLineNumber(),
+              descripcion: `${expr.getText()}() — eliminar debug output en producción`,
+              severidad: 'menor',
+            });
+          }
+        }
+      });
+    }
+  } catch (_) {
+    // ts-morph disponible pero error al analizar — no bloquear
+    resultado.disponible = true;
+  }
+
+  perf.mark('tsMorph_end');
+  perf.measure('tsMorph', 'tsMorph_start', 'tsMorph_end');
+  return resultado;
+}
+
+// ---------------------------------------------------------------------------
+// Punto de entrada
+// ---------------------------------------------------------------------------
+
+function main() {
+  // Leer el input de Claude Code (JSON en stdin)
+  let input = '';
+  try {
+    input = fs.readFileSync('/dev/stdin', 'utf8');
+  } catch (_) {
+    try {
+      // Fallback para Windows
+      const buf = [];
+      const fd = require('fs').openSync('\\\\.\\pipe\\CONIN$', 'r');
+      // Si falla, simplemente no hay input — salir silenciosamente
+    } catch (_2) {}
+  }
+
+  let datos = {};
+  try { datos = JSON.parse(input); } catch (_) { process.exit(0); }
+
+  const cmd = normalizeForDetection(datos?.tool_input?.command || '');
+  if (!esGitCommit(cmd)) process.exit(0);
+
+  perf.mark('hook_start');
+
+  // Obtener archivos TypeScript staged
+  const archivosTS = obtenerArchivosTSStagged();
+  if (archivosTS.length === 0) {
+    // No hay archivos TypeScript en el commit — no aplica este hook
+    process.exit(0);
+  }
+
+  // Obtener diff de archivos TS
+  const diff = obtenerDiffTS();
+  const lineasAgregadas = extraerLineasAgregadas(diff);
+
+  // Ejecutar todas las verificaciones
+  const todasViolaciones = [];
+
+  todasViolaciones.push(...verificarAnyExplicito(lineasAgregadas));
+  todasViolaciones.push(...verificarTsIgnore(archivosTS));
+  todasViolaciones.push(...verificarDoubleCast(lineasAgregadas));
+  todasViolaciones.push(...verificarCatchTipos(lineasAgregadas));
+
+  // tsc --noEmit
+  const { errores: erroresTsc } = ejecutarTsc();
+
+  // ts-morph (opcional)
+  const { violaciones: violacionesMorph } = verificarConTsMorph(archivosTS);
+  todasViolaciones.push(...violacionesMorph);
+
+  perf.mark('hook_end');
+  perf.measure('hook_total', 'hook_start', 'hook_end');
+
+  // Separar críticos de advertencias
+  const criticos    = todasViolaciones.filter(v => v.severidad === 'critica');
+  const mayores     = todasViolaciones.filter(v => v.severidad === 'mayor');
+  const advertencias = todasViolaciones.filter(v => v.severidad === 'advertencia' || v.severidad === 'menor');
+
+  const hayProblemas = criticos.length > 0 || mayores.length > 0 || erroresTsc.length > 0;
+
+  if (!hayProblemas && advertencias.length === 0) process.exit(0);
+
+  // Generar output
+  const lineasOutput = [
+    `\n[calidad-typescript] ${archivosTS.length} archivo(s) TypeScript en el commit\n`,
+  ];
+
+  if (criticos.length > 0) {
+    lineasOutput.push('CRÍTICOS (bloquean el commit):');
+    criticos.forEach(v => lineasOutput.push(`  ${v.archivo}:${v.linea} — ${v.descripcion}`));
+    lineasOutput.push('');
+  }
+
+  if (mayores.length > 0) {
+    lineasOutput.push('MAYORES:');
+    mayores.forEach(v => lineasOutput.push(`  ${v.archivo}:${v.linea} — ${v.descripcion}`));
+    lineasOutput.push('');
+  }
+
+  if (erroresTsc.length > 0) {
+    lineasOutput.push(`Errores de tsc --noEmit (${erroresTsc.length} primeros):`);
+    erroresTsc.forEach(e => lineasOutput.push(`  ${e}`));
+    lineasOutput.push('');
+  }
+
+  if (advertencias.length > 0) {
+    lineasOutput.push('Advertencias (no bloquean):');
+    advertencias.forEach(v => lineasOutput.push(`  ${v.archivo}:${v.linea} — ${v.descripcion}`));
+    lineasOutput.push('');
+  }
+
+  // Agregar reporte de performance si tardó más de 3 segundos
+  const durTotal = perf.getDuration('hook_total');
+  if (durTotal > 3000) {
+    lineasOutput.push(perf.formatReporte({ umbralMs: 50 }));
+    lineasOutput.push('');
+  }
+
+  // stderr: visible al usuario siempre y enviado a Claude si se usa exit 2.
+  // stdout solo se muestra en modo transcript (CTRL-R), no llega al modelo.
+  process.stderr.write(lineasOutput.join('\n'));
+
+  // Bloquear solo si hay críticos, mayores o errores de tsc
+  if (criticos.length > 0 || erroresTsc.length > 0) {
+    process.exit(2);
+  }
+  // Mayores: bloquear si hay más de 2
+  if (mayores.length > 2) {
+    process.exit(2);
+  }
+  // Si solo hay advertencias o 1-2 mayores: warning sin bloqueo
+  process.exit(0);
+}
+
+main();

package/hooks/captura-feedback-usuario.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: captura-feedback-usuario.js
+ * Tipo: UserPromptSubmit
+ *
+ * Detecta correcciones explícitas del usuario ("no hagas X", "recuerda Y",
+ * "prefiero Z") y las encola en .planning/evolucion/feedback-queue.jsonl
+ * para que el perfilador-usuario-swl, el ciclo AGP y /swl:aprender puedan
+ * consumirlas sin depender de que el usuario ejecute comandos manualmente.
+ *
+ * Inspirado en claude-reflect (capture_learning.py). Zero-deps, patrones
+ * regex en español e inglés.
+ *
+ * A diferencia del clasificador-mensajes.js (que hace routing de modelos),
+ * este hook captura SEÑALES DE MEMORIA persistente del usuario.
+ *
+ * Resultado:
+ *   - Señal detectada → append a feedback-queue.jsonl (no bloquea ni muestra al modelo)
+ *   - Sin señal → exit 0 silencioso
+ *   - Error → exit 0 silencioso (nunca bloquea)
+ *
+ * Opt-out: SWL_CAPTURAR_FEEDBACK=0
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+// ---------------------------------------------------------------------------
+// Patrones de detección
+//
+// Clasificación por tipo de señal:
+//   correccion:   el usuario corrige un comportamiento ("no hagas X", "no uses Y")
+//   preferencia:  el usuario declara una preferencia ("prefiero X", "siempre usa Y")
+//   memoria:      el usuario pide recordar ("recuerda que X", "guarda X")
+//   prohibicion:  el usuario prohíbe ("nunca X", "jamás Y")
+// ---------------------------------------------------------------------------
+
+const PATRONES = [
+  // Correcciones explícitas
+  { tipo: 'correccion', re: /\b(no\s+(?:hagas|uses|escribas|incluyas|agregues)\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'correccion', re: /\b(don['´]?t\s+(?:do|use|write|include|add)\s+[a-z][^.!?\n]{3,100})/i },
+  { tipo: 'correccion', re: /\b(eso\s+(?:está|esta)\s+mal[^.!?\n]{0,100})/i },
+  { tipo: 'correccion', re: /\b(that['´]?s\s+wrong[^.!?\n]{0,100})/i },
+  { tipo: 'correccion', re: /\b(corrige\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+
+  // Preferencias
+  { tipo: 'preferencia', re: /\b(prefiero\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'preferencia', re: /\b(i\s+prefer\s+[a-z][^.!?\n]{3,100})/i },
+  { tipo: 'preferencia', re: /\b(mejor\s+usa\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'preferencia', re: /\b(siempre\s+(?:usa|haz|escribe|incluye)\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'preferencia', re: /\b(always\s+(?:use|do|write|include)\s+[a-z][^.!?\n]{3,100})/i },
+
+  // Memoria explícita
+  { tipo: 'memoria', re: /\b(recuerda(?:\s+que)?\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'memoria', re: /\b(guarda\s+(?:esto|que)\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'memoria', re: /\b(remember\s+(?:that\s+)?[a-z][^.!?\n]{3,100})/i },
+
+  // Prohibiciones absolutas
+  { tipo: 'prohibicion', re: /\b(nunca\s+(?:hagas|uses|escribas|incluyas|agregues)\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'prohibicion', re: /\b(jamás\s+(?:hagas|uses|escribas|incluyas|agregues)\s+[a-záéíóúñ][^.!?\n]{3,100})/i },
+  { tipo: 'prohibicion', re: /\b(never\s+(?:do|use|write|include|add)\s+[a-z][^.!?\n]{3,100})/i },
+];
+
+// Longitud mínima del prompt completo para considerarlo como feedback
+// (evita capturar "no" suelto o prompts ultra-cortos de navegación).
+const MIN_PROMPT_LEN = 12;
+
+// Longitud máxima del fragmento capturado (para no saturar la cola con pastes largos)
+const MAX_FRAGMENTO_LEN = 280;
+
+/**
+ * Analiza un prompt y extrae señales de feedback.
+ * @param {string} prompt
+ * @returns {Array<{tipo: string, fragmento: string}>}
+ */
+function detectarFeedback(prompt) {
+  if (!prompt || prompt.length < MIN_PROMPT_LEN) return [];
+
+  // Omitir si el prompt es claramente un comando slash
+  if (prompt.trim().startsWith('/')) return [];
+
+  const hallazgos = [];
+  for (const { tipo, re } of PATRONES) {
+    const m = prompt.match(re);
+    if (!m) continue;
+    const fragmento = m[1].trim().slice(0, MAX_FRAGMENTO_LEN);
+    hallazgos.push({ tipo, fragmento });
+  }
+
+  // Deduplicar por fragmento idéntico
+  const vistos = new Set();
+  return hallazgos.filter(h => {
+    const clave = `${h.tipo}::${h.fragmento.toLowerCase()}`;
+    if (vistos.has(clave)) return false;
+    vistos.add(clave);
+    return true;
+  });
+}
+
+/**
+ * Encola un hallazgo en feedback-queue.jsonl.
+ */
+function encolar(hallazgo, meta) {
+  try {
+    const dir = path.join(process.cwd(), '.planning', 'evolucion');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    const entrada = {
+      ts:         new Date().toISOString(),
+      sessionId:  meta.sessionId,
+      tipo:       hallazgo.tipo,
+      fragmento:  hallazgo.fragmento,
+      cwd:        meta.cwd,
+      procesado:  false,
+    };
+
+    const jsonlPath = path.join(dir, 'feedback-queue.jsonl');
+    fs.appendFileSync(jsonlPath, JSON.stringify(entrada) + '\n');
+  } catch (_) { /* nunca bloquear */ }
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+process.stdin.on('data', c => { inputRaw += c; });
+
+process.stdin.on('end', () => {
+  try {
+    if (process.env.SWL_CAPTURAR_FEEDBACK === '0') return;
+
+    const data = JSON.parse(inputRaw);
+    const prompt = data.prompt || '';
+    const sessionId = String(data.session_id || 'default');
+
+    const hallazgos = detectarFeedback(prompt);
+    if (hallazgos.length === 0) return;
+
+    for (const h of hallazgos) {
+      encolar(h, { sessionId, cwd: process.cwd() });
+    }
+  } catch (_) { /* silencioso */ }
+});
+
+module.exports = { detectarFeedback };