@saulwade/swl-ses 2.6.1 → 2.8.0

package/scripts/lib/w4-motor-mutacion.js

@@ -0,0 +1,1348 @@
+'use strict';
+
+/**
+ * Motor de mutation testing zero-deps para los módulos críticos de swl-ses
+ * (ADR-0050 § "mutation score de al menos 90%, con 100% de mutantes críticos
+ * eliminados"; F32/T-07, REQ-32-07).
+ *
+ * Construido desde cero porque el repo es zero-deps en `scripts/lib/` y no
+ * tiene ninguna librería de mutation testing instalada (ni Stryker ni un
+ * parser de AST como @babel/parser/acorn) — no se puede agregar ninguna
+ * dependencia npm nueva (Whitelist F32). Por eso los 5 operadores de
+ * mutación (ver `OPERADORES`) son mutaciones de TEXTO sobre una versión
+ * "enmascarada" del código fuente (strings/comentarios/regex-literales
+ * reemplazados por relleno neutro, misma longitud), nunca un AST completo.
+ * Es una técnica de mutation testing legítima y usada en la práctica
+ * (herramientas tempranas de mutation testing empezaron así antes de mover
+ * a AST completo) — documentado honestamente como tal, no un atajo oculto.
+ *
+ * DECLARACIÓN DE EFECTOS (a diferencia de T-01/T-02/T-04/T-05, que son puros
+ * por contrato): `ejecutarMutationTesting` SÍ tiene efectos — crea
+ * directorios temporales reales en `os.tmpdir()`, escribe archivos ahí y
+ * spawnea procesos `node` reales. Es necesario por la naturaleza de la
+ * tarea (no se puede saber si una suite mata un mutante sin ejecutarla).
+ * `generarMutantes`, `clasificarCritico`, `enmascarar` y
+ * `verificarTasaSyntaxError` sí son puras.
+ *
+ * CRÍTICO — invariante de aislamiento: el motor NUNCA escribe un mutante de
+ * vuelta a los 20 módulos ORIGINALES de `scripts/lib/`. Cada mutante se
+ * escribe en una COPIA efímera bajo `os.tmpdir()` (creada y borrada por
+ * tarea), nunca en el árbol real del repo — los 20 módulos críticos están
+ * fuera de la whitelist de escritura de F32 (son de F29/F30/F31, ya
+ * cerrados).
+ *
+ * DESVIACIÓN DOCUMENTADA respecto al memo de diseño aprobado (§4b/§4c): el
+ * memo sugería `child_process.spawnSync` con un pool de workers "por
+ * módulo" (uno por cada uno de los 20 módulos, min(20, cpus)). La medición
+ * real de baseline (hecha ANTES de implementar, sobre los 20 módulos reales)
+ * mostró que 4 módulos por sí solos tardan 26-87s por corrida de su suite
+ * (`gate-engine` ~28s con ~330 mutantes, `runtime-compiler` ~86s,
+ * `runtime-bundle-installer` ~44s, `policy-bundle`/`harness-source-snapshot`
+ * ~10-14s compartiendo `tests/scripts/policy-bundle.test.js`) — paralelizar
+ * sólo "por módulo" habría dejado esos módulos corriendo SECUENCIALMENTE
+ * sus propios cientos de mutantes (decenas de minutos a varias horas cada
+ * uno, inviable en una sesión). Este módulo paraleliza a nivel de TAREA
+ * individual (módulo, mutante) con `child_process.spawn` asíncrono (no
+ * bloqueante, a diferencia de `spawnSync`) sobre un pool de concurrencia
+ * acotada — cada tarea usa su propia copia efímera aislada, creada y
+ * borrada sólo para esa tarea. El comando exacto que se spawnea
+ * (`node --test --test-reporter=tap --test-reporter-destination=stdout
+ * <testFiles...>`, `cwd` = copia efímera) es EXACTAMENTE el especificado en
+ * el memo — sólo cambia el mecanismo de concurrencia (async spawn + pool de
+ * tareas en vez de spawnSync + pool de módulos), no el comando ni la
+ * semántica de clasificación muerto/sobrevivió/crítico.
+ *
+ * CORRECCIONES POST-VERIFICACIÓN (misma sesión T-07, ver detalle junto a
+ * cada función): (1) `matarArbolDeProceso` era exclusivamente Windows
+ * (`taskkill`) y fallaba silenciosamente en la CI real (ubuntu-latest) —
+ * ahora branchea por `process.platform` vía `decidirComandoMatarArbol`
+ * (pura, testeable en cualquier SO); (2) `prepararPlantillaGit` podía dejar
+ * un directorio huérfano en `os.tmpdir()` si `clonarGitLocal` fallaba antes
+ * de que el `finally` del caller tuviera una referencia que limpiar; (3)
+ * `clasificarCritico`/`nombreFuncionContenedora` no reconocían funciones
+ * declaradas como propiedad-flecha de objeto (`nombre: (v) => ...`) ni
+ * prefijos críticos en inglés (`validate`/`verify`/`is[A-Z]`/`can[A-Z]`),
+ * pese a ser la convención de nombrado real de los 20 módulos críticos —
+ * subestimaba el conteo de mutantes críticos; (4) `correrLineaBase` validaba
+ * la línea base con la UNIÓN de `directoriosExtra` de todo el batch en un
+ * único árbol compartido, en vez de aislar cada módulo con EXACTAMENTE los
+ * mismos directorios que usan después sus tareas de mutante reales
+ * (`directoriosParaModulo`) — con los 20 módulos juntos esa unión incluía
+ * `DIRECTORIOS_EXTRA_PAQUETE_COMPLETO` (declarado sólo por los módulos #1/#2)
+ * y enmascaraba que 7 módulos más nunca declararon el suyo propio: sus
+ * tareas de mutante reales fallaban por MODULE_NOT_FOUND/ENOENT en CADA
+ * mutante, contadas falsamente como "muerto" por SYNTAX_ERROR (100% de
+ * score que medía entorno roto, no detección real). Corregido: baseline
+ * aislado por módulo + `directoriosExtra` correcto declarado para cada uno
+ * de los 20 (ver DEUDA-TECNICA.md#DT-T07-MUTANTES-CRITICOS-SOBREVIVIENTES).
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn, execFileSync } = require('node:child_process');
+
+const SCHEMA_VERSION = '1.0.0';
+const UMBRAL_SYNTAX_ERROR = 0.01;
+const DIRECTORIOS_POR_DEFECTO = Object.freeze(['scripts', 'schemas', 'tests/lib', 'tests/scripts']);
+
+// (HALLAZGO real durante T-07, corrida completa 2026-07-17). Sin timeout, dos
+// mutantes de módulos con tests concurrentes (fork()/spawn() internos, p.ej.
+// integrity-ledger.test.js) COLGARON el proceso hijo indefinidamente (~17min
+// de CPU activa medidos antes de detectarlo y matar el árbol de procesos) —
+// bloqueando esos 2 de 12 "slots" de concurrencia para siempre y estancando
+// la corrida real al 99.5%. Una mutación puede razonablemente convertir una
+// guarda de terminación en un loop infinito o un deadlock de espera — es una
+// forma VÁLIDA de "matar" el mutante (cambió el comportamiento observable
+// tan drásticamente que ni siquiera termina), no un defecto del motor.
+// 150s da margen holgado sobre el baseline medido más lento de los 20
+// módulos reales (~86s, runtime-compiler.test.js).
+const TIMEOUT_MS_POR_DEFECTO = 150000;
+
+// (HALLAZGO real durante T-07, opción A de arreglar-al-detectar.md — fix
+// acotado, reversible, sólo toca este módulo). `tests/scripts/policy-bundle.test.js`
+// -- único testFile de los módulos #1/#2 de MODULOS_CRITICOS -- NO es un test
+// acotado a esos dos módulos: es un archivo de tests de PAQUETE COMPLETO.
+// Hace require('../../package.json'/'package-lock.json'/'plugin.json'), lee
+// '.planning/loops/tdd-f30-policy-gates.json' (ya anticipado por el memo de
+// diseño §1), corre `git diff <baseCommit> -- <paths>` contra RAIZ (sólo
+// lectura: los únicos git() con efectos de escritura del archivo apuntan a
+// fixtures temporales propias del test, nunca a RAIZ), compila el harness
+// real contra `agentes/`/`habilidades/`/`comandos/swl/`/`reglas/`, y
+// verifica contenido de 10 documentos raíz (AGENTS.md, CLAUDE.md,
+// COMANDOS.md, INSTALACION.md, llms.txt, MANUAL_USO.md, INVENTARIO.md,
+// README.md, SALUD.md, CHANGELOG.md) — verificado exhaustivamente vía grep
+// de `path.join(RAIZ, ...)` en el archivo, no por prueba y error incremental.
+// Sin estos elementos la línea base fallaba con MUTATION_BASELINE_FAILED por
+// ENOENT/"not a git repository" — no por una guarda real de seguridad.
+//
+// Esta lista NUNCA se agrega a DIRECTORIOS_POR_DEFECTO (penalizaría a los
+// otros 18 módulos, cuyos testFiles no la necesitan): sólo los módulos #1/#2
+// de MODULOS_CRITICOS declaran `directoriosExtra` con esta lista.
+//
+// `.git` requiere un CHECKOUT real (no sólo `git clone --no-checkout`): el
+// snapshot del harness lee `.git/index` directamente
+// (`harness-source-snapshot.js#resolverIndiceGit`, vía `git rev-parse
+// --git-path index` + `fs.realpathSync`) y ese archivo sólo existe tras un
+// checkout. `--no-checkout` mide ~120ms pero dejaría `.git/index` ausente
+// (ENOENT); un checkout completo mide ~3.6s (dominado por escribir ~1700
+// archivos pequeños en NTFS, no por el clon en sí — `--shared` evita
+// recopiar el historial vía alternates). Ese costo se paga sólo en las 222
+// tareas de los módulos #1/#2 (62+160 mutantes), nunca en las otras 2000+.
+const DIRECTORIOS_EXTRA_PAQUETE_COMPLETO = Object.freeze([
+  'manifiestos', 'gateway', '.github', 'hooks', '.planning/loops',
+  'agentes', 'habilidades', 'comandos', 'reglas',
+  'package.json', 'package-lock.json', 'plugin.json',
+  'AGENTS.md', 'CLAUDE.md', 'COMANDOS.md', 'INSTALACION.md', 'llms.txt',
+  'MANUAL_USO.md', 'INVENTARIO.md', 'README.md', 'SALUD.md', 'CHANGELOG.md',
+  '.git',
+]);
+
+function crearError(codigo, mensaje) {
+  const error = new Error(mensaje);
+  error.codigo = codigo;
+  return error;
+}
+
+function fallar(codigo, mensaje) {
+  throw crearError(codigo, mensaje);
+}
+
+function esObjetoPlano(valor) {
+  return Boolean(valor) && typeof valor === 'object' && !Array.isArray(valor)
+    && Object.getPrototypeOf(valor) === Object.prototype;
+}
+
+function congelarProfundo(valor) {
+  if (valor && typeof valor === 'object' && !Object.isFrozen(valor)) {
+    Object.values(valor).forEach(congelarProfundo);
+    Object.freeze(valor);
+  }
+  return valor;
+}
+
+// =============================================================================
+// MODULOS_CRITICOS — los 13 módulos del kernel W2 (F29/F30) + los 7 de F31,
+// con su(s) testFile(s) real(es) verificado(s) con Glob/Grep contra el árbol
+// (32-CONTEXTO.md/memo de diseño de T-07 § 0). Array LITERAL hardcodeado —
+// NUNCA descubierto con fs.readdirSync: el orden de un listado de directorio
+// no está garantizado estable entre filesystems/plataformas, y esto rompería
+// el determinismo del reporte (§ ensamblarReporte).
+// =============================================================================
+// (HALLAZGO real durante T-07, opción A de arreglar-al-detectar.md). El test
+// "T-01 usa módulos locales y conserva su aislamiento durante Core-3" de
+// tests/scripts/policy-bundle.test.js corre `git -c core.autocrlf=false diff
+// <baseCommit> -- gateway .github ...` esperando diff vacío. Esa aserción
+// depende de una OPTIMIZACIÓN DE STAT-CACHE de git: si el mtime de un
+// archivo coincide con el cacheado en el índice, git confía en el OID
+// cacheado SIN re-hashear el contenido — enmascarando que el blob commiteado
+// está en LF puro mientras el archivo real en disco está en CRLF (git
+// show <commit>:gateway/index.js = 9770 bytes sin CRLF; el archivo real =
+// 10090 bytes con CRLF). Raíz verificada de forma determinante: un simple
+// `touch gateway/index.js` en el repo REAL (sin tocar contenido) hace que
+// ESTA MISMA aserción falle ahí también — es una fragilidad preexistente de
+// la aserción, no un defecto introducido por este motor. CUALQUIER copia
+// fresca (checkout de `.git`, clon, `cpSync`) invalida el stat-cache y
+// revela la discrepancia LF/CRLF que ya existía. Como este chequeo de rutas
+// congeladas es ortogonal a la lógica real de harness-source-snapshot.js/
+// policy-bundle.js (los módulos que este motor sí mutation-testea), se
+// excluye ese test puntual vía `--test-skip-pattern` al spawnear
+// policy-bundle.test.js para estos 2 módulos — nunca se modifica el archivo
+// de test (fuera del boundary de escritura de F32) ni se enmascara un
+// hallazgo real de las guardas de seguridad que sí ejercitan estos módulos.
+const TEST_SKIP_PATTERN_GIT_STATCACHE = 'T-01 usa m.dulos locales y conserva su aislamiento durante Core-3';
+
+// integrity-ledger.test.js incluye 3 tests que forkean procesos reales
+// (childProcess.fork/spawn) para ejercitar concurrencia de append y reclaim de
+// lock. Bajo el harness de mutation testing son NO DETERMINISTAS: además de
+// colgar bajo carga (timeout — ya tratado como kill válido, ver
+// TIMEOUT_MS_POR_DEFECTO), producen fallos-assertion FLAKY por carreras entre los
+// forks reales, independientes de la mutación bajo prueba. Un fallo-flaky así,
+// coincidiendo con un mutante EQUIVALENTE anotado, dispararía EN FALSO el
+// invariante fail-closed (MUTATION_EQUIVALENTE_MATADO) y volvería el Gate no
+// reproducible. Se excluyen del scoring de mutación (siguen corriendo en la suite
+// normal de CI para su cobertura). El descubrimiento determinista de T-07 confirmó
+// 0 mutantes críticos MATABLES cubiertos SÓLO por estos tests: excluirlos no pierde
+// señal (246/249 críticos muertos, 3 sobrevivientes todos equivalentes anotados).
+// Ver ADR-0055 § Determinismo del Gate para integrity-ledger.
+const TEST_SKIP_PATTERN_INTEGRITY_LEDGER = 'dos procesos reales|worker que falla antes|dos reclaimers reales';
+
+const MODULOS_CRITICOS = Object.freeze([
+  Object.freeze({
+    modulo: 'scripts/lib/harness-source-snapshot.js', testFiles: Object.freeze(['tests/scripts/policy-bundle.test.js']),
+    directoriosExtra: DIRECTORIOS_EXTRA_PAQUETE_COMPLETO, testSkipPattern: TEST_SKIP_PATTERN_GIT_STATCACHE,
+  }),
+  Object.freeze({
+    modulo: 'scripts/lib/policy-bundle.js', testFiles: Object.freeze(['tests/scripts/policy-bundle.test.js']),
+    directoriosExtra: DIRECTORIOS_EXTRA_PAQUETE_COMPLETO, testSkipPattern: TEST_SKIP_PATTERN_GIT_STATCACHE,
+  }),
+  Object.freeze({ modulo: 'scripts/lib/signed-envelope.js', testFiles: Object.freeze(['tests/lib/signed-envelope.test.js']) }),
+  Object.freeze({ modulo: 'scripts/lib/policy-contract.js', testFiles: Object.freeze(['tests/lib/policy-contract.test.js']) }),
+  Object.freeze({ modulo: 'scripts/lib/principal-verifier.js', testFiles: Object.freeze(['tests/lib/principal-verifier.test.js']) }),
+  // (HALLAZGO real de fix de granularidad, corrida diagnóstica 2026-07-17,
+  // ver DEUDA-TECNICA.md#DT-T07-MUTANTES-CRITICOS-SOBREVIVIENTES § granularidad):
+  // `policy-context-provider.test.js` compila el policy bundle real en cada
+  // test (`compilarPolicyBundle` -> `capturarHarnessSourceSnapshot`), que
+  // requiere `.git` (`resolverRaizGit`/`ejecutarGit`) Y el ÁRBOL de trabajo
+  // real (`leerFuente`/`validarSegmentos` leen `agentes/`, `habilidades/`,
+  // `comandos/`, `reglas/` DIRECTAMENTE del filesystem, no vía git plumbing).
+  // CORRECCIÓN DE UNA FALSA DECLARACIÓN PROPIA (segunda iteración de este
+  // mismo fix): `['.git']` a secas pasaba en un diagnóstico AISLADO (sin
+  // `plantillaGit` compartida) porque, sin plantilla, `copiarGit` cae a
+  // `clonarGitLocal` — un checkout COMPLETO real que de paso trae todo el
+  // árbol de trabajo. En la corrida real (`ejecutarMutationTesting`, que SÍ
+  // usa una `plantillaGit` compartida) `copiarGit` sólo copia el subdirectorio
+  // `.git` de la plantilla, NO su árbol de trabajo — un módulo que declare
+  // sólo `.git` queda con `.git` pero SIN `agentes/`, dando ENOENT real
+  // ("lstat ... agentes") en la corrida de punta a punta. Por eso, igual que
+  // los módulos #1/#2, se declara `DIRECTORIOS_EXTRA_PAQUETE_COMPLETO`
+  // completo (ya incluye `.git` + el árbol de trabajo real).
+  Object.freeze({
+    modulo: 'scripts/lib/policy-context-provider.js', testFiles: Object.freeze(['tests/lib/policy-context-provider.test.js']),
+    directoriosExtra: DIRECTORIOS_EXTRA_PAQUETE_COMPLETO,
+  }),
+  Object.freeze({ modulo: 'scripts/lib/approval-receipts.js', testFiles: Object.freeze(['tests/lib/approval-receipts.test.js']) }),
+  Object.freeze({ modulo: 'scripts/lib/evidence-verifier.js', testFiles: Object.freeze(['tests/lib/evidence-verifier.test.js']) }),
+  Object.freeze({ modulo: 'scripts/lib/integrity-ledger.js', testFiles: Object.freeze(['tests/lib/integrity-ledger.test.js']), testSkipPattern: TEST_SKIP_PATTERN_INTEGRITY_LEDGER }),
+  Object.freeze({ modulo: 'scripts/lib/single-use-store.js', testFiles: Object.freeze(['tests/lib/single-use-store.test.js']) }),
+  Object.freeze({ modulo: 'scripts/lib/gate-engine.js', testFiles: Object.freeze(['tests/lib/gate-engine.test.js']) }),
+  // (HALLAZGO real, misma corrida diagnóstica): `policy-broker.test.js`
+  // combina el mismo `compilarPolicyBundle` (requiere el árbol completo +
+  // `.git`, ver nota arriba junto a policy-context-provider.js) CON
+  // `loadPolicyCorpus()` que lee `manifiestos/policy-corpus-w2.json`
+  // directamente. `DIRECTORIOS_EXTRA_PAQUETE_COMPLETO` ya incluye
+  // `manifiestos`, así que cubre ambos requisitos con una sola declaración.
+  Object.freeze({
+    modulo: 'scripts/lib/policy-broker.js', testFiles: Object.freeze(['tests/lib/policy-broker.test.js']),
+    directoriosExtra: DIRECTORIOS_EXTRA_PAQUETE_COMPLETO,
+  }),
+  // (HALLAZGO real, misma corrida diagnóstica, tres iteraciones): ambos
+  // testFiles importan `tests/_helpers/sandbox.js` (patrón obligatorio de
+  // cleanup de `~/.claude/rules/tests-cleanup.md`) — directorio HERMANO de
+  // `tests/lib`, no incluido por DIRECTORIOS_POR_DEFECTO.
+  // `legacy-gate-migration.js` ADEMÁS requiere `hooks/lib/atomic-write.js`
+  // directamente (mismo patrón que `runtime-compiler.js`, ver abajo). Y
+  // `gate-cli-integration.test.js` spawnea el CLI real
+  // (`CLI = path.join(__dirname, '..', '..', 'bin', 'swl-ses.js')`) como
+  // proceso hijo — requiere `bin`, y `bin/swl-ses.js` a su vez hace
+  // `require('../package.json')` para resolver metadata del paquete
+  // (sólo LECTURA de la copia efímera — nunca se escribe, ver Whitelist F32).
+  // Los cuatro hallazgos verificados con `correrLineaBase` aislado en
+  // iteraciones sucesivas.
+  Object.freeze({
+    modulo: 'scripts/lib/legacy-gate-migration.js',
+    testFiles: Object.freeze(['tests/scripts/migrar-gates-legacy.test.js', 'tests/scripts/gate-cli-integration.test.js']),
+    directoriosExtra: Object.freeze(['tests/_helpers', 'hooks', 'bin', 'package.json']),
+  }),
+  // (HALLAZGO real, misma corrida diagnóstica): `runtime-adapter-contract.test.js`
+  // lee `manifiestos/runtime-adapters-core3.json` y `manifiestos/runtime-conformance.json`
+  // directamente (contrato Core-3 real, no un fixture). Verificado con
+  // `correrLineaBase` aislado: ENOENT en ambos archivos sin esta declaración.
+  Object.freeze({
+    modulo: 'scripts/lib/runtime-adapter-contract.js', testFiles: Object.freeze(['tests/lib/runtime-adapter-contract.test.js']),
+    directoriosExtra: Object.freeze(['manifiestos']),
+  }),
+  Object.freeze({ modulo: 'scripts/lib/runtime-artifact-verifier.js', testFiles: Object.freeze(['tests/lib/runtime-artifact-verifier.test.js']) }),
+  // (HALLAZGO real, diagnóstico original del orquestador, confirmado y
+  // ampliado por `correrLineaBase` aislado en varias iteraciones):
+  // `runtime-compiler.js` depende transitivamente de `hooks/lib/atomic-write.js`
+  // vía `scripts/lib/toml-merge.js` (MODULE_NOT_FOUND sin `hooks`) Y su
+  // testFile compila el harness IR real (`compilarHarnessIR` ->
+  // `capturarHarnessSourceSnapshot`), que requiere el árbol completo + `.git`
+  // (mismo patrón que policy-context-provider.js, ver nota arriba).
+  // `DIRECTORIOS_EXTRA_PAQUETE_COMPLETO` ya incluye `hooks`, así que cubre
+  // ambos requisitos con una sola declaración.
+  Object.freeze({
+    modulo: 'scripts/lib/runtime-compiler.js', testFiles: Object.freeze(['tests/lib/runtime-compiler.test.js']),
+    directoriosExtra: DIRECTORIOS_EXTRA_PAQUETE_COMPLETO,
+  }),
+  Object.freeze({ modulo: 'scripts/lib/runtime-operation-adapter.js', testFiles: Object.freeze(['tests/lib/runtime-operation-adapter.test.js']) }),
+  Object.freeze({ modulo: 'scripts/lib/runtime-build-attestation.js', testFiles: Object.freeze(['tests/lib/runtime-build-attestation.test.js']) }),
+  // (HALLAZGO real, misma corrida diagnóstica): `runtime-doctor-core3.test.js`
+  // lee `manifiestos/runtime-adapters-core3.json` directamente. Verificado
+  // con `correrLineaBase` aislado: ENOENT sin esta declaración.
+  Object.freeze({
+    modulo: 'scripts/lib/runtime-doctor-core3.js', testFiles: Object.freeze(['tests/lib/runtime-doctor-core3.test.js']),
+    directoriosExtra: Object.freeze(['manifiestos']),
+  }),
+  // (HALLAZGO real, misma corrida diagnóstica, varias iteraciones): igual
+  // que legacy-gate-migration.js, importa `tests/_helpers/sandbox.js`
+  // (directorio HERMANO de `tests/lib`, no cubierto por
+  // DIRECTORIOS_EXTRA_PAQUETE_COMPLETO). Y, como runtime-compiler.js/
+  // policy-context-provider.js, su testFile ejercita rutas que compilan el
+  // harness real y requieren el árbol completo + `.git` — se agrega
+  // `tests/_helpers` al paquete completo (no basta con `.git` solo, ver nota
+  // arriba junto a policy-context-provider.js).
+  Object.freeze({
+    modulo: 'scripts/lib/runtime-bundle-installer.js', testFiles: Object.freeze(['tests/lib/runtime-bundle-installer.test.js']),
+    directoriosExtra: Object.freeze([...DIRECTORIOS_EXTRA_PAQUETE_COMPLETO, 'tests/_helpers']),
+  }),
+]);
+
+// Metadata descriptiva de los 5 operadores — sólo para el reporte/documentación,
+// la lógica real vive en generarMutantes().
+const OPERADORES = Object.freeze([
+  Object.freeze({ id: 'M1', nombre: 'Negar igualdad estricta', patron: '=== <-> !==' }),
+  Object.freeze({ id: 'M2', nombre: 'Negar operador lógico', patron: '&& <-> ||' }),
+  Object.freeze({ id: 'M3', nombre: 'Invertir literal booleano', patron: 'true <-> false' }),
+  Object.freeze({ id: 'M4', nombre: 'Relajar umbral numérico', patron: '[<>]=? entero (genera +1 y -1)' }),
+  Object.freeze({
+    id: 'M5', nombre: 'Neutralizar guard de seguridad',
+    patron: 'fallar(...)/throw ...; standalone -> comentada; if (cond) fallar/throw; -> if (false) ...',
+  }),
+]);
+
+// =============================================================================
+// enmascarar — reemplaza el contenido de strings, comentarios y literales
+// regex por relleno neutro ('#'), preservando longitud y saltos de línea
+// reales. Los operadores M1-M5 sólo escanean el texto YA enmascarado, para
+// nunca mutar dentro de un string/comentario/regex.
+// =============================================================================
+
+const PALABRAS_INICIO_REGEX = new Set([
+  'return', 'typeof', 'case', 'in', 'of', 'new', 'instanceof', 'throw', 'yield', 'await',
+]);
+const CHARS_INICIO_REGEX = new Set(['{', '(', ',', '=', ':', '[', '!', '&', '|', '?', '}', ';', '\n']);
+
+function esInicioDeRegex(colaCode) {
+  const recortado = colaCode.replace(/\s+$/u, '');
+  if (recortado.length === 0) return true;
+  const ultimo = recortado[recortado.length - 1];
+  if (CHARS_INICIO_REGEX.has(ultimo)) return true;
+  const coincidencia = recortado.match(/[A-Za-z_$][A-Za-z0-9_$]*$/u);
+  return Boolean(coincidencia && PALABRAS_INICIO_REGEX.has(coincidencia[0]));
+}
+
+/** Busca, desde `inicio` (justo tras el '/' de apertura), un '/' de cierre no
+ * escapado y fuera de una clase de caracteres `[...]`, antes del siguiente
+ * '\n'. Devuelve -1 si no hay cierre en la misma línea (un regex literal de
+ * JS nunca puede contener un salto de línea real sin escapar) — esto acota
+ * el riesgo de falso-positivo descrito en el memo de diseño: si no hay
+ * cierre en la línea, NO es un regex, se trata el '/' como código normal. */
+function buscarCierreRegexEnLinea(codigoFuente, inicio) {
+  let dentroDeClase = false;
+  for (let j = inicio; j < codigoFuente.length; j += 1) {
+    const c = codigoFuente[j];
+    if (c === '\n') return -1;
+    if (c === '\\') { j += 1; continue; }
+    if (c === '[') dentroDeClase = true;
+    else if (c === ']') dentroDeClase = false;
+    else if (c === '/' && !dentroDeClase) return j;
+  }
+  return -1;
+}
+
+function enmascararDelimitado(codigoFuente, salida, inicio, delimitador) {
+  let i = inicio;
+  const n = codigoFuente.length;
+  while (i < n) {
+    const d = codigoFuente[i];
+    if (d === '\n') { salida[i] = '\n'; i += 1; continue; }
+    if (d === '\\' && i + 1 < n) { salida[i] = '#'; salida[i + 1] = '#'; i += 2; continue; }
+    salida[i] = '#';
+    i += 1;
+    if (d === delimitador) break;
+  }
+  return i;
+}
+
+function enmascararComentarioLinea(codigoFuente, salida, inicio) {
+  let i = inicio;
+  salida[i] = '#'; salida[i + 1] = '#'; i += 2;
+  const n = codigoFuente.length;
+  while (i < n && codigoFuente[i] !== '\n') { salida[i] = '#'; i += 1; }
+  return i;
+}
+
+function enmascararComentarioBloque(codigoFuente, salida, inicio) {
+  let i = inicio;
+  salida[i] = '#'; salida[i + 1] = '#'; i += 2;
+  const n = codigoFuente.length;
+  while (i < n) {
+    if (codigoFuente[i] === '\n') { salida[i] = '\n'; i += 1; continue; }
+    if (codigoFuente[i] === '*' && codigoFuente[i + 1] === '/') {
+      salida[i] = '#'; salida[i + 1] = '#'; i += 2; break;
+    }
+    salida[i] = '#'; i += 1;
+  }
+  return i;
+}
+
+function enmascararRegexLiteral(codigoFuente, salida, inicio, fin) {
+  let j = inicio;
+  for (; j <= fin; j += 1) salida[j] = '#';
+  j += 1;
+  while (j < codigoFuente.length && /[a-z]/iu.test(codigoFuente[j])) { salida[j] = '#'; j += 1; }
+  return j;
+}
+
+/** Procesa un único carácter de posición `i` del enmascarado (string,
+ * comentario de línea/bloque, regex-literal o código normal) y devuelve el
+ * nuevo índice y la nueva "cola de código" para decidir si el siguiente '/'
+ * puede ser inicio de regex. Extraído de `enmascarar` (hallazgo MENOR de
+ * verificación T-07: la función excedía el límite de 30 líneas de
+ * estilo-codigo.md). Puro. */
+function procesarCaracter(codigoFuente, salida, i, colaCode) {
+  const c = codigoFuente[i];
+  if (c === "'" || c === '"' || c === '`') {
+    salida[i] = '#';
+    return { i: enmascararDelimitado(codigoFuente, salida, i + 1, c), colaCode: '' };
+  }
+  if (c === '/' && codigoFuente[i + 1] === '/') {
+    return { i: enmascararComentarioLinea(codigoFuente, salida, i), colaCode: '' };
+  }
+  if (c === '/' && codigoFuente[i + 1] === '*') {
+    return { i: enmascararComentarioBloque(codigoFuente, salida, i), colaCode: '' };
+  }
+  if (c === '/' && esInicioDeRegex(colaCode)) {
+    const fin = buscarCierreRegexEnLinea(codigoFuente, i + 1);
+    if (fin !== -1) {
+      return { i: enmascararRegexLiteral(codigoFuente, salida, i, fin), colaCode: '' };
+    }
+  }
+  salida[i] = c;
+  return { i: i + 1, colaCode: c === '\n' ? '' : (colaCode + c).slice(-20) };
+}
+
+/** Enmascara strings/comentarios/regex-literales de un código fuente JS,
+ * preservando longitud exacta y saltos de línea reales. Puro. */
+function enmascarar(codigoFuente) {
+  const n = codigoFuente.length;
+  const salida = new Array(n);
+  let colaCode = '';
+  let i = 0;
+  while (i < n) {
+    ({ i, colaCode } = procesarCaracter(codigoFuente, salida, i, colaCode));
+  }
+  return salida.join('');
+}
+
+// =============================================================================
+// generarMutantes — escanea el texto ENMASCARADO línea por línea y produce
+// mutantes cuyos offsets (inicioAbs/finAbs) apuntan al código fuente ORIGINAL.
+// =============================================================================
+
+function calcularOffsetsDeLineas(lineas) {
+  const offsets = new Array(lineas.length);
+  let acumulado = 0;
+  for (let i = 0; i < lineas.length; i += 1) {
+    offsets[i] = acumulado;
+    acumulado += lineas[i].length + 1;
+  }
+  return offsets;
+}
+
+function construirMutante(ctx, operador, inicioRel, finRel, original, mutado) {
+  return {
+    modulo: ctx.rutaRelativa, linea: ctx.numeroLinea, operador, original, mutado,
+    inicioAbs: ctx.offsetLinea + inicioRel, finAbs: ctx.offsetLinea + finRel,
+  };
+}
+
+function agregarM1(mutantes, ctx) {
+  for (const m of ctx.lineaMask.matchAll(/===|!==/gu)) {
+    const mutado = m[0] === '===' ? '!==' : '===';
+    mutantes.push(construirMutante(ctx, 'M1', m.index, m.index + m[0].length, m[0], mutado));
+  }
+}
+
+function agregarM2(mutantes, ctx) {
+  for (const m of ctx.lineaMask.matchAll(/&&|\|\|/gu)) {
+    const mutado = m[0] === '&&' ? '||' : '&&';
+    mutantes.push(construirMutante(ctx, 'M2', m.index, m.index + m[0].length, m[0], mutado));
+  }
+}
+
+function agregarM3(mutantes, ctx) {
+  for (const m of ctx.lineaMask.matchAll(/\btrue\b|\bfalse\b/gu)) {
+    const mutado = m[0] === 'true' ? 'false' : 'true';
+    mutantes.push(construirMutante(ctx, 'M3', m.index, m.index + m[0].length, m[0], mutado));
+  }
+}
+
+function agregarM4(mutantes, ctx) {
+  for (const m of ctx.lineaMask.matchAll(/[<>]=?\s*([0-9]+)/gu)) {
+    const digitos = m[1];
+    const inicio = m.index + (m[0].length - digitos.length);
+    const fin = inicio + digitos.length;
+    const valor = Number.parseInt(digitos, 10);
+    for (const delta of [1, -1]) {
+      mutantes.push(construirMutante(ctx, 'M4', inicio, fin, digitos, String(valor + delta)));
+    }
+  }
+}
+
+const RE_STANDALONE_GUARD = /^(fallar\([\s\S]*\);|throw\s[\s\S]*;)$/u;
+const RE_IF_GUARD = /^(\s*if\s*\()([\s\S]*?)(\)\s*(?:fallar\(|throw\s)[\s\S]*;\s*)$/u;
+
+function detectarGuardEnLinea(lineaMask) {
+  const m = lineaMask.match(RE_IF_GUARD);
+  if (!m) return null;
+  const inicioCondicion = m[1].length;
+  const finCondicion = inicioCondicion + m[2].length;
+  return { inicioCondicion, finCondicion };
+}
+
+function agregarM5(mutantes, ctx) {
+  const trimMask = ctx.lineaMask.trim();
+  if (RE_STANDALONE_GUARD.test(trimMask)) {
+    const indent = ctx.lineaOriginal.match(/^\s*/u)[0];
+    const contenido = ctx.lineaOriginal.slice(indent.length);
+    const mutado = `${indent}// mutación: ${contenido}`;
+    mutantes.push(construirMutante(ctx, 'M5', 0, ctx.lineaOriginal.length, ctx.lineaOriginal, mutado));
+    return;
+  }
+  const guard = detectarGuardEnLinea(ctx.lineaMask);
+  if (!guard) return;
+  const original = ctx.lineaOriginal.slice(guard.inicioCondicion, guard.finCondicion);
+  mutantes.push(construirMutante(ctx, 'M5', guard.inicioCondicion, guard.finCondicion, original, 'false'));
+}
+
+function agregarMutantesDeLinea(mutantes, ctx) {
+  agregarM1(mutantes, ctx);
+  agregarM2(mutantes, ctx);
+  agregarM3(mutantes, ctx);
+  agregarM4(mutantes, ctx);
+  agregarM5(mutantes, ctx);
+}
+
+/** Genera todos los mutantes M1-M5 de un módulo. Puro: sólo texto en
+ * memoria, ningún I/O ni reloj. El orden de recorrido (línea ascendente,
+ * M1->M2->M3->M4->M5 dentro de cada línea) es determinista — memo §8. */
+function generarMutantes(codigoFuente, rutaRelativa) {
+  const enmascarado = enmascarar(codigoFuente);
+  const lineasOriginal = codigoFuente.split('\n');
+  const lineasMask = enmascarado.split('\n');
+  const offsets = calcularOffsetsDeLineas(lineasOriginal);
+  const mutantes = [];
+  for (let i = 0; i < lineasOriginal.length; i += 1) {
+    agregarMutantesDeLinea(mutantes, {
+      lineaOriginal: lineasOriginal[i], lineaMask: lineasMask[i],
+      offsetLinea: offsets[i], numeroLinea: i + 1, rutaRelativa,
+    });
+  }
+  return mutantes;
+}
+
+function aplicarMutante(codigoFuente, mutante) {
+  return codigoFuente.slice(0, mutante.inicioAbs) + mutante.mutado + codigoFuente.slice(mutante.finAbs);
+}
+
+// =============================================================================
+// clasificarCritico — REQ-32-07 "100% de mutantes críticos eliminados"; regla
+// exacta de §3 del memo de diseño. Deliberadamente conservadora hacia marcar
+// de más como crítico, nunca hacia excluir.
+// =============================================================================
+
+const RE_DECLARACION_FUNCION = /^function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/u;
+// (HALLAZGO real de verificación T-07, MAYOR): los 20 módulos críticos
+// declaran funciones de capability-token ("no falsificable vía WeakMap+owner")
+// como propiedades de objeto con arrow function -- `isGateReceipt: (value) =>
+// ...` (gate-engine.js:850-851, single-use-store.js:340-341,
+// integrity-ledger.js:1043-1044, policy-broker.js:334) -- que
+// RE_DECLARACION_FUNCION nunca detectaba (sólo matchea `function nombre(`).
+const RE_DECLARACION_PROPIEDAD_ARROW = /^\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*:\s*(?:async\s+)?\([^()]*\)\s*=>/u;
+// (HALLAZGO real de verificación T-07, MAYOR, mismo defecto de clase): un
+// grep amplio de los 20 módulos críticos (todos F29/F30/F31, nombrados en
+// inglés) confirmó que RE_NOMBRE_FUNCION_CRITICA sólo reconocía prefijos en
+// ESPAÑOL -- "validar"/"verificar"/"puede[A-Z]"/"es[A-Z]" nunca matchean
+// "validate"/"verify"/"can[A-Z]"/"is[A-Z]" (decenas de funciones validate*/
+// verify* en policy-contract.js, principal-verifier.js,
+// policy-context-provider.js, approval-receipts.js, evidence-verifier.js,
+// single-use-store.js, gate-engine.js, legacy-gate-migration.js,
+// runtime-build-attestation.js, runtime-doctor-core3.js; canPersistInvalidation
+// en gate-engine.js; isDataObject/isDataArray/isRealDirectory en
+// runtime-doctor-core3.js, isVerifiedOperation/isKernelDependencies en
+// policy-contract.js, fail() en legacy-gate-migration.js/
+// runtime-build-attestation.js) -- se agregan los equivalentes ingleses
+// paralelos a los ya existentes en español (misma exigencia de mayúscula
+// tras el prefijo para is[A-Z]/can[A-Z], igual que es[A-Z]/puede[A-Z], para
+// no matchear substrings como "issueGrant"/"canonicalHash").
+const RE_NOMBRE_FUNCION_CRITICA = /^(validar|validate|verificar|verify|fallar|fail|es[A-Z]|is[A-Z]|puede[A-Z]|can[A-Z]|comparar|coincide)/u;
+const IDENTIFICADORES_INTEGRIDAD = Object.freeze(['digest', 'Hash', 'signature', 'Digest', 'SHA256', 'firma']);
+const IDENTIFICADORES_UMBRAL = Object.freeze(['MAX_', 'Length', 'byteLength', 'size', 'sequence', 'expiresAt', 'issuedAt']);
+
+function nombreFuncionContenedora(lineasMask, numeroLinea) {
+  for (let i = numeroLinea - 1; i >= 0; i -= 1) {
+    const linea = lineasMask[i];
+    const declaracion = linea.match(RE_DECLARACION_FUNCION) || linea.match(RE_DECLARACION_PROPIEDAD_ARROW);
+    if (declaracion) return declaracion[1];
+  }
+  return null;
+}
+
+/** Clasifica un mutante como crítico ("cambia una decisión de seguridad")
+ * según §3 del memo. `codigoFuenteEnmascarado` es el texto YA enmascarado
+ * del módulo completo (identificadores y nombres de función siguen
+ * visibles en el enmascarado — sólo strings/comentarios/regex se ocultan).
+ * Puro. */
+function clasificarCritico(mutante, codigoFuenteEnmascarado) {
+  if (mutante.operador === 'M5') return true;
+
+  const lineasMask = codigoFuenteEnmascarado.split('\n');
+  const nombreFuncion = nombreFuncionContenedora(lineasMask, mutante.linea);
+  if (nombreFuncion && RE_NOMBRE_FUNCION_CRITICA.test(nombreFuncion)) return true;
+
+  const lineaMask = lineasMask[mutante.linea - 1] || '';
+  if ((mutante.operador === 'M1' || mutante.operador === 'M2')
+    && IDENTIFICADORES_INTEGRIDAD.some((id) => lineaMask.includes(id))) {
+    return true;
+  }
+  if (mutante.operador === 'M4' && IDENTIFICADORES_UMBRAL.some((id) => lineaMask.includes(id))) {
+    return true;
+  }
+  return false;
+}
+
+// =============================================================================
+// Ejecución real: copia efímera + spawn asíncrono + clasificación
+// muerto/sobrevivió. Única parte del módulo con efectos.
+// =============================================================================
+
+/** Clona `.git` local con checkout completo (`--shared` referencia los
+ * objects reales del repo vía alternates — sin copiar el historial) en
+ * `destino`, que debe estar vacío en este punto. Requiere el checkout real
+ * (no `--no-checkout`): `harness-source-snapshot.js` lee `.git/index`
+ * directamente, y ese archivo sólo existe tras un checkout — ver comentario
+ * de DIRECTORIOS_EXTRA_PAQUETE_COMPLETO. */
+function clonarGitLocal(raizRepo, destino) {
+  execFileSync('git', ['clone', '--local', '--shared', raizRepo, destino], { stdio: 'pipe' });
+}
+
+/** Crea UNA plantilla de `.git` (clon+checkout completo) reutilizable por
+ * TODAS las tareas que la necesiten (memo T-07 § hallazgo policy-bundle.test.js).
+ * Medido: clonar de nuevo por tarea cuesta ~3.6s (dominado por escribir
+ * ~1700 archivos en NTFS) — con 222 tareas eso paralizó la corrida real bajo
+ * concurrencia (contención de I/O/antivirus). La plantilla post-checkout
+ * pesa sólo ~260KB (--shared no copia objects) y copiarla por tarea cuesta
+ * ~30ms — la mutación real sólo toca `scripts/lib/<modulo>.js`, nunca
+ * `.git`, así que compartir la plantilla entre tareas es seguro: cada tarea
+ * la copia (nunca la enlaza — un `.git/index` enlazado se RECHAZA
+ * explícitamente por `harness-source-snapshot.js#resolverIndiceGit`). */
+function prepararPlantillaGit(raizRepo) {
+  const plantilla = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-w4-git-plantilla-'));
+  // (HALLAZGO real de verificación T-07, MAYOR): si clonarGitLocal lanza
+  // (git ausente, fallo de disco/permisos), el directorio ya creado por
+  // mkdtempSync quedaba huérfano -- nada lo referenciaba para limpiarlo
+  // (el finally del caller sólo limpia `plantillaGit`, que nunca llegaba a
+  // asignarse). Se limpia aquí mismo antes de relanzar.
+  try {
+    clonarGitLocal(raizRepo, plantilla);
+  } catch (error) {
+    fs.rmSync(plantilla, { recursive: true, force: true });
+    throw error;
+  }
+  return plantilla;
+}
+
+/** Combina DIRECTORIOS_POR_DEFECTO (o el override del caller) con los
+ * `directoriosExtra` propios de un módulo (memo T-07 § hallazgo
+ * policy-bundle.test.js) — nunca penaliza a los módulos que no los
+ * necesitan. */
+function directoriosParaModulo(directoriosBase, entrada) {
+  if (!entrada || !Array.isArray(entrada.directoriosExtra) || entrada.directoriosExtra.length === 0) {
+    return directoriosBase;
+  }
+  return [...new Set([...directoriosBase, ...entrada.directoriosExtra])];
+}
+
+function copiarGit(raizRepo, destino, plantillaGit) {
+  if (plantillaGit) {
+    fs.cpSync(path.join(plantillaGit, '.git'), path.join(destino, '.git'), { recursive: true });
+    return;
+  }
+  if (fs.existsSync(path.join(raizRepo, '.git'))) clonarGitLocal(raizRepo, destino);
+}
+
+function copiarArboles(raizRepo, destino, directorios, plantillaGit) {
+  if (directorios.includes('.git')) copiarGit(raizRepo, destino, plantillaGit);
+  for (const dir of directorios) {
+    if (dir === '.git') continue;
+    const origen = path.join(raizRepo, dir);
+    if (!fs.existsSync(origen)) continue;
+    fs.cpSync(origen, path.join(destino, dir), { recursive: true });
+  }
+}
+
+/** Decide QUÉ comando mataría el árbol completo del proceso `pid` para
+ * `platform` (parámetro explícito, nunca lee `process.platform`
+ * internamente — así ambas ramas son testeables desde cualquier SO). Puro.
+ *
+ * (HALLAZGO real de verificación T-07, CRÍTICO): la versión previa usaba
+ * EXCLUSIVAMENTE `taskkill` (Windows). La CI real del proyecto corre en
+ * `ubuntu-latest` (.github/workflows/ci.yml, paso "Ejecutar tests
+ * unitarios"): en Linux/macOS `execFileSync('taskkill', ...)` lanza ENOENT
+ * y se tragaba en el catch vacío de `matarArbolDeProceso` SIN matar al
+ * proceso colgado — reproducido experimentalmente: un proceso Node padre
+ * con stdio en modo pipe se queda esperando indefinidamente a un hijo
+ * colgado que nunca murió. En POSIX no hay 'kill de árbol' nativo sin
+ * recorrer /proc (fuera de zero-deps): la alternativa portable es spawnear
+ * el hijo como líder de su propio grupo de procesos (`detached: true` en
+ * `spawnTestsAsync`) y matar el GRUPO completo con `process.kill(-pid,
+ * 'SIGKILL')` — alcanza también a los nietos (forks internos de módulos
+ * como integrity-ledger.test.js). */
+function decidirComandoMatarArbol(pid, platform) {
+  if (platform === 'win32') {
+    return { ejecutable: 'taskkill', argv: ['/pid', String(pid), '/t', '/f'] };
+  }
+  return { grupoPosix: true, pid };
+}
+
+/** Best-effort: mata el árbol completo del proceso (no sólo el hijo directo
+ * — módulos como integrity-ledger.test.js forkean workers propios). Puede
+ * fallar si el proceso ya terminó entre el timeout y el intento de matarlo;
+ * eso no es un error real, sólo una carrera benigna. */
+function matarArbolDeProceso(pid) {
+  const comando = decidirComandoMatarArbol(pid, process.platform);
+  try {
+    if (comando.grupoPosix) {
+      process.kill(-comando.pid, 'SIGKILL');
+    } else {
+      execFileSync(comando.ejecutable, comando.argv, { stdio: 'pipe' });
+    }
+  } catch {
+    // Ignorado a propósito — ver docstring.
+  }
+}
+
+function spawnTestsAsync(cwd, testFiles, testSkipPattern, timeoutMs) {
+  return new Promise((resolve) => {
+    const argv = ['--test', '--test-reporter=tap', '--test-reporter-destination=stdout'];
+    if (testSkipPattern) argv.push(`--test-skip-pattern=${testSkipPattern}`);
+    argv.push(...testFiles);
+    // detached=true en POSIX: el hijo se vuelve líder de su propio grupo de
+    // procesos, condición necesaria para poder matar el GRUPO completo con
+    // `process.kill(-pid, ...)` en decidirComandoMatarArbol — en win32 no
+    // aplica (taskkill /t recorre el árbol por sí solo).
+    const proceso = spawn(
+      process.execPath, argv, { cwd, shell: false, detached: process.platform !== 'win32' }
+    );
+    let stdout = '';
+    let stderr = '';
+    let resuelto = false;
+    const limite = Number.isInteger(timeoutMs) && timeoutMs > 0 ? timeoutMs : TIMEOUT_MS_POR_DEFECTO;
+    const temporizador = setTimeout(() => {
+      if (resuelto) return;
+      resuelto = true;
+      matarArbolDeProceso(proceso.pid);
+      resolve({ exitCode: null, stdout, stderr, agotoTiempo: true });
+    }, limite);
+    proceso.stdout.on('data', (dato) => { stdout += dato; });
+    proceso.stderr.on('data', (dato) => { stderr += dato; });
+    proceso.on('close', (exitCode) => {
+      if (resuelto) return;
+      resuelto = true;
+      clearTimeout(temporizador);
+      resolve({ exitCode, stdout, stderr, agotoTiempo: false });
+    });
+  });
+}
+
+const RE_NOT_OK = /^\s*not ok \d+ - (.+)$/mu;
+
+function construirEntradaMutante(mutante, critico, estado, testQueLoMato, detailCode) {
+  return {
+    modulo: mutante.modulo, linea: mutante.linea, operador: mutante.operador,
+    original: mutante.original, mutado: mutante.mutado, inicioAbs: mutante.inicioAbs,
+    critico, estado, testQueLoMato, detailCode,
+  };
+}
+
+/** Clasifica el resultado de correr los tests contra un mutante: timeout ->
+ * muerto por TIMEOUT (el mutante convirtió una terminación en un colgado —
+ * ver TIMEOUT_MS_POR_DEFECTO); exit 0 -> sobrevivió; exit != 0 con "not ok"
+ * en el TAP -> muerto (por ese test); exit != 0 sin "not ok" -> muerto por
+ * SYNTAX_ERROR (el proceso no llegó a emitir TAP — típicamente el módulo
+ * mutado no cargó). Ver memo §5: contar SYNTAX_ERROR como muerto es la
+ * opción conservadora y difícil de gamear; TIMEOUT sigue el mismo criterio. */
+function clasificarResultado(mutante, critico, resultado) {
+  if (resultado.agotoTiempo) {
+    return construirEntradaMutante(mutante, critico, 'muerto', null, 'TIMEOUT');
+  }
+  if (resultado.exitCode === 0) {
+    return construirEntradaMutante(mutante, critico, 'sobrevivio', null, null);
+  }
+  const coincidencia = resultado.stdout.match(RE_NOT_OK);
+  if (!coincidencia) {
+    return construirEntradaMutante(mutante, critico, 'muerto', null, 'SYNTAX_ERROR');
+  }
+  return construirEntradaMutante(mutante, critico, 'muerto', coincidencia[1].trim(), null);
+}
+
+/** Salvaguarda anti-gaming (memo §5): si más del 1% de los mutantes de un
+ * módulo terminan en SYNTAX_ERROR, es señal de un enmascarado roto (los 5
+ * operadores son sintaxis-preservantes por construcción), no de guardas
+ * reales — lanza en vez de reportar un score que mentiría. Puro. */
+function verificarTasaSyntaxError(resultadosModulo, nombreModulo) {
+  const total = resultadosModulo.length;
+  if (total === 0) return;
+  const sintacticos = resultadosModulo.filter((r) => r.detailCode === 'SYNTAX_ERROR').length;
+  if (sintacticos / total > UMBRAL_SYNTAX_ERROR) {
+    fallar(
+      'MUTATION_ENGINE_INVALID',
+      `demasiados mutantes con SYNTAX_ERROR en ${nombreModulo}: ${sintacticos}/${total} `
+      + `(umbral ${UMBRAL_SYNTAX_ERROR * 100}%) — señal de enmascarado roto, no de guardas reales`
+    );
+  }
+}
+
+async function ejecutarUnaTarea(tarea, raizRepo, plantillaGit) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-w4-mutante-'));
+  try {
+    copiarArboles(raizRepo, tmp, tarea.directoriosACopiar, plantillaGit);
+    const contenidoMutado = aplicarMutante(tarea.codigoFuente, tarea.mutante);
+    fs.writeFileSync(path.join(tmp, tarea.mutante.modulo), contenidoMutado, 'utf8');
+    const resultado = await spawnTestsAsync(tmp, tarea.testFiles, tarea.testSkipPattern, tarea.timeoutMs);
+    return clasificarResultado(tarea.mutante, tarea.critico, resultado);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+async function ejecutarTareasConcurrentes(tareas, concurrencia, raizRepo, plantillaGit, onProgreso) {
+  const resultados = new Array(tareas.length);
+  let siguiente = 0;
+  let completadas = 0;
+
+  async function trabajador() {
+    for (;;) {
+      const indice = siguiente;
+      siguiente += 1;
+      if (indice >= tareas.length) return;
+      resultados[indice] = await ejecutarUnaTarea(tareas[indice], raizRepo, plantillaGit);
+      completadas += 1;
+      if (onProgreso) onProgreso({ completadas, total: tareas.length, ultimo: resultados[indice] });
+    }
+  }
+
+  const nTrabajadores = Math.max(1, Math.min(concurrencia, tareas.length || 1));
+  await Promise.all(Array.from({ length: nTrabajadores }, trabajador));
+  return resultados;
+}
+
+// =============================================================================
+// Ensamblado del reporte — determinista (memo §8 punto 4): orden fijo por
+// (índice de módulo en `modulos`, línea ascendente, orden de operador
+// M1..M5), aplicado ANTES de congelar, sin importar el orden real en que
+// terminaron las tareas concurrentes.
+// =============================================================================
+
+function calcularScore(muertos, total) {
+  if (total === 0) return 100;
+  return Math.round((muertos / total) * 10000) / 100;
+}
+
+const ORDEN_OPERADOR = Object.freeze({ M1: 0, M2: 1, M3: 2, M4: 3, M5: 4 });
+
+function ordenarMutantes(resultados, modulos) {
+  const indice = new Map(modulos.map((m, i) => [m.modulo, i]));
+  return [...resultados].sort((a, b) => {
+    const ia = indice.get(a.modulo);
+    const ib = indice.get(b.modulo);
+    if (ia !== ib) return ia - ib;
+    if (a.linea !== b.linea) return a.linea - b.linea;
+    return ORDEN_OPERADOR[a.operador] - ORDEN_OPERADOR[b.operador];
+  });
+}
+
+// ADR-0055: mutantes verificados como EQUIVALENTES — inmatables por diseño fail-closed
+// del kernel W2 (el operador mutado produce el MISMO código/mensaje observable por ambos
+// caminos; una validación redundante posterior atrapa lo que la anterior dejaría pasar).
+// Clave: modulo\0linea\0operador\0original\0mutado. Cada entrada pasa verificación
+// adversarial (un escéptico intenta matarla) antes de entrar; append-only con razón.
+// Se excluyen del DENOMINADOR de críticos SÓLO cuando sobreviven; un anotado que resulte
+// MUERTO hace FALLAR el motor (verificarAnotacionEquivalentes) porque la anotación
+// mentiría. La lista se puebla desde la verificación adversarial del cierre de DT-T07.
+const MUTANTES_EQUIVALENTES = new Set([
+  "scripts/lib/policy-bundle.js 253 M4 0 1 10891",  // policy-bundle L253 off10891: El regex M4 (/[<>]=?\s*[0-9]+/) solo matchea el '0' final de '.localeCompare(item) < 0'; NO el 'indice === 0' (no precedido de < o >), pese a que el…
+  "scripts/lib/signed-envelope.js 133 M5 error.codigo === 'IJSON_INVALID' false 5253",  // signed-envelope L133 off5253: El guard controla, dentro del catch de canonicalizarIJson, si se relanza el error original (rama verdadera) o se envuelve en uno nuevo vía…
+  "scripts/lib/policy-contract.js 59 M2 || && 2186",  // policy-contract L59 off2186: Nodo 2 (segundo `||`, aísla `Array.isArray(valor)`).
+  "scripts/lib/policy-contract.js 59 M2 || && 2215",  // policy-contract L59 off2215: Nodo 2 (segundo `||`, aísla `Array.isArray(valor)`).
+  "scripts/lib/policy-contract.js 101 M3 false true 3798",  // policy-contract L101 off3798: Default `permitirVacio = false` mutado a `true`.
+  "scripts/lib/policy-contract.js 102 M2 || && 3840",  // policy-contract L102 off3840: Nodo que aísla `(!permitirVacio && valor.length === 0)` del resto de la cadena `||`.
+  "scripts/lib/policy-contract.js 118 M2 || && 4416",  // policy-contract L118 off4416: Segundo nodo de L118 (aísla `item === '..'` de `!item || item === '.' || item === '..'`).
+  "scripts/lib/policy-contract.js 159 M2 || && 6100",  // policy-contract L159 off6100: Nodo que aísla `!Array.isArray(effect.argv)` en la cadena de validarProcessEffect.
+  "scripts/lib/policy-contract.js 191 M4 0 -1 7567",  // policy-contract L191 off7567: `index > 0` mutado a `index > -1`.
+  "scripts/lib/policy-contract.js 208 M5     fallar('CONTRACT_INVALID', 'effect desconocido');\r     // mutación: fallar('CONTRACT_INVALID', 'effect desconocido');\r 8109",  // policy-contract L208 off8109: `fallar('CONTRACT_INVALID', 'effect desconocido')` comentado.
+  "scripts/lib/principal-verifier.js 145 M2 || && 6213",  // principal-verifier L145 off6213: El termino C (current.rootKeyDigest !== authority.rootKeyDigest) es estructuralmente inalcanzable como true al llegar a la linea 145:…
+  "scripts/lib/approval-receipts.js 34 M2 || && 1469",  // approval-receipts L34 off1469: isScoped (línea 34) solo se usa para (a) elegir el arreglo de claves esperado por exactKeys() (línea 37) y (b) el guard de la línea 53.
+  "scripts/lib/evidence-verifier.js 73 M4 0 -1 3293",  // evidence-verifier L73 off3293: canonical.some((value, index) => index > 0 && canonical[index - 1] >= value).
+  "scripts/lib/single-use-store.js 229 M2 || && 9863",  // single-use-store L229 off9863: La línea 229 contiene DOS operadores || físicos distintos que colapsan a la misma clave de reporte (mismo módulo/línea/operador/original/mutado): (a)…
+  "scripts/lib/runtime-artifact-verifier.js 197 M2 || && 7781",  // runtime-artifact-verifier L197 off7781: Mismo fundamento estructural: B (`includes(':')`) es SIEMPRE false en la línea 197 porque SAFE_RELATIVE_PATH (líneas 192-195, evaluado antes) rechaza…
+  "scripts/lib/runtime-artifact-verifier.js 197 M2 || && 7807",  // runtime-artifact-verifier L197 off7807: Mismo fundamento estructural: B (`includes(':')`) es SIEMPRE false en la línea 197 porque SAFE_RELATIVE_PATH (líneas 192-195, evaluado antes) rechaza…
+  "scripts/lib/runtime-operation-adapter.js 84 M2 || && 3219",  // runtime-operation-adapter L84 off3219: esObjetoPlano(valor) = A||B||C||D con A=!valor, B=typeof valor!=='object', C=Array.isArray(valor), D=util.types.isProxy(valor).
+  "scripts/lib/runtime-operation-adapter.js 84 M2 || && 3248",  // runtime-operation-adapter L84 off3248: esObjetoPlano(valor) = A||B||C||D con A=!valor, B=typeof valor!=='object', C=Array.isArray(valor), D=util.types.isProxy(valor).
+  "scripts/lib/runtime-operation-adapter.js 85 M2 || && 3279",  // runtime-operation-adapter L85 off3279: Unica ocurrencia de '||' en L85, entre el termino C (Array.isArray) y D (isProxy): original A||B||C||D se muta a A||B||(C&&D).
+  "scripts/lib/runtime-operation-adapter.js 91 M5 !esObjetoPlano(valor) false 3482",  // runtime-operation-adapter L91 off3482: El guard `if (!esObjetoPlano(valor)) throw new TypeError('objeto invalido');` en validarClaves se desactiva por completo con la mutacion.
+  "scripts/lib/runtime-doctor-core3.js 78 M2 || && 2882",  // runtime-doctor-core3 L78 off2882: La condición completa es `!value || A || B || C` con A = `typeof value !== 'object'` y B = `Array.isArray(value)`.
+  "scripts/lib/runtime-doctor-core3.js 105 M4 0 -1 4150",  // runtime-doctor-core3 L105 off4150: El único valor donde `entry.length > 0` y `entry.length > -1` difieren es `entry.length === 0`, es decir `entry === ''` (el .length de un string…
+  "scripts/lib/integrity-ledger.js 165 M3 true false 6065",  // integrity-ledger L165 off6065: Mutación sobre el parámetro por defecto 'privado = true' de validarPermisos(stat, codigo, esDirectorio=false, privado=true).
+  "scripts/lib/integrity-ledger.js 711 M5 indice === inicio false 26125",  // integrity-ledger L711 off26125: dividirJsonl vive dentro del try de parsearLedger cuyo catch convierte toda excepcion a LEDGER_INVALID; indice===inicio produce un buffer de longitud…
+  "scripts/lib/gate-engine.js 572 M2 || && 25671",  // gate-engine L572 off25671: validateActiveG1 compara approval.planDigest !== state.planDigest.
+  "scripts/lib/gate-engine.js 573 M2 || && 25722",  // gate-engine L573 off25722: Mismo patrón que L572 pero con planBindingDigest/activeApprovalDigest: state.activeApprovalDigest=payload.approvalDigest se asigna en la MISMA…
+  "scripts/lib/gate-engine.js 574 M2 || && 25790",  // gate-engine L574 off25790: Compara approval.approverDigest !== context.config.actorBindings.human_approver.
+  "scripts/lib/gate-engine.js 633 M1 === !== 28533",  // gate-engine L633 off28533: Documentado en sesión previa (comentario ya existente en el archivo de test): la asignación task.g3EvidenceDigest=evidences[0].evidenceDigest escribe…
+  "scripts/lib/integrity-ledger.js 843 M3 false true 31149",  // integrity-ledger L843 off31149: esAutoridad=false es un default DEAD CODE: ambos call-sites (L897 y L932) pasan el 2do argumento explicitamente, el default nunca se ejercita.
+]);
+
+// La clave incluye inicioAbs (offset absoluto del operador en el fuente) para
+// ser ÚNICA por mutante: una línea puede tener varios operadores iguales (p.ej.
+// `!a || b || c` genera 3 mutantes M2 ||->&& con idéntico {linea,operador,
+// original,mutado}); sin el offset, anotar uno como equivalente anotaría a los
+// tres, confundiendo un matable con un equivalente. inicioAbs es estable porque
+// los 20 módulos del kernel están congelados (whitelist F32). Ver ADR-0055.
+function claveMutanteEquivalente(m) {
+  return [m.modulo, m.linea, m.operador, m.original, m.mutado, m.inicioAbs].join(' ');
+}
+
+function esEquivalenteSobreviviente(m) {
+  return m.estado === 'sobrevivio' && MUTANTES_EQUIVALENTES.has(claveMutanteEquivalente(m));
+}
+
+// Invariante fail-closed (ADR-0055 § Anti-gaming): un mutante anotado como equivalente
+// que resulte MUERTO demuestra que la anotación es falsa (un equivalente genuino es
+// inmatable). El motor falla en vez de excluirlo o inflar el score en silencio.
+function verificarAnotacionEquivalentes(mutantes) {
+  // Un anotado equivalente que muere por RUIDO de infraestructura (TIMEOUT del
+  // motor bajo carga, o SYNTAX_ERROR de un enmascarado roto) NO invalida la
+  // anotación: ni el timeout ni el syntax-error son un test que distinga la
+  // lógica del mutante del original — un equivalente genuino, por definición,
+  // no altera la terminación ni la sintaxis, así que un timeout/syntax-error
+  // sobre él es ruido, no detección. Sólo una muerte por un TEST real
+  // (detailCode ausente) demuestra que la anotación es falsa. Ver ADR-0055
+  // § "Ruido de infraestructura: tests de workers concurrentes".
+  const anotadoMatadoPorTest = mutantes.find(
+    (m) => m.estado === 'muerto' && !m.detailCode && MUTANTES_EQUIVALENTES.has(claveMutanteEquivalente(m))
+  );
+  if (anotadoMatadoPorTest) {
+    fallar('MUTATION_EQUIVALENTE_MATADO',
+      `mutante anotado equivalente fue matado por un test (anotación falsa): ${claveMutanteEquivalente(anotadoMatadoPorTest)}`);
+  }
+}
+
+// Cota anti-crecimiento-silencioso del conjunto de equivalentes (endurecimiento
+// tras la barrida de estabilización 2026-07-20; ADR-0055/0056 § Anti-gaming).
+// El vector de gaming detectado: `esEquivalenteSobreviviente` excluye un mutante
+// crítico SOBREVIVIENTE del denominador de críticos, subiendo el critical-score
+// a 100%; `verificarAnotacionEquivalentes` sólo caza la dirección contraria
+// (anotado que MUERE). Un maker podría mislabelar un crítico sobreviviente como
+// equivalente para inflar el score. Bajo ADR-0056 (operador único, maker =
+// revisor, misma superficie pineada) esto NO es prevenible por máquina — el
+// maker que agrega el equivalente falso controla también cualquier control en el
+// mismo tarball. Lo que SÍ se puede hacer es volverlo tamper-EVIDENTE: pinear el
+// tamaño del conjunto para que ninguna alta/baja pase en silencio; toda mutación
+// del conjunto exige bumpear esta cota explícitamente — un cambio visible en el
+// diff, revisable por CODEOWNERS. Controles de buena fe restantes: la
+// justificación por-entrada (comentarios de cada clave) y la verificación
+// adversarial previa a anotar (ADR-0055, invariante 3). La garantía adversarial
+// plena sólo se recupera con Ruta B (identidad independiente del juez).
+const MUTANTES_EQUIVALENTES_ESPERADOS = 29;
+
+// `tamano` es inyectable sólo para tests; el gate (ensamblarReporte) siempre lo
+// llama sin argumentos, atándose al tamaño real del conjunto pineado.
+function verificarCotaEquivalentes(tamano = MUTANTES_EQUIVALENTES.size) {
+  if (tamano !== MUTANTES_EQUIVALENTES_ESPERADOS) {
+    fallar('MUTATION_EQUIVALENTES_COTA',
+      `el conjunto de mutantes equivalentes cambió de tamaño (${tamano} vs ${MUTANTES_EQUIVALENTES_ESPERADOS} pineados): `
+      + 'toda alta/baja debe bumpear la cota explícitamente y justificarse (ADR-0055/0056 § Anti-gaming)');
+  }
+}
+
+function construirEntradaModulo(entrada, mutantes) {
+  const delModulo = mutantes.filter((m) => m.modulo === entrada.modulo);
+  const muertos = delModulo.filter((m) => m.estado === 'muerto').length;
+  const criticos = delModulo.filter((m) => m.critico && !esEquivalenteSobreviviente(m));
+  const criticosMuertos = criticos.filter((m) => m.estado === 'muerto').length;
+  return {
+    modulo: entrada.modulo, testFiles: [...entrada.testFiles],
+    totalMutantes: delModulo.length, muertos, sobrevivientes: delModulo.length - muertos,
+    score: calcularScore(muertos, delModulo.length),
+    criticos: { total: criticos.length, muertos: criticosMuertos },
+  };
+}
+
+function construirGlobal(mutantes) {
+  const total = mutantes.length;
+  const muertos = mutantes.filter((m) => m.estado === 'muerto').length;
+  const criticos = mutantes.filter((m) => m.critico && !esEquivalenteSobreviviente(m));
+  const criticosMuertos = criticos.filter((m) => m.estado === 'muerto').length;
+  return {
+    totalMutantes: total, muertos, sobrevivientes: total - muertos,
+    score: calcularScore(muertos, total),
+    criticos: { total: criticos.length, muertos: criticosMuertos, score: calcularScore(criticosMuertos, criticos.length) },
+  };
+}
+
+function ensamblarReporte(modulos, resultados) {
+  const mutantesOrdenados = ordenarMutantes(resultados, modulos);
+  verificarAnotacionEquivalentes(mutantesOrdenados);
+  verificarCotaEquivalentes();
+  return {
+    kind: 'swl-mutation-report',
+    schemaVersion: SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    global: construirGlobal(mutantesOrdenados),
+    porModulo: modulos.map((entrada) => construirEntradaModulo(entrada, mutantesOrdenados)),
+    mutantes: mutantesOrdenados,
+  };
+}
+
+// =============================================================================
+// ejecutarMutationTesting — orquestador público. `raizRepo`/`modulos`/
+// `directoriosACopiar` son inyectables EXCLUSIVAMENTE para que los tests
+// rápidos del propio motor usen un repo-fixture sintético en vez del kernel
+// real de 8,102 líneas; el uso de certificación real no pasa overrides.
+// =============================================================================
+
+function leerPristinos(raizRepo, modulos) {
+  const mapa = new Map();
+  for (const entrada of modulos) {
+    mapa.set(entrada.modulo, fs.readFileSync(path.join(raizRepo, entrada.modulo), 'utf8'));
+  }
+  return mapa;
+}
+
+/** Corre, SIN mutar, los testFiles de cada módulo — cada módulo dentro de su
+ * PROPIA copia efímera, construida con EXACTAMENTE los mismos
+ * `directoriosParaModulo(directoriosACopiar, entrada)` que usarán después sus
+ * tareas de mutante reales (`generarTareas`). Si algo falla aquí, es la
+ * señal correcta y temprana de que a ESE módulo le falta declarar su propio
+ * `directoriosExtra` — nunca un problema del entorno compartido (memo § Paso 2).
+ *
+ * CORRECCIÓN DE GRANULARIDAD (hallazgo real T-07, post-corrida completa
+ * 2026-07-17, ver DEUDA-TECNICA.md#DT-T07-MUTANTES-CRITICOS-SOBREVIVIENTES):
+ * la versión previa copiaba UNA sola vez la UNIÓN de `directoriosExtra` de
+ * todos los módulos del batch (`directoriosUnionParaModulos`, eliminada) y
+ * corría los testFiles de cada módulo DENTRO de esa copia compartida. Con
+ * los 20 módulos críticos juntos, esa unión incluía siempre
+ * `DIRECTORIOS_EXTRA_PAQUETE_COMPLETO` (declarado sólo por los módulos #1/#2)
+ * — enmascarando que otros módulos (p.ej. `runtime-compiler.js`, que
+ * requiere transitivamente `hooks/lib/atomic-write.js` vía
+ * `scripts/lib/toml-merge.js`) nunca declararon su propio `directoriosExtra`.
+ * El baseline "pasaba" para esos módulos SOLO por la presencia accidental de
+ * directorios que otro módulo del batch necesitaba — pero sus tareas de
+ * mutante reales (`generarTareas`, que sí usa `directoriosParaModulo` por
+ * módulo, sin unión) fallaban después en CADA mutante por MODULE_NOT_FOUND,
+ * contado falsamente como "muerto" por SYNTAX_ERROR (mide entorno roto, no
+ * detección real de mutación). Correr el baseline con la copia AISLADA por
+ * módulo (misma función `directoriosParaModulo` que usan las tareas reales)
+ * expone el hueco de inmediato, antes de generar un solo mutante. */
+async function correrLineaBase(raizRepo, modulos, directoriosACopiar, timeoutMs, plantillaGit) {
+  for (const entrada of modulos) {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'swl-w4-mutacion-baseline-'));
+    try {
+      copiarArboles(raizRepo, tmp, directoriosParaModulo(directoriosACopiar, entrada), plantillaGit);
+      const resultado = await spawnTestsAsync(tmp, entrada.testFiles, entrada.testSkipPattern, timeoutMs);
+      if (resultado.exitCode !== 0 || resultado.agotoTiempo) {
+        fallar(
+          'MUTATION_BASELINE_FAILED',
+          `línea base falló para ${entrada.modulo} (${entrada.testFiles.join(', ')}): `
+          + `exit=${resultado.exitCode} agotoTiempo=${resultado.agotoTiempo}\n${resultado.stdout}\n${resultado.stderr}`
+        );
+      }
+    } finally {
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  }
+}
+
+function generarTareas(modulos, pristinos, directoriosBase, timeoutMs, filtroClaves) {
+  const tareas = [];
+  for (const entrada of modulos) {
+    const codigoFuente = pristinos.get(entrada.modulo);
+    const enmascarado = enmascarar(codigoFuente);
+    const directoriosACopiar = directoriosParaModulo(directoriosBase, entrada);
+    for (const mutante of generarMutantes(codigoFuente, entrada.modulo)) {
+      // filtroClaves (opt-in, diagnóstico): cuando es un Set no vacío, sólo se
+      // ejecutan los mutantes cuya clave está en él. Por defecto (null) el
+      // comportamiento es idéntico — NO afecta el Gate. Ver probar-mutante (T-07).
+      if (filtroClaves && !filtroClaves.has(claveMutanteEquivalente({ modulo: entrada.modulo, ...mutante }))) continue;
+      tareas.push({
+        mutante, codigoFuente, testFiles: entrada.testFiles, directoriosACopiar, timeoutMs,
+        testSkipPattern: entrada.testSkipPattern,
+        critico: clasificarCritico(mutante, enmascarado),
+      });
+    }
+  }
+  return tareas;
+}
+
+/**
+ * Ejecuta mutation testing completo sobre `modulos` (por defecto,
+ * `MODULOS_CRITICOS`, los 20 módulos críticos de F29/F30/F31). Efectos:
+ * crea/borra directorios temporales, escribe archivos ahí, spawnea procesos
+ * `node --test` reales. NUNCA toca los módulos originales en disco — cada
+ * mutante vive sólo en una copia efímera de `os.tmpdir()`.
+ *
+ * Cada entrada de `modulos` puede declarar, además de `modulo`/`testFiles`:
+ * `directoriosExtra` (string[], directorios/archivos adicionales a copiar
+ * SÓLO para las tareas de ese módulo — ver DIRECTORIOS_EXTRA_PAQUETE_COMPLETO)
+ * y `testSkipPattern` (string, pasado como `--test-skip-pattern` al spawnear
+ * ese módulo — ver TEST_SKIP_PATTERN_GIT_STATCACHE). Ambos son excepciones
+ * puntuales descubiertas durante T-07, documentadas junto a su constante.
+ *
+ * @param {object} [opciones]
+ * @param {string} [opciones.raizRepo] - raíz del repo a copiar (default: raíz real de swl-ses).
+ * @param {Array<{modulo:string,testFiles:string[],directoriosExtra?:string[],testSkipPattern?:string}>} [opciones.modulos] - default: MODULOS_CRITICOS.
+ * @param {string[]} [opciones.directoriosACopiar] - default: DIRECTORIOS_POR_DEFECTO.
+ * @param {number} [opciones.concurrencia] - tareas (módulo,mutante) concurrentes (default: 1).
+ * @param {number} [opciones.timeoutMs] - límite por corrida de tests antes de matar el proceso
+ *   y clasificar el mutante como muerto por TIMEOUT (default: TIMEOUT_MS_POR_DEFECTO, 150s —
+ *   un mutante puede convertir una guarda de terminación en un colgado indefinido; ver hallazgo
+ *   junto a esa constante).
+ * @param {(progreso:{completadas:number,total:number}) => void} [opciones.onProgreso]
+ * @returns {Promise<object>} MutationReport (ver schemas/w4-mutation-report.schema.json).
+ */
+async function ejecutarMutationTesting(opciones = {}) {
+  const raizRepo = opciones.raizRepo || path.resolve(__dirname, '..', '..');
+  const modulos = opciones.modulos || MODULOS_CRITICOS;
+  const directoriosACopiar = opciones.directoriosACopiar || DIRECTORIOS_POR_DEFECTO;
+  const concurrencia = Number.isInteger(opciones.concurrencia) && opciones.concurrencia > 0 ? opciones.concurrencia : 1;
+  const timeoutMs = Number.isInteger(opciones.timeoutMs) && opciones.timeoutMs > 0 ? opciones.timeoutMs : TIMEOUT_MS_POR_DEFECTO;
+  const onProgreso = typeof opciones.onProgreso === 'function' ? opciones.onProgreso : null;
+  const filtroClaves = opciones.filtroClaves instanceof Set && opciones.filtroClaves.size > 0 ? opciones.filtroClaves : null;
+
+  const pristinos = leerPristinos(raizRepo, modulos);
+  // Calculado sobre `modulos` (no sobre `tareas`, que todavía no existe):
+  // misma condición — algún módulo, con su propio directoriosParaModulo,
+  // necesita '.git'. Se prepara ANTES de la línea base porque ésta ahora
+  // corre aislada por módulo (ver correrLineaBase) y también necesita la
+  // plantilla para los módulos que declaran '.git' en su directoriosExtra.
+  const necesitaGit = modulos.some((entrada) => directoriosParaModulo(directoriosACopiar, entrada).includes('.git'));
+  const plantillaGit = necesitaGit ? prepararPlantillaGit(raizRepo) : null;
+  try {
+    await correrLineaBase(raizRepo, modulos, directoriosACopiar, timeoutMs, plantillaGit);
+    const tareas = generarTareas(modulos, pristinos, directoriosACopiar, timeoutMs, filtroClaves);
+    const resultados = await ejecutarTareasConcurrentes(tareas, concurrencia, raizRepo, plantillaGit, onProgreso);
+
+    for (const entrada of modulos) {
+      verificarTasaSyntaxError(resultados.filter((r) => r.modulo === entrada.modulo), entrada.modulo);
+    }
+
+    return ensamblarReporte(modulos, resultados);
+  } finally {
+    if (plantillaGit) fs.rmSync(plantillaGit, { recursive: true, force: true });
+  }
+}
+
+// =============================================================================
+// validateMutationReport — validación sin efectos del MutationReport.
+// =============================================================================
+
+const REPORT_KEYS = ['kind', 'schemaVersion', 'generatedAt', 'global', 'porModulo', 'mutantes'];
+const GLOBAL_KEYS = ['totalMutantes', 'muertos', 'sobrevivientes', 'score', 'criticos'];
+const GLOBAL_CRITICOS_KEYS = ['total', 'muertos', 'score'];
+const MODULO_ENTRY_KEYS = ['modulo', 'testFiles', 'totalMutantes', 'muertos', 'sobrevivientes', 'score', 'criticos'];
+const MODULO_CRITICOS_KEYS = ['total', 'muertos'];
+const MUTANTE_KEYS = ['modulo', 'linea', 'operador', 'original', 'mutado', 'inicioAbs', 'critico', 'estado', 'testQueLoMato', 'detailCode'];
+const OPERADORES_VALIDOS = new Set(['M1', 'M2', 'M3', 'M4', 'M5']);
+const ESTADOS_VALIDOS = new Set(['muerto', 'sobrevivio']);
+const DETAIL_CODES_VALIDOS = new Set(['SYNTAX_ERROR', 'TIMEOUT']);
+
+function validarClaves(valor, esperadas, etiqueta) {
+  if (!esObjetoPlano(valor)) fallar('MUTATION_REPORT_INVALID', `${etiqueta} inválido`);
+  const actuales = Object.keys(valor).sort();
+  const objetivo = [...esperadas].sort();
+  if (JSON.stringify(actuales) !== JSON.stringify(objetivo)) {
+    fallar('MUTATION_REPORT_INVALID', `${etiqueta} inválido`);
+  }
+}
+
+function validarScore(valor, etiqueta) {
+  if (typeof valor !== 'number' || Number.isNaN(valor) || valor < 0 || valor > 100) {
+    fallar('MUTATION_REPORT_INVALID', `${etiqueta} inválido`);
+  }
+}
+
+function validarEnteroNoNegativo(valor, etiqueta) {
+  if (!Number.isInteger(valor) || valor < 0) fallar('MUTATION_REPORT_INVALID', `${etiqueta} inválido`);
+}
+
+function validarCriticosGlobal(criticos) {
+  validarClaves(criticos, GLOBAL_CRITICOS_KEYS, 'global.criticos');
+  validarEnteroNoNegativo(criticos.total, 'global.criticos.total');
+  validarEnteroNoNegativo(criticos.muertos, 'global.criticos.muertos');
+  if (criticos.muertos > criticos.total) fallar('MUTATION_REPORT_INVALID', 'global.criticos inconsistente');
+  validarScore(criticos.score, 'global.criticos.score');
+}
+
+function validarGlobal(global) {
+  validarClaves(global, GLOBAL_KEYS, 'global');
+  validarEnteroNoNegativo(global.totalMutantes, 'global.totalMutantes');
+  validarEnteroNoNegativo(global.muertos, 'global.muertos');
+  validarEnteroNoNegativo(global.sobrevivientes, 'global.sobrevivientes');
+  if (global.muertos + global.sobrevivientes !== global.totalMutantes) {
+    fallar('MUTATION_REPORT_INVALID', 'global inconsistente');
+  }
+  validarScore(global.score, 'global.score');
+  validarCriticosGlobal(global.criticos);
+}
+
+function validarModuloEntry(entrada) {
+  validarClaves(entrada, MODULO_ENTRY_KEYS, 'porModulo[]');
+  if (typeof entrada.modulo !== 'string' || entrada.modulo.length === 0) {
+    fallar('MUTATION_REPORT_INVALID', 'porModulo[].modulo inválido');
+  }
+  if (!Array.isArray(entrada.testFiles) || entrada.testFiles.length === 0
+    || !entrada.testFiles.every((f) => typeof f === 'string' && f.length > 0)) {
+    fallar('MUTATION_REPORT_INVALID', 'porModulo[].testFiles inválido');
+  }
+  validarEnteroNoNegativo(entrada.totalMutantes, 'porModulo[].totalMutantes');
+  validarEnteroNoNegativo(entrada.muertos, 'porModulo[].muertos');
+  validarEnteroNoNegativo(entrada.sobrevivientes, 'porModulo[].sobrevivientes');
+  if (entrada.muertos + entrada.sobrevivientes !== entrada.totalMutantes) {
+    fallar('MUTATION_REPORT_INVALID', 'porModulo[] inconsistente');
+  }
+  validarScore(entrada.score, 'porModulo[].score');
+  validarClaves(entrada.criticos, MODULO_CRITICOS_KEYS, 'porModulo[].criticos');
+  validarEnteroNoNegativo(entrada.criticos.total, 'porModulo[].criticos.total');
+  validarEnteroNoNegativo(entrada.criticos.muertos, 'porModulo[].criticos.muertos');
+  if (entrada.criticos.muertos > entrada.criticos.total) {
+    fallar('MUTATION_REPORT_INVALID', 'porModulo[].criticos inconsistente');
+  }
+}
+
+function validarMutanteEntry(entrada) {
+  validarClaves(entrada, MUTANTE_KEYS, 'mutantes[]');
+  if (typeof entrada.modulo !== 'string' || entrada.modulo.length === 0) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[].modulo inválido');
+  }
+  if (!Number.isInteger(entrada.linea) || entrada.linea < 1) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[].linea inválido');
+  }
+  if (!OPERADORES_VALIDOS.has(entrada.operador)) fallar('MUTATION_REPORT_INVALID', 'mutantes[].operador inválido');
+  if (typeof entrada.original !== 'string' || typeof entrada.mutado !== 'string') {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[].original/mutado inválido');
+  }
+  if (!Number.isInteger(entrada.inicioAbs) || entrada.inicioAbs < 0) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[].inicioAbs inválido');
+  }
+  if (typeof entrada.critico !== 'boolean') fallar('MUTATION_REPORT_INVALID', 'mutantes[].critico inválido');
+  if (!ESTADOS_VALIDOS.has(entrada.estado)) fallar('MUTATION_REPORT_INVALID', 'mutantes[].estado inválido');
+  if (entrada.operador === 'M5' && entrada.critico !== true) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[] todo M5 debe ser crítico');
+  }
+  if (entrada.testQueLoMato !== null && typeof entrada.testQueLoMato !== 'string') {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[].testQueLoMato inválido');
+  }
+  if (entrada.detailCode !== null && !DETAIL_CODES_VALIDOS.has(entrada.detailCode)) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[].detailCode inválido');
+  }
+  if (entrada.estado === 'sobrevivio' && (entrada.testQueLoMato !== null || entrada.detailCode !== null)) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[] sobreviviente inconsistente');
+  }
+  if (entrada.estado === 'muerto' && entrada.testQueLoMato === null && !DETAIL_CODES_VALIDOS.has(entrada.detailCode)) {
+    fallar('MUTATION_REPORT_INVALID', 'mutantes[] muerto sin evidencia de causa');
+  }
+}
+
+function verificarConsistenciaAgregados(value) {
+  const total = value.mutantes.length;
+  const muertos = value.mutantes.filter((m) => m.estado === 'muerto').length;
+  if (value.global.totalMutantes !== total || value.global.muertos !== muertos
+    || value.global.score !== calcularScore(muertos, total)) {
+    fallar('MUTATION_REPORT_INVALID', 'global no coincide con mutantes[]');
+  }
+  const criticos = value.mutantes.filter((m) => m.critico);
+  const criticosMuertos = criticos.filter((m) => m.estado === 'muerto').length;
+  if (value.global.criticos.total !== criticos.length || value.global.criticos.muertos !== criticosMuertos
+    || value.global.criticos.score !== calcularScore(criticosMuertos, criticos.length)) {
+    fallar('MUTATION_REPORT_INVALID', 'global.criticos no coincide con mutantes[]');
+  }
+  for (const entrada of value.porModulo) verificarConsistenciaModulo(entrada, value.mutantes);
+}
+
+function verificarConsistenciaModulo(entrada, mutantes) {
+  const delModulo = mutantes.filter((m) => m.modulo === entrada.modulo);
+  const muertosModulo = delModulo.filter((m) => m.estado === 'muerto').length;
+  if (entrada.totalMutantes !== delModulo.length || entrada.muertos !== muertosModulo
+    || entrada.score !== calcularScore(muertosModulo, delModulo.length)) {
+    fallar('MUTATION_REPORT_INVALID', `porModulo[${entrada.modulo}] no coincide con mutantes[]`);
+  }
+  const criticosModulo = delModulo.filter((m) => m.critico);
+  const criticosMuertosModulo = criticosModulo.filter((m) => m.estado === 'muerto').length;
+  if (entrada.criticos.total !== criticosModulo.length || entrada.criticos.muertos !== criticosMuertosModulo) {
+    fallar('MUTATION_REPORT_INVALID', `porModulo[${entrada.modulo}].criticos no coincide con mutantes[]`);
+  }
+}
+
+/** Valida un `MutationReport` sin efectos: no lee disco, no hace red, no
+ * consulta el reloj. Lanza MUTATION_REPORT_INVALID si el valor no cumple
+ * `schemas/w4-mutation-report.schema.json`; retorna un valor deeply frozen
+ * equivalente si es válido. */
+function validateMutationReport(value) {
+  validarClaves(value, REPORT_KEYS, 'mutationReport');
+  if (value.kind !== 'swl-mutation-report') fallar('MUTATION_REPORT_INVALID', 'kind inválido');
+  if (value.schemaVersion !== SCHEMA_VERSION) fallar('MUTATION_REPORT_INVALID', 'schemaVersion inválida');
+  if (typeof value.generatedAt !== 'string' || Number.isNaN(Date.parse(value.generatedAt))) {
+    fallar('MUTATION_REPORT_INVALID', 'generatedAt inválido');
+  }
+  validarGlobal(value.global);
+  if (!Array.isArray(value.porModulo) || value.porModulo.length === 0) {
+    fallar('MUTATION_REPORT_INVALID', 'porModulo inválido');
+  }
+  value.porModulo.forEach(validarModuloEntry);
+  if (!Array.isArray(value.mutantes)) fallar('MUTATION_REPORT_INVALID', 'mutantes inválido');
+  value.mutantes.forEach(validarMutanteEntry);
+
+  verificarConsistenciaAgregados(value);
+
+  return congelarProfundo(JSON.parse(JSON.stringify(value)));
+}
+
+module.exports = {
+  ejecutarMutationTesting,
+  generarMutantes,
+  clasificarCritico,
+  enmascarar,
+  validateMutationReport,
+  verificarTasaSyntaxError,
+  MODULOS_CRITICOS,
+  OPERADORES,
+  // Export interno sólo para tests (y diagnóstico manual) del fix
+  // cross-platform de matarArbolDeProceso, del fix de granularidad de
+  // correrLineaBase (verificación T-07) y del filtro opt-in filtroClaves
+  // (generarTareas + claveMutanteEquivalente). NO usar en código de
+  // producción — la API estable es la lista de arriba.
+  __internalParaTest: { decidirComandoMatarArbol, correrLineaBase, prepararPlantillaGit, generarTareas, claveMutanteEquivalente, verificarAnotacionEquivalentes, verificarCotaEquivalentes, esEquivalenteSobreviviente, MUTANTES_EQUIVALENTES_ESPERADOS },
+};