@ingeniomaps/cauce 0.73.0 → 0.74.0

package/CHANGELOG.md

@@ -14,6 +14,42 @@ desde este repositorio no va, porque el que lee no puede actuar sobre eso. Cuand
 unas pocas líneas casi siempre es porque cuenta cómo se descubrió el problema o por qué se eligió el
 diseño — eso vive en el commit y en el código.
 
+## [0.74.0] - 2026-09-10
+
+### Corregido
+
+- **Un gate ya no pisa lo que vos construiste.** Al medir el índice, lo ignorado se enlazaba al árbol
+  real: el gate corría sobre lo staged y te dejaba la salida de build con **esa** versión, mientras tu
+  fuente en disco tenía otra y nada lo decía. Si corrías la app después de commitear, corrías algo que
+  no era lo que estabas mirando. Ahora lo que un gate puede fabricar —`dist`, `build`, `out`,
+  `coverage`, `.next`, `.nuxt`, `.svelte-kit`, `.turbo`, `.output`, `.parcel-cache`, `__pycache__`,
+  `.pytest_cache`— se construye adentro de la copia y se descarta con ella. Lo que no puede fabricar
+  —`node_modules`, un `.env`— se le sigue enlazando.
+
+  Arregla también algo del propio gate: construía sobre restos de tu corrida anterior, así que su
+  veredicto dependía de un estado que nadie declaró.
+
+  **Lo que te pide algo**: el build del gate deja de ser incremental, así que ese commit tarda más. Y si
+  tu proyecto genera en un directorio ignorado que no está en esa lista, seguí reportándolo: el nombre
+  se agrega.
+
+- **Los gates corren sobre una copia que se declara no interactiva, y un gate que falla dice qué dijo.**
+  `verify` mide el índice en un temporal y enlaza ahí lo ignorado, `node_modules` incluido, apuntando al
+  original. En un proyecto pnpm eso no corre: el gestor ve que el árbol enlazado no fue instalado ahí y
+  su reacción es reinstalar, que empieza borrando el `node_modules` **del proyecto**. Lo único que lo
+  detenía es que el hijo no ve una terminal. Ahora la copia lleva `CI=true`, que es la variable que el
+  propio pnpm nombra — y sólo la copia: si árbol e índice coinciden, los gates corren en tu directorio y
+  ahí no se te cambia nada.
+
+  Y el bloqueo dejaba de decir por qué: `test (exit 1)` era el mismo texto para una suite en rojo y para
+  un gestor que se negó a arrancar el script, así que empujaba a aprobar el commit como «rojo conocido»
+  sin que nada se hubiera medido. Ahora llega con la duración y con la primera línea de error de la
+  herramienta, y cuando todos los gates fallan por debajo de dos segundos lo dice — sin afirmar que no
+  corrieron, que es algo que no se puede saber desde acá.
+
+  **Lo que te pide algo**: si tenías un gate que se comportaba distinto bajo `CI`, ahora lo va a hacer
+  al commitear con algo sin stagear o sin trackear.
+
 ## [0.73.0] - 2026-09-09
 
 ### Corregido

package/engine/core/evidence.js

