@ingeniomaps/cauce 0.91.0 → 0.93.0

package/engine/cli/ops.js

@@ -10,6 +10,7 @@ const { fail } = require('./io')
 const IN = require('./instance')
 const PL = require('./planning')
 const CT = require('./contract')
+const BN = require('./bench')
 const VA = require('./validate')
 const AR = require('./archive')
 const CLM = require('./claims')
@@ -151,6 +152,7 @@ function usage() {
   ops tree <planning-dir> [--no-color] [--json]
   ops context <planning-dir> [--hito <slug>] [--json]
   ops contract <ops-root> [--json]
+  ops bench <suelto|tarea|sidecar> [--force]
   ops recurring <planning-dir> [--promote <qué>] [--json]
   ops runners <planning-dir> [--json]
   ops claim <planning-dir> <tarea>
@@ -211,6 +213,7 @@ async function run(cli) {
   else if (command === 'tree') PL.tree(arg[1], cli)
   else if (command === 'context') PL.context(arg[1], cli)
   else if (command === 'contract') CT.contract(arg[1], cli)
+  else if (command === 'bench') BN.bench(arg[1], cli)
   else if (command === 'recurring') PL.recurring(arg[1], cli)
   else if (command === 'runners') CLM.runners(arg[1], cli)
   else if (command === 'claim') CLM.claim(arg[1], arg[2], cli)

package/engine/cli/validate.js

@@ -29,6 +29,7 @@ const C = require('../config/validate')
 const CP = require('../config/paths')
 const AG = require('../agents/catalog')
 const RL = require('../automation/rules')
+const CT = require('./contract')
 const { fail, planningRoot, TODAY } = require('./io')
 
 function check(dir, cli) {
@@ -131,6 +132,7 @@ function check(dir, cli) {
   warnings.push(...R.unrecordedHumanActions(path.resolve(root, '..'), P.readHumanActions(root)))
   warnings.push(...AP.warnings(path.resolve(root, '..')))
   warnings.push(...TR.warnings(path.resolve(root, '..')))
+  warnings.push(...CT.warnings(path.resolve(root, '..')))
 
   // Lo que `upgrade` conserva por estar editado deja de recibir mejoras, y eso es una deuda que no
   // avisa sola: la instancia queda con medio molde viejo y todo se ve normal. Sale acá para que se vea

package/engine/config/validate.js

@@ -121,7 +121,7 @@ function validateWorkspaces(workspaces, errors) {
       continue
     }
     for (const key of Object.keys(workspace)) {
-      if (!['name', 'path', 'verify'].includes(key)) {
+      if (!['name', 'path', 'verify', 'scope'].includes(key)) {
         errors.push(`ops.config.json: workspaceRoots[${index}].${key} no está permitido`)
       }
     }
@@ -130,6 +130,18 @@ function validateWorkspaces(workspaces, errors) {
     if ('verify' in workspace && (typeof workspace.verify !== 'string' || !workspace.verify.trim())) {
       errors.push(`ops.config.json: workspaceRoots[${index}].verify debe ser el comando, o no estar`)
     }
+    // Qué rutas lee esa puerta, y se rechaza vacío por lo que dice la línea de arriba. Lo propio de acá
+    // es que ausente **no** es lo mismo que vacío: sin el campo cuenta cualquier delta, que es lo que
+    // mantiene válida a toda instancia escrita antes de que existiera, mientras que una lista vacía diría
+    // que la puerta no lee nada y ningún delta la alcanzaría nunca.
+    if ('scope' in workspace) {
+      const scope = workspace.scope
+      if (!Array.isArray(scope) || !scope.length) {
+        errors.push(`ops.config.json: workspaceRoots[${index}].scope debe ser una lista de rutas, o no estar`)
+      } else if (scope.some((one) => typeof one !== 'string' || !one.trim())) {
+        errors.push(`ops.config.json: workspaceRoots[${index}].scope: cada entrada es un patrón de ruta`)
+      }
+    }
     if (typeof workspace.name !== 'string' || !workspace.name.trim()) {
       errors.push(`ops.config.json: workspaceRoots[${index}].name es obligatorio`)
     }

package/engine/core/ownership.js

@@ -107,10 +107,37 @@ function sourceOf(relative) {
 // Dos caminos, no tres. La copia vendorizada en `.ops/` se retiró en 0.10.0 — ahorraba un
 // `package.json` a cambio de 5 MB en la historia de la empresa y de no poder enterarse de una versión
 // nueva, y Node hace falta igual en los dos casos.
+//
+// Y un tercero, que es el layout que produce el flujo documentado: `npm install @ingeniomaps/cauce` se
+// corre en la carpeta de la empresa y `cauce init ops` deja la instancia adentro, así que el motor queda
+// **arriba** de ella. Sin este candidato, `automation check` daba nueve errores sobre un motor instalado y
+// el consejo mandaba a bajar una segunda copia un nivel más abajo (caso 158).
+//
+// Un nivel y no una búsqueda hacia arriba. Node sube hasta la raíz del disco y eso acá adivina: dentro de
+// un monorepo con varios paquetes encontraría un motor de otra versión, y ese fallo es silencioso. Lo que
+// se mira es la raíz que la instancia **declara** —la misma que `installRoot` usa para el runner—, así que
+// un `<empresa>-ops` con su propio `node_modules` gana en el primer candidato y no cambia nada.
+//
+// Se lee acá y no se importa de `automation/runners`: ese módulo ya importa éste, y al revés se muerden.
+//
+// **Y esta cascada la repiten otros dos**, porque corren antes de poder cargar este módulo: el shim
+// `automatization/hooks/run-hook.sh`, que lanza cada guard, y el bridge
+// `automatization/runners/antigravity/hook.js`. Los tres se cambian juntos o el motor se encuentra desde
+// el CLI y no desde los guards, que es medio arreglo y del lado que no se nota.
+function declaredRoot(root) {
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8'))
+    if (config.mode === 'sidecar') return path.resolve(root, '..')
+  } catch { /* sin configuración legible, sólo el propio */ }
+  return ''
+}
+
 function packagePath(root, relative) {
+  const above = declaredRoot(root)
   const candidates = [
     path.join(root, 'node_modules', '@ingeniomaps', 'cauce', relative),
     path.join(root, relative),
+    ...(above ? [path.join(above, 'node_modules', '@ingeniomaps', 'cauce', relative)] : []),
   ]
   return candidates.find((candidate) => fs.existsSync(candidate)) || ''
 }

package/engine/core/scope.js

@@ -0,0 +1,130 @@
+'use strict'
+
+// Qué rutas alcanza la puerta de una raíz, para poder decidir si un delta puede cambiar su veredicto.
+//
+// Existe porque `verify` declara **el comando** de la puerta y no lo que ese comando lee, así que
+// `commitTree` sólo podía preguntarse *si hay* delta y nunca *qué* delta: cualquier archivo sucio
+// —un README a medio escribir, la basura de una sonda— forzaba la copia del índice aunque el gate no
+// lo fuera a abrir nunca (caso 156). Lo caro no es la copia sino lo que arrastra: adentro
+// `node_modules` viaja por enlace y eso rompe cualquier build de Turbopack (caso 153).
+//
+// Vive en `core/` y recibe las raíces ya leídas: resolver la raíz ops es de `hooks/`, y hacerlo acá
+// invertiría la única dirección de dependencia que el repositorio sostiene entera.
+//
+// El matcher es propio y mínimo, y eso es una decisión: el motor no tiene ninguno reusable —las once
+// construcciones de `RegExp` que hay son para comandos de git, para el chat o para nombres de archivo
+// generado— y agregar una dependencia para esto contradiría la primera convención del repositorio.
+
+const path = require('node:path')
+
+// Lo que un patrón puede traer y hay que neutralizar para que no signifique otra cosa dentro de la
+// expresión regular. `*` y `?` se tratan aparte porque son justamente los que sí significan. Sin esto
+// `package.json` aceptaría `packageXjson`, y el alcance sería más ancho que el declarado.
+const ESCAPE = /[.+^${}()|[\]\\]/g
+
+// El vocabulario es el mínimo que alguien espera al escribir una ruta, y no el de una shell:
+//
+//   `**`  cualquier cantidad de segmentos, incluido ninguno
+//   `*`   cualquier cosa dentro de **un** segmento — no cruza `/`
+//   `?`   un carácter, tampoco `/`
+//
+// No hay llaves ni clases de caracteres, y eso es a propósito: cada forma que se agrega es una forma
+// más de escribir mal un alcance, y un alcance escrito de menos apaga el aislamiento sin que nada lo
+// diga. Se agregan cuando alguien las necesite de verdad.
+//
+// `**/` se consume junto con su barra para que `src/**/x.js` acepte también `src/x.js`: si no, el
+// patrón pediría un directorio intermedio obligatorio, que no es lo que nadie quiere decir.
+function toRegExp(pattern) {
+  let out = ''
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index]
+    if (char === '*' && pattern[index + 1] === '*') {
+      const slash = pattern[index + 2] === '/'
+      out += slash ? '(?:.*/)?' : '.*'
+      index += slash ? 2 : 1
+      continue
+    }
+    if (char === '*') { out += '[^/]*'; continue }
+    if (char === '?') { out += '[^/]'; continue }
+    out += char.replace(ESCAPE, '\\$&')
+  }
+  return new RegExp(`^${out}$`)
+}
+
+// La ruta relativa a la raíz declarada, que es donde vive quien escribió el patrón: en un monorepo el
+// `scope` de `apps/web` habla de `src/**`, no de `apps/web/src/**`. Devuelve `null` cuando cae fuera de
+// esa raíz, que no es lo mismo que no coincidir con ningún patrón — una es «no es tuya» y la otra «es
+// tuya y no la mirás».
+//
+// `path.relative` normaliza la barra final —`build/` vuelve como `build`—, así que si hace falta saber
+// que era un directorio hay que mirarlo antes, en la cadena cruda. Eso costó una prueba en rojo.
+function relativeTo(rootDir, repoDir, file) {
+  const absolute = path.resolve(repoDir, file)
+  const inside = path.relative(rootDir, absolute)
+  if (!inside || inside.startsWith('..') || path.isAbsolute(inside)) return null
+  return inside.split(path.sep).join('/')
+}
+
+// Un directorio sin trackear llega como `build/` y **git no dice qué hay adentro**. Si el alcance
+// declara `build/**/*.ts`, ninguna forma del directorio matchea, y quedarse con eso sería dejar de
+// materializar sin saber qué contiene. Por eso cuenta también cuando algún patrón **apunta hacia
+// adentro** de él: equivocarse hacia materializar de más devuelve el comportamiento de siempre;
+// hacia materializar de menos devuelve el defecto que `commitTree` fue a cerrar.
+function coversDirectory(relative, patterns, raw) {
+  const clean = relative.replace(/\/$/, '')
+  const forms = [clean, `${clean}/`]
+  if (forms.some((form) => patterns.some((one) => one.test(form)))) return true
+  return raw.some((pattern) => pattern.startsWith(`${clean}/`))
+}
+
+// La ruta de una línea de `git status --porcelain`: empieza en la columna 4 —`XY ` y después el
+// nombre— y un rename llega como `viejo -> nuevo`, del que importa el destino, que es lo que queda en
+// disco. Las comillas las pone git cuando el nombre trae caracteres raros.
+const fileOf = (line) => line.slice(3).trim().replace(/^.* -> /, '').replace(/^"|"$/g, '')
+
+// Si alguna de las rutas del delta cae dentro del alcance declarado de alguna raíz.
+//
+// **Sin ninguna raíz que declare `scope`, contesta siempre que sí**, y ahí está la compatibilidad: una
+// instancia que no adopta el campo se comporta exactamente como antes de que existiera. Es la única
+// respuesta segura, porque lo que se decide es si se puede confiar en el árbol, y el default tiene que
+// ser el que no confía.
+//
+// Una ruta que no cae bajo **ninguna** raíz declarada también cuenta como adentro: puede ser de la
+// instancia, de otro servicio sin declarar o de la raíz misma, y decidir que no cuenta sería la clase
+// de suposición que este campo existe para no tener que hacer.
+function reachesGate(roots, repoDir, files) {
+  const declared = roots.filter((one) => one && Array.isArray(one.scope) && one.scope.length)
+  if (!declared.length) return true
+  const compiled = declared.map((one) => ({
+    dir: path.resolve(repoDir, one.path),
+    raw: one.scope,
+    patterns: one.scope.map(toRegExp),
+  }))
+  return files.some((file) => {
+    const isDir = file.endsWith('/')
+    let owned = false
+    for (const root of compiled) {
+      const relative = relativeTo(root.dir, repoDir, file)
+      if (relative === null) continue
+      owned = true
+      const hit = isDir
+        ? coversDirectory(relative, root.patterns, root.raw)
+        : root.patterns.some((one) => one.test(relative))
+      if (hit) return true
+    }
+    return !owned
+  })
+}
+
+// La decisión completa, para que quien la consume sea una línea: ¿alcanza con correr sobre el árbol?
+// Recibe las líneas del delta tal como las devuelve `git status --porcelain`, ya sin lo ignorado.
+function staysInTree(roots, repoDir, deltaLines) {
+  const declared = Array.isArray(roots) ? roots : []
+  if (!declared.length) return false
+  return !reachesGate(declared, repoDir, deltaLines.map(fileOf))
+}
+
+// Sólo lo que otro módulo consume, por lo que dice el cierre de `cli/bench.js`. `toRegExp` se queda
+// adentro y no pierde nada: lo que hay que fijar de él son sus respuestas, y se ven igual preguntándole
+// a `reachesGate`.
+module.exports = { reachesGate, staysInTree }

package/engine/hooks/run.js

@@ -11,6 +11,7 @@ const os = require('node:os')
 const path = require('node:path')
 const { readInput, cwdOf, block, findOpsRoot } = require('./input')
 const shell = require('./shell')
+const { verify } = require('./verify')
 const files = require('./files')
 const chat = require('./chat')
 const { secretsShell } = require('./secrets-shell')
@@ -40,7 +41,7 @@ const guards = {
   'git-add': shell.gitAdd,
   dependencies: shell.dependencies,
   governance: shell.governance,
-  verify: shell.verify,
+  verify,
   'shell-boundary': shell.shellBoundary,
   'secrets-shell': secretsShell,
   'ops-config-shell': opsConfigShell,

package/engine/hooks/shell.js

@@ -1,8 +1,12 @@
 'use strict'
 
-// Los guards que juzgan un comando antes de que se ejecute: qué destruye, qué publica, qué toca una
-// dependencia y qué gate hay que haber corrido. Todos leen `commandOf` y miran el índice de git —de
-// ahí que vayan juntos—, y son el grupo `pre-shell` que el registro ya declaraba.
+// Los guards que juzgan el **texto** de un comando antes de que se ejecute: qué destruye, qué publica,
+// qué toca una dependencia y qué gobierna. Es el grupo `pre-shell` que el registro declara, y de lo que
+// parten los cinco es `commandOf`. Dos miran además el índice —`dependencies` y `governance`, los dos
+// acotados a un commit—; los otros tres deciden sólo con lo que el comando dice.
+//
+// Correr los gates de un commit era lo otro que hacía este archivo y hoy vive en `verify.js`, que de acá
+// no usa más que `run`. Cambia por otra causa: una herramienta nueva, no una evasión nueva.
 
 const fs = require('node:fs')
 const os = require('node:os')
@@ -16,7 +20,6 @@ const AP = require('./approval')
 const CHAT = require('./chat')
 const { publish } = require('./push')
 const { selfApprovalShell } = require('./self-approval')
-const EV = require('../core/evidence')
 
 // Dónde empieza y dónde termina una palabra dentro de un comando. Tres reglas de la tabla de abajo lo
 // decidían por su cuenta admitiendo sólo un espacio, el principio o el fin, y en un shell una palabra
@@ -395,248 +398,5 @@ function run(program, args, cwd, extra = {}) {
   }
 }
 
-// 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
-// `git add` de toda la vida. En los dos casos el verde se calcula sobre un código que nadie va a
-// commitear, y queda escrito como si fuera el del commit.
-//
-// Cuando árbol e índice coinciden, el árbol **es** el próximo commit y correr donde está no cuesta nada.
-// Sólo cuando difieren se materializa el índice: `checkout-index` sobre un temporal, medido en 157 ms
-// para las mil quinientas rutas de este repositorio, contra los segundos que tarda cualquier gate.
-//
-// Lo ignorado viaja por enlace y lo sin trackear no, y esa distinción es la mitad del arreglo:
-// `node_modules` o `.venv` son entorno que el commit no lleva y sin ellos no corre ningún gate, mientras
-// que un fuente sin agregar es justamente lo que hay que ver fallar. `git status --ignored` ya los
-// separa en `!!` y `??`, así que no hay que adivinar cuál es cuál.
-//
-// No se usa `git stash --keep-index`, que sería más corto: toca el árbol de quien está trabajando, y un
-// gate que muere a la mitad le deja el stash puesto.
-function commitTree(dir) {
-  const status = run('git', ['-C', dir, 'status', '--porcelain', '--ignored'], dir)
-  if (!status.ok) {
-    block(`no se pudo leer el estado de ${dir}, así que no hay cómo saber qué va a grabar el commit.`)
-  }
-  const lines = status.output.split('\n').filter(Boolean)
-  if (!lines.some((line) => !line.startsWith('!!') && line[1] !== ' ')) {
-    return { root: dir, temp: null, env: {} }
-  }
-
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'ops-verify-'))
-  const written = run('git', ['-C', dir, 'checkout-index', '-a', `--prefix=${temp}${path.sep}`], dir)
-  if (!written.ok) {
-    fs.rmSync(temp, { recursive: true, force: true })
-    block(`no se pudo materializar el índice de ${dir} para correr los gates: ${written.output}`)
-  }
-  const linked = []
-  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 })
-    fs.symlinkSync(path.join(dir, name), link, 'junction')
-    linked.push(name)
-  }
-  // Un índice materializado no trae `.git`, y un gate que llama a git —listar lo trackeado— falla ahí
-  // por no encontrarlo: el guard frenaría un commit correcto por su propia mecánica. La copia se vuelve
-  // un repositorio propio, con su índice cargado desde lo que se acaba de materializar, así que `git`
-  // contesta sobre lo que el commit va a grabar.
-  //
-  // Antes esto se resolvía exportando `GIT_DIR` del repositorio de verdad, y ahí el gate que **escribe**
-  // con git escribía en él: la suite de un proyecto levanta repositorios de prueba y les commitea, y
-  // esos commits caían en la rama del usuario junto con un `core.worktree` apuntando a un temporal ya
-  // borrado. Nada lo anunciaba (caso 045).
-  //
-  // Lo que se pierde a cambio, y son dos cosas. La copia no tiene historia, así que un gate que lea una
-  // etiqueta o un `git log` no la encuentra: falla y se ve. Y un gate cuyo efecto ES una escritura de
-  // git —taggear, commitear un lockfile regenerado— la hace sobre la copia, que se borra: ese efecto se
-  // pierde en silencio. Se elige el silencio de acá sobre el de antes, que era escribir en la rama de
-  // quien commitea; un proyecto con un gate así tiene que sacar esa escritura del gate.
-  const started = run('git', ['init', '--quiet'], temp)
-  // Lo enlazado es entorno y no entra al índice de la copia, y el `.gitignore` no alcanza para eso: un
-  // patrón con barra final sólo cubre directorios, y un enlace no lo es para git. `add --all` lo agregaba
-  // y un gate que recorre lo trackeado lo leía como archivo del commit (caso 095).
-  if (started.ok) {
-    fs.mkdirSync(path.join(temp, '.git', 'info'), { recursive: true })
-    fs.appendFileSync(path.join(temp, '.git', 'info', 'exclude'),
-      linked.map((name) => `/${name.replace(/[\\*?[\]]/g, '\\$&')}\n`).join(''))
-    run('git', ['add', '--all'], temp)
-  }
-  // 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 que se
-  // sincroniza antes de correr un script lo lleva al extremo: ve que el árbol enlazado no coincide con
-  // el lockfile de la copia y reinstala, lo que **empieza borrando** el `node_modules` del proyecto.
-  //
-  // Lo que se apaga es esa comprobación previa, que es el motivo por el que quiere tocar nada.
-  // `verify-deps-before-run` la gobierna y tiene cinco valores —`install`, `warn`, `prompt`, `error` y
-  // `false`—. El que hace el daño es `install`, que reinstala solo y es el default desde pnpm 11. `error`
-  // tampoco serviría: frena el gate cuando el lockfile de la copia difiere de lo instalado, que es justo
-  // lo que pasa al commitear un cambio de lockfile por partes. La copia no tiene que sincronizar nada:
-  // tiene que medir el código.
-  //
-  // El prefijo es `pnpm_config_` y no `npm_config_`, y esa sola palabra es la diferencia entre apagar la
-  // comprobación y no apagar nada: pnpm lee sus ajustes del entorno con su propio prefijo, así que con el
-  // de npm la variable llega igual y se ignora en silencio. Acá estuvo `npm_config_` desde el arreglo del
-  // 070 y no surtió efecto nunca (caso 151), con lo cual la protección que ese arreglo creyó poner no
-  // estuvo puesta. Medido sobre pnpm 10.30.2 y 11.20.0, iguales las dos.
-  //
-  // Acá estuvo `CI: 'true'` y fue una regresión (caso 070). Resolvía el síntoma del 068 —pnpm dejaba de
-  // preguntar antes de purgar— desarmando la confirmación en vez de quitarle el motivo, y esa
-  // confirmación era lo único que protegía al `node_modules` del proyecto: sin ella la reinstalación
-  // avanza y borra por el enlace. Además encendía `frozen-lockfile`, que el propio pnpm anuncia al
-  // fallar, así que la variable armaba y desarmaba guardas distintas a la vez.
-  //
-  // La regla que queda: no se desarma la confirmación de una herramienta, se le quita el motivo de
-  // preguntar. Una confirmación que estorba casi siempre está cuidando algo.
-  return { root: temp, temp, env: { pnpm_config_verify_deps_before_run: 'false' } }
-}
-
-function verify(input) {
-  if (process.env.OPS_SKIP_VERIFY === '1') return
-  const command = commandOf(input)
-  if (!isCommit(command)) return
-  const { dir, staged } = stagedForCommit(command, cwdOf(input))
-  const changedOpenApi = staged.some((file) => /^(?:openapi|api|spec)(?:\/.*)?\/[^/]+\.ya?ml$/i.test(file))
-    || staged.some((file) => /^(?:openapi|swagger)\.ya?ml$/i.test(file))
-  const changedSqlSource = staged.some((file) => /^(?:db\/queries|queries)\/.*\.sql$/i.test(file))
-  const hasApiGenerated = staged.some((file) => /(?:^|\/)[^/]*(?:generated|\.gen)\.(?:go|ts|js|py)$/i.test(file))
-  const hasSqlGenerated = staged.some((file) => /(?:^|\/)(?:sqlc|generated)(?:\/|.*\.(?:go|ts|js|py)$)/i.test(file))
-  // Acá lo aprobado es el conjunto staged entero: decir «autorizo commitear exactamente estas rutas»
-  // es lo que un gate en rojo necesita, y cambia en cuanto se stagea una más. La lista sale del índice
-  // y no de una regla, que es lo que la vuelve una operación y no un permiso.
-  const sinAprobar = AP.pendingNow(opsRoot(input), staged, input)
-  const aprobado = !sinAprobar.length
-  if (changedOpenApi && !hasApiGenerated && !aprobado) {
-    block('Cambió una fuente OpenAPI/Swagger sin incluir código regenerado. Ejecuta el generador y '
-      + `stagea su salida.\n${AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input)}`)
-  }
-  if (changedSqlSource && !hasSqlGenerated && !aprobado) {
-    block('Cambió una consulta SQL fuente sin artefactos regenerados. Ejecuta el generador.\n'
-      + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
-  }
-  if (!staged.some((file) => /\.(?:ts|tsx|js|jsx|mjs|cjs|go|py|html|css|scss|prisma)$/.test(file))) return
-  const { root, temp, env } = commitTree(dir)
-  try {
-    verifyGates(root, dir, sinAprobar, env, input)
-  } finally {
-    if (temp) fs.rmSync(temp, { recursive: true, force: true })
-  }
-}
-
-// Corre lo que el stack declare y bloquea si algo sale en rojo. `root` es dónde corre —el índice
-// materializado o el árbol, que ahí son lo mismo— y `dir` es el repositorio, que es el nombre que le
-// dice algo a quien lee el mensaje.
-//
-// 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
-// Cómo marca un reporte de pruebas cada resultado. Van sólo las comprobadas contra la herramienta (caso
-// 094): el nombre de una prueba verde puede decir «error», y sin mirar la marca la búsqueda por palabra se
-// quedaba con ella y el mensaje escondía la roja. Comprobadas con la salida entubada, como la ve un gate:
-// `node --test` en spec y en TAP (Node 24.18.0), `go test` (go 1.26.3), jest 30.5.1 (`● nombre`, y
-// `● Test suite failed to run`), vitest 5.0.0 (`× nombre`), mocha 12.0.1 (`1) nombre`; la verde es `✔`) y
-// pytest 9.1.1 (`FAILED archivo::prueba` en el resumen; `::prueba PASSED` la verde con `-v`). Jest y vitest
-// no imprimen las verdes sin `--verbose`, así que de ellos no hay marca de éxito.
-const FAILED_TEST = /^(?:✖|not ok\b|--- FAIL:|● |× |\d+\) |FAILED )/
-const PASSED_TEST = /^(?:✔|ok\b|--- PASS:)|::\S+ PASSED\b/
-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) => FAILED_TEST.test(one))
-    || lines.find((one) => !PASSED_TEST.test(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, sinAprobar, env, input) {
-  const ops = opsRoot(input)
-  const failures = []
-  if (fs.existsSync(path.join(root, 'package.json'))) {
-    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'))
-    const usesPnpm = fs.existsSync(path.join(root, 'pnpm-lock.yaml'))
-      && !fs.existsSync(path.join(root, 'package-lock.json'))
-    const pm = usesPnpm ? 'pnpm' : 'npm'
-    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, 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, 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, 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, result.ms)
-      if (!result.ok) failures.push(fallo('make test', result))
-    }
-  }
-  if (!failures.length || !sinAprobar.length) return
-  // Se dice sobre qué corrió cuando no fue el árbol: un fallo que no se reproduce escribiendo el mismo
-  // 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)}: ${comoSeLee(failures)}\nNo se commitea en rojo.${donde}\n`
-    + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
-}
 
-module.exports = { destructive, gitAdd, dependencies, governance, verify, shellBoundary, run, writesWithBase }
+module.exports = { destructive, gitAdd, dependencies, governance, shellBoundary, run, writesWithBase }