@ingeniomaps/cauce 0.72.0 → 0.73.0

package/CHANGELOG.md

@@ -14,6 +14,32 @@ 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.73.0] - 2026-09-09
+
+### Corregido
+
+- **Los guards dejan de frenar trabajo legítimo escrito en varias líneas.** Siete reglas acotaban
+  «dentro de este comando» con `[^;&|]`, y el salto de línea —que también separa comandos— no estaba en
+  esa lista: cualquier bandera de una línea posterior se leía como parte del comando de arriba. `git
+  commit -m "x"` seguido de `ls -a` se bloqueaba como si stageara al commitear, y `git push origin main`
+  seguido de `rm -f /tmp/x` como un force push, que además nombraba una violación que no estaba.
+
+  Lo que frena sigue frenando: `commit -am`, `add -A`, `push --force`, `--amend` e `install -g` en una
+  línea siguen bloqueados, y un `git push` seguido de otra cosa sigue pidiendo la acción humana que R10
+  exige — sólo que ya no lo llama reescritura de historia.
+
+- **Un banco de evaluación que no se puede rehacer lo dice, en vez de seguir sobre uno que no es nuevo.**
+  El borrado ahora se comprueba, y si algo sobrevive la corrida corta nombrando qué. Hasta acá el mismo
+  hecho se venía rodeando por síntoma —reintentos en el borrado, `force` en el andamiaje, un `rm` antes
+  del enlace—, y cada rodeo dejaba la medición siguiente corriendo sobre restos de la anterior.
+
+  La prueba que lo destapaba, además, **descartaba el resultado de la corrida que fallaba**: cualquier
+  causa terminaba en el mismo `true !== false` con el `stderr` tirado, y por eso tres investigaciones
+  dejaron escrito «no está establecido por qué». Ahora la falla llega con su código y su ruta.
+
+  **Lo que te pide algo**: si rehacer un banco te corta con «no se pudo borrar entero», borralo a mano y
+  volvé a correr. Antes eso seguía en silencio y fallaba más adelante, en otro lado.
+
 ## [0.72.0] - 2026-09-09
 
 ### Corregido

package/engine/cli/catalog.js

@@ -102,6 +102,29 @@ function evaluationBench(root, agent, caso, force, kind) {
   // reintentos, rehacer un banco es una operación que falla de vez en cuando y deja la corrida sin
   // empezar.
   fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })
+  // Y se comprueba que haya borrado. `rmSync` puede volver sin lanzar y dejar cosas —pasó en CI y no
+  // está establecido por qué—, y hasta acá cada síntoma se rodeaba por separado: `force` en el
+  // andamiaje, un `rm` antes del enlace. Rodearlo deja la corrida siguiendo sobre un banco que no es
+  // nuevo, y lo que falla después no dice nada del borrado: el test que lo destapó reportaba
+  // `true !== false` sobre un archivo de la corrida anterior, sin nombrar de dónde salía.
+  //
+  // Falla en vez de seguir, porque un banco a medio borrar contamina la medición que viene, que es lo
+  // que la recreación existe para evitar. Y nombra lo que sobrevivió: es lo único que va a permitir
+  // establecer la causa la próxima vez que ocurra.
+  if (fs.existsSync(dir)) {
+    const sobreviven = []
+    const recorrer = (base, relative = '') => {
+      for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+        if (sobreviven.length >= 5) return
+        const next = relative ? `${relative}/${entry.name}` : entry.name
+        if (entry.isDirectory()) recorrer(path.join(base, entry.name), next)
+        else sobreviven.push(next)
+      }
+    }
+    try { recorrer(dir) } catch { /* el listado es la explicación, no la comprobación */ }
+    fail(`${dir} no se pudo borrar entero y el banco tiene que ser nuevo. Sobrevivieron al borrado: `
+      + `${sobreviven.join(', ') || '(sólo directorios)'}. Borralo a mano y volvé a correr.`, 2)
+  }
   // Con `force`: el banco es desechable y se acaba de borrar, así que lo que sobreviva al `rmSync` se
   // pisa en vez de cortar la corrida. Sin esto, `copyTemplate` se niega ante cualquier archivo que
   // quede —«El destino contiene …/AGENTS.md»— y el mismo test falló así tres veces en un día, en las

package/engine/hooks/shell.js

@@ -31,6 +31,13 @@ const EV = require('../core/evidence')
 const ANTES = String.raw`(?:^|[\s;&|('"\`])`
 const PALABRA = String.raw`$|[\s;&|)'"\`]`
 const COMANDO = String.raw`$|[;&|)'"\`]`
+// Lo que puede haber **entre** un comando y su bandera sin salir de ese comando. El salto de línea va
+// adentro de lo excluido porque también separa comandos, exactamente igual que `;`, `&` y `|`: sin él,
+// una bandera escrita en una línea posterior se leía como parte del primer comando. Es la causa de los
+// falsos positivos del caso 067, en siete reglas a la vez — `git push origin main` seguido de
+// `rm -f /tmp/x` se bloqueaba anunciando «`git push --force` reescribe historia publicada», que además
+// de frenar trabajo legítimo nombraba una violación que no estaba.
+const MISMO = String.raw`[^;&|\n]`
 
 // Un mensaje de commit es dato, no código. `git commit -m "fix: bloquear git push --force"` disparaba
 // el guard de publicación, y lo mismo `rm -rf /` nombrado en una explicación; con el heredoc que se usa
@@ -62,7 +69,8 @@ function destructive(input) {
   // matchea igual las dos formas, así que `allowPush` habilitaba el force-push sin que nadie lo decidiera
   // y el párrafo de autonomía de `AGENTS.md` tenía que confesarlo. R8 prohíbe `force` sin excepción
   // configurable, así que esta rama va antes del permiso y no lo consulta.
-  if (/\bgit\s+push\b[^;&|]*\s(?:-f|--force(?:-with-lease|-if-includes)?)\b/.test(command)) {
+  if (new RegExp(String.raw`\bgit\s+push\b${MISMO}*\s(?:-f|--force(?:-with-lease|-if-includes)?)\b`)
+    .test(command)) {
     block("'git push --force' reescribe historia ya publicada. R8 lo prohíbe y runner.allowPush no lo "
       + 'habilita: publicá con un push normal, o registrá una acción humana.')
   }
@@ -75,7 +83,7 @@ function destructive(input) {
     // no devolvía una línea. Se bloquea por política y no por daño —un `--amend` sobre algo que nadie vio
     // no rompe nada—, así que el mensaje manda a lo que sí corresponde: otro commit.
     [
-      /\bgit\s+commit\b[^;&|]*\s--amend\b/,
+      new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s--amend\b`),
       "'git commit --amend' reescribe un commit ya creado. R8 pide uno nuevo en su lugar.",
     ],
     [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento."],
@@ -89,7 +97,7 @@ function destructive(input) {
     [
       // `git restore .` no lleva `--` y destruye igual: comprobado en `git restore --help` (git 2.43.0),
       // que restaura el working tree por defecto y toma el pathspec sin separador.
-      new RegExp(String.raw`\bgit\s+(?:checkout|restore)\s+(?:[^;&|]*?\s)?`
+      new RegExp(String.raw`\bgit\s+(?:checkout|restore)\s+(?:${MISMO}*?\s)?`
         + String.raw`(?:--(?=\s*(?:${COMANDO}))|(?:--\s+)?(?:\.|\*|:\/)(?=\s*(?:${COMANDO})))`),
       "'git checkout -- .' revierte todo lo no commiteado del directorio, no sólo lo que estás mirando. "
       + 'Nombrá el archivo, o commiteá lo que quieras conservar antes.',
@@ -104,7 +112,7 @@ function destructive(input) {
     ],
     [
       new RegExp(ANTES + String.raw`(?:mkfs\S*|shred)\s`
-        + String.raw`|\bdd\s+[^;&|]*\bof=\/dev\/|>\s*\/dev\/(?:sd|nvme|disk)`),
+        + String.raw`|\bdd\s+${MISMO}*\bof=\/dev\/|>\s*\/dev\/(?:sd|nvme|disk)`),
       'Operación destructiva sobre disco o dispositivo.',
     ],
     [
@@ -124,14 +132,14 @@ function gitAdd(input) {
   // Dónde termina la palabra lo decide PALABRA y no un espacio: `bash -c "git add -A"` y
   // `eval 'git add -A'` pasaban porque después de la bandera venía una comilla. Es el hueco que 028
   // cerró en las reglas de `destructive`, y esta regla se quedó afuera de aquel arreglo.
-  if (new RegExp(String.raw`\bgit\s+add\s+(?:[^;&|]*\s)?(?:-A|--all|\.)(?=${PALABRA})`)
+  if (new RegExp(String.raw`\bgit\s+add\s+(?:${MISMO}*\s)?(?:-A|--all|\.)(?=${PALABRA})`)
     .test(command)) {
     block("'git add -A/--all/.' está prohibido. Stagea rutas explícitas.")
   }
   // La misma regla con otra ortografía: `-a` stagea todo lo seguido sin nombrar una ruta, y encima lo
   // hace al commitear —después de este hook—, así que los guards que leen el índice tampoco lo ven.
   // `--amend` queda afuera: empieza con dos guiones y lo frena `destructive`, por otra razón.
-  if (/\bgit\s+commit\b[^;&|]*\s(?:-[a-z]*a[a-z]*|--all)\b/.test(command)) {
+  if (new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s(?:-[a-z]*a[a-z]*|--all)\b`).test(command)) {
     block("'git commit -a' stagea al commitear, después de este guard: nadie llega a revisar el diff "
       + 'staged, ni vos ni los guards que lo miran. Stageá las rutas por nombre y commiteá aparte.')
   }
@@ -141,7 +149,8 @@ function dependencies(input) {
   if (process.env.OPS_DEPENDENCIES_OVERRIDE === '1') return
   const command = commandOf(input)
   const unsafePackageCommand = /\b(?:npm|pnpm|yarn|bun)\s+publish\b/.test(command)
-    || /\b(?:npm|pnpm|yarn)\s+(?:install|add)\b[^;&|]*(?:\s-g\b|\s--global\b)/.test(command)
+    || new RegExp(String.raw`\b(?:npm|pnpm|yarn)\s+(?:install|add)\b${MISMO}*(?:\s-g\b|\s--global\b)`)
+      .test(command)
   if (unsafePackageCommand) {
     block('Publicar paquetes o instalar dependencias globales requiere una acción humana explícita.')
   }

package/package.json

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