@@ -31,12 +31,16 @@ function logPath(root) {
 
 // Una línea por gate corrido. Nunca lanza: es un efecto de borde de un guard, y un registro que no se
 // puede escribir no puede impedir el commit que estaba juzgando.
-function record(root, gate, status) {
+// `ms` es cuánto tardó el gate, y se guarda porque es lo que separa una suite que falló de una que
+// nunca arrancó. Antes había que restar los `at` de dos líneas seguidas para estimarlo, y esa resta
+// incluye lo que pasó entre gate y gate; el número propio no. Fue lo que costó diagnosticar el caso 068:
+// tres gates «en rojo» a un segundo uno de otro, cuando la corrida real de ese proyecto tarda trece.
+function record(root, gate, status, ms) {
   if (!root) return
   try {
     const file = logPath(root)
     const previous = fs.existsSync(file) ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean) : []
-    const entry = JSON.stringify({ at: new Date().toISOString(), gate, status })
+    const entry = JSON.stringify({ at: new Date().toISOString(), gate, status, ...(ms >= 0 ? { ms } : {}) })
     fs.mkdirSync(path.dirname(file), { recursive: true })
     fs.writeFileSync(file, `${[...previous, entry].slice(-MAX_RUNS).join('\n')}\n`)
   } catch { /* el registro es evidencia, no una puerta */ }

package/engine/hooks/shell.js

@@ -355,14 +355,22 @@ function governance(input) {
 function run(program, args, cwd, extra = {}) {
   const env = { ...process.env, ...extra }
   delete env.NODE_TEST_CONTEXT
+  const started = Date.now()
   const result = spawnSync(program, args, { cwd, encoding: 'utf8', stdio: 'pipe', env })
   return {
     ok: result.status === 0,
     status: result.status,
+    ms: Date.now() - started,
     output: `${result.stdout || ''}${result.stderr || ''}`.trim(),
   }
 }
 
+// Salidas de build y cachés que cualquier gate rehace solo. Se comparan contra el nombre entero de la
+// entrada para que valga también anidado —`packages/app/dist`—, y con el separador de `git status`, que
+// siempre usa `/`.
+const RECREABLE = new RegExp('(^|/)(?:dist|build|out|coverage|__pycache__'
+  + '|\\.next|\\.nuxt|\\.svelte-kit|\\.turbo|\\.output|\\.parcel-cache|\\.pytest_cache)$')
+
 // Dónde tiene que correr un gate: sobre lo que el commit va a grabar, que es el índice y no el árbol.
 // El árbol se le parece casi siempre y por eso el error no se veía — puede tener encima otra versión de
 // un archivo staged, y puede tener uno sin trackear que el commit no lleva, que es el olvido de
@@ -399,6 +407,19 @@ function commitTree(dir) {
   for (const line of lines) {
     if (!line.startsWith('!! ')) continue
     const name = line.slice(3).trim().replace(/\/$/, '')
+    // Lo que el gate puede fabricar no se le enlaza: lo construye adentro de la copia y se descarta con
+    // ella. Enlazarlo hacía dos daños a la vez. Uno es del usuario: el gate corre sobre el índice, así
+    // que le dejaba la salida de build con la versión **staged** mientras su fuente en disco tenía otra,
+    // y nada lo decía —medido con un `dist/` que pasó de «lo-que-estoy-editando» a «staged» (caso 069)—.
+    // El otro es del propio gate: construía sobre restos de la corrida anterior del usuario, así que su
+    // veredicto dependía de un estado que nadie declaró.
+    //
+    // La lista envejece y eso pesa menos de lo que parece, porque sólo se aplica a rutas que git ya
+    // marcó como ignoradas: un `dist/` ignorado es generado por definición. Errarle por defecto —que
+    // falte un nombre— deja el comportamiento de antes; errarle por exceso hace que un gate reconstruya,
+    // que es más lento y no incorrecto. Lo que **sí** se enlaza es lo que un gate no puede fabricar:
+    // `node_modules`, un `.env`, las credenciales de una herramienta.
+    if (RECREABLE.test(name)) continue
     const link = path.join(temp, name)
     if (fs.existsSync(link)) continue
     fs.mkdirSync(path.dirname(link), { recursive: true })
@@ -421,7 +442,17 @@ function commitTree(dir) {
   // quien commitea; un proyecto con un gate así tiene que sacar esa escritura del gate.
   const started = run('git', ['init', '--quiet'], temp)
   if (started.ok) run('git', ['add', '--all'], temp)
-  return { root: temp, temp, env: {} }
+  // Un gate no sólo lee su entorno: escribe en él. Lo ignorado se enlaza al original —eso es a
+  // propósito y está arriba—, así que lo que el gate escriba cae en el árbol de quien commitea. Un
+  // gestor de paquetes que se sincroniza antes de correr un script lo lleva al extremo: pnpm 11 ve que
+  // el árbol enlazado no fue instalado acá y su reacción es reinstalar, que empieza borrando el
+  // `node_modules` **del proyecto**. Lo único que hoy lo detiene es que `run` lanza con `stdio: 'pipe'`
+  // y el hijo no ve una terminal (caso 068).
+  //
+  // `CI` es la variable que el propio pnpm nombra para no preguntar, y la que cualquier gate razonable
+  // ya espera. Va sólo acá: por el `return` de arriba los gates corren en el directorio del usuario, y
+  // ahí cambiarle el entorno no tiene ninguna razón.
+  return { root: temp, temp, env: { CI: 'true' } }
 }
 
 function verify(input) {
@@ -462,6 +493,41 @@ function verify(input) {
 // Cada gate deja su rastro en `ops`; para qué sirve ese registro lo dice `core/evidence.js`. Lo que se
 // decide acá es que el rojo se anota igual que el verde: un gate que falló y se commiteó con
 // aprobación es exactamente lo que alguien va a querer ver después.
+// Lo que se sabe de un gate que falló, en la forma en que se va a leer. El mensaje decía sólo
+// `test (exit 1)` y tiraba la salida de la herramienta: cualquier causa —una suite en rojo, un gestor
+// que se negó a arrancar el script, un binario que no está— llegaba con el mismo texto. Es la misma
+// forma de fallar que el caso 066 encontró en una prueba, acá en el mensaje que lee una persona.
+//
+// Se muestra **una** línea y acotada: la salida de un gate puede traer cualquier cosa del entorno, y lo
+// que hace falta para diagnosticar es la primera línea de error, no el volcado.
+const ERROR_LINE = /error|err[_!]|fail|abort|not found|cannot|no such/i
+const MAX_LINE = 160
+function fallo(gate, result) {
+  // La línea que empieza con `>` es el eco del script que npm y pnpm imprimen antes de correrlo, así
+  // que lleva el comando entero y no dice nada de qué falló. Descartarla es lo que hace que la primera
+  // coincidencia sea el error y no el comando — con el eco adentro, un script que **menciona** una
+  // palabra de error gana siempre.
+  const lines = (result.output || '').split('\n').map((one) => one.trim())
+    .filter((one) => one && !one.startsWith('>'))
+  const line = lines.find((one) => ERROR_LINE.test(one)) || lines[0] || ''
+  return { gate, status: result.status, ms: result.ms, line: line.slice(0, MAX_LINE) }
+}
+
+// Un gate que vuelve en menos de esto no corrió una suite. No se afirma que **no** haya corrido —un
+// lint puede fallar rápido y de verdad— y por eso lo que se agrega es el número, no un veredicto: los
+// tres gates del caso 068 volvieron a un segundo uno de otro contra los trece de la corrida real.
+const DEMASIADO_RAPIDO = 2000
+function comoSeLee(failures) {
+  const texto = failures
+    .map((one) => `${one.gate} (exit ${one.status}, ${(one.ms / 1000).toFixed(1)} s)`
+      + `${one.line ? `: ${one.line}` : ''}`)
+    .join('; ')
+  if (!failures.every((one) => one.ms < DEMASIADO_RAPIDO)) return texto
+  const cuantos = failures.length === 1 ? 'Volvió' : `Los ${failures.length} volvieron`
+  return `${texto}\n${cuantos} en menos de ${DEMASIADO_RAPIDO / 1000} s: eso no alcanza para correr `
+    + 'una suite, así que mirá si llegaron a ejecutarse antes de aprobar esto como un rojo conocido.'
+}
+
 function verifyGates(root, dir, aprobado, env, ops) {
   const failures = []
   if (fs.existsSync(path.join(root, 'package.json'))) {
@@ -472,28 +538,28 @@ function verifyGates(root, dir, aprobado, env, ops) {
     for (const script of ['test', 'lint', 'typecheck', 'build']) {
       if (!pkg.scripts || !pkg.scripts[script]) continue
       const result = run(pm, ['run', script], root, env)
-      EV.record(ops, script, result.status)
-      if (!result.ok) failures.push(`${script} (exit ${result.status})`)
+      EV.record(ops, script, result.status, result.ms)
+      if (!result.ok) failures.push(fallo(script, result))
     }
   } else if (fs.existsSync(path.join(root, 'go.mod'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^ci:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['ci'], root, env)
-      EV.record(ops, 'make ci', result.status)
-      if (!result.ok) failures.push(`make ci (exit ${result.status})`)
+      EV.record(ops, 'make ci', result.status, result.ms)
+      if (!result.ok) failures.push(fallo('make ci', result))
     } else {
       for (const args of [['test', './...'], ['build', './...']]) {
         const result = run('go', args, root, env)
-        EV.record(ops, `go ${args[0]}`, result.status)
-        if (!result.ok) failures.push(`go ${args[0]} (exit ${result.status})`)
+        EV.record(ops, `go ${args[0]}`, result.status, result.ms)
+        if (!result.ok) failures.push(fallo(`go ${args[0]}`, result))
       }
     }
   } else if (fs.existsSync(path.join(root, 'pyproject.toml')) || fs.existsSync(path.join(root, 'requirements.txt'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^test:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['test'], root, env)
-      EV.record(ops, 'make test', result.status)
-      if (!result.ok) failures.push(`make test (exit ${result.status})`)
+      EV.record(ops, 'make test', result.status, result.ms)
+      if (!result.ok) failures.push(fallo('make test', result))
     }
   }
   if (!failures.length || aprobado) return
@@ -501,7 +567,7 @@ function verifyGates(root, dir, aprobado, env, ops) {
   // comando a mano se lee como que el guard miente, y lo que pasó es que midió lo que se va a grabar.
   const donde = root === dir ? '' : '\nCorrió sobre el índice, que es lo que el commit graba: si en tu '
     + 'directorio pasa, es que en disco tenés algo que no está staged.'
-  block(`Verify falló en ${path.basename(dir)}: ${failures.join(', ')}. No se commitea en rojo.${donde}\n`
+  block(`Verify falló en ${path.basename(dir)}: ${comoSeLee(failures)}\nNo se commitea en rojo.${donde}\n`
     + AP.HOW('OPS_SKIP_VERIFY'))
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",