@ingeniomaps/cauce 0.91.0 → 0.93.0

package/CHANGELOG.md

@@ -14,6 +14,130 @@ 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.93.0] - 2026-09-16
+
+### Corregido
+
+- **Declarar un límite ahora lo saca del aviso, en vez de sumarlo.** Si escribiste tus límites como
+  viñetas bajo `### Límites` —el camino que 0.92.0 agregó—, `check` los contaba igual como párrafos que
+  no llegan a los agentes, y también contaba la frase con la que presentabas la lista. O sea que hacer
+  lo correcto **subía** el número: medido sobre un banco, de 4 párrafos avisados pasaba a 6.
+
+  Ahora una viñeta declarada y la prosa que la presenta no entran en el aviso. Lo que sigue entrando es
+  la prosa de afuera del bloque, que es lo único para lo que el aviso existe: descontar el bloque entero
+  la habría silenciado, porque a un bloque `### Límites` no lo cierra nada más que el próximo
+  encabezado y el del molde se extiende hasta donde escribas el tuyo.
+
+- **El aviso te manda al camino declarado y no a imitar una gramática.** Decía que tus párrafos no
+  llegan «porque no arrancan con «El runner», «Debe» o «Nunca»». Desde 0.92.0 hay una forma de
+  arreglarlo sin imitar nada, y es la que el aviso nombra ahora: sumar el límite como viñeta bajo
+  `### Límites`. Los dos caminos siguen valiendo; lo que cambia es cuál se recomienda.
+
+## [0.92.0] - 2026-09-15
+
+### Agregado
+
+- **El ciclo de aprendizaje ya no deja la propuesta mensual en «por definir».** Cada mes, el ciclo
+  consolida lo que recomendaron los informes semanales de un cargo y abre su propuesta. Hasta ahora la
+  dejaba con el molde intacto en «Cambio propuesto», y eso no es aprobable: nadie firma una intención.
+  Medido sobre `2026-09`: de **25** propuestas, **15** se archivaron con el molde y sólo 10 llegaron a
+  algo, las que alguien completó a mano.
+
+  El recorrido que escribe el cambio exacto —archivo por archivo, contrastado contra los casos
+  adversariales vigentes— ya existía; lo que faltaba era que el ciclo lo corriera. Ahora lo corre, y sólo
+  sobre las propuestas que quedaron sin decidir.
+
+  **Sin credencial no se rompe nada**: el paso avisa y el mes queda como quedaba antes, con la rama
+  empujada y sus sellos puestos. Lo mismo si la corrida falla. Lo que decide si se te pide una firma
+  sigue siendo el documento, no quién lo llenó.
+
+- **Tu proyecto puede declarar sus límites en una lista, y `check` avisa del que no llegue a los agentes.**
+  Los límites que tu proyecto amplía o restringe viven en `organization/workspace.md`, y de ahí viajan al
+  preámbulo de cada subagente. Hasta ahora se reconocían **por cómo arrancaba el párrafo** —«El runner»,
+  «Debe», «Nunca»—, que es la gramática del molde: un límite escrito de cualquier otra forma, que es como
+  lo escribiría cualquiera, no llegaba a ningún agente y nada lo decía. La lista salía más corta y se leía
+  igual de completa.
+
+  Ahora esa sección trae un `### Límites` con una viñeta por límite:
+
+  ```markdown
+  ### Límites
+
+  - En `api/` no se tocan migraciones sin aprobación de quien administra la base.
+  ```
+
+  **Lo que ya tenías escrito sigue contando**: la gramática vieja se lee igual, así que no hay nada que
+  migrar. Y lo que no entra por ninguno de los dos caminos ya no se pierde callado — `ops check` lo
+  reporta citando el párrafo, para que sepas cuál de tus límites se quedó afuera.
+
+  El ejemplo del molde viene comentado a propósito: un límite de ejemplo que se obedece es peor que
+  ninguno, porque nadie lo escribió y todos lo cumplirían.
+
+- **Reanudar una tarea dejó de pagar la fase que no tiene nada que hacer, y la corrida dice cuándo lo
+  hizo.** Una tarea que para antes de Commit —una revisión que pidió algo, un gate en rojo— deja su plan
+  en disco con los pasos tildados. Al relanzar, el recorrido entraba igual a Build: el agente releía el
+  WIP, comprobaba el disco y contestaba que no había nada pendiente. Hacía lo correcto; lo que costaba
+  era haberlo llamado — **893.000 tokens sobre tres corridas de una sola tarea**, medido.
+
+  Ahora, si el WIP no tiene pasos pendientes, esa llamada no se hace y la fase se anuncia como
+  `Build (reanudado)`, que viaja al resultado de la corrida y a la entrada de DONE. Antes una corrida
+  reanudada se veía idéntica a una que construyó salvo por el costo, así que comprobar qué se reutilizó
+  exigía abrir la salida cruda y sumar tokens a mano.
+
+  **Lo que no cambia es qué se revisa.** No se saltea la fase, se saltea la llamada: Review, Verify y QA
+  siguen mirando el diff real que quedó en disco, venga de la corrida que venga. Y si tu instancia no
+  emite ese dato, todo se comporta como antes.
+
+- **Una raíz puede declarar qué rutas lee su puerta, y un archivo sucio que el gate no va a abrir deja de
+  forzar la copia del índice.** Al commitear, `verify` corre sobre el árbol cuando árbol e índice
+  coinciden y materializa el índice en un temporal cuando difieren. Hasta ahora alcanzaba **cualquier**
+  archivo sin trackear para materializar: un README a medio escribir, un `tsconfig.json` que dejó otra
+  sesión, o el propio `planning/.ops-approval` que el bloqueo te manda crear para aprobar unas rutas.
+
+  Ahora, junto a `verify`, una raíz puede declarar `scope`:
+
+  ```json
+  "workspaceRoots": [
+    { "name": "web", "path": "apps/web", "verify": "pnpm build",
+      "scope": ["src/**", "package.json", "tsconfig.json"] }
+  ]
+  ```
+
+  Con eso, sólo materializa si alguna ruta que difiere cae dentro de ese alcance. Los patrones son
+  relativos a la raíz —el `scope` de `apps/web` habla de `src/**`, no de `apps/web/src/**`— y admiten
+  `*` dentro de un segmento, `**` cruzando segmentos y `?` por un carácter.
+
+  **Sin `scope` declarado no cambia nada**: cualquier delta sigue forzando la copia, que es el
+  comportamiento de siempre. El campo es opcional y no hay que adoptarlo.
+
+  Lo que se gana no es tiempo. Dentro de la copia `node_modules` viaja por **enlace**, y eso rompe
+  cualquier build de Turbopack sin salida del lado del proyecto: ahí un archivo ajeno al commit no cuesta
+  segundos, deja el gate sin poder pasar. Declarar el alcance es lo que lo destraba.
+
+  Dos bordes que valen la pena saber. Un directorio sin trackear llega colapsado —git reporta `extra/` y
+  no dice qué hay adentro—, así que se materializa igual si algún patrón apunta hacia adentro de él. Y
+  una ruta que no cuelga de **ninguna** raíz declarada también cuenta: puede ser de la instancia o de un
+  servicio que nadie declaró, y suponer que no importa es justo lo que este campo existe para evitar.
+
+### Corregido
+
+- **El motor se encuentra aunque lo hayas instalado un nivel arriba de tu instancia.** Si corrés
+  `npm install @ingeniomaps/cauce` en la carpeta de tu empresa y después `cauce init ops`, la instancia
+  queda adentro y el motor arriba. Ese es el árbol que el propio comando sugiere, y hasta ahora
+  `automation check` devolvía **nueve errores** sobre un motor que estaba instalado, cada uno mandándote a
+  correr `npm install` otra vez un nivel más abajo — o sea a bajar una segunda copia del paquete.
+
+  Ahora se busca también en la raíz que tu `ops.config.json` declara, que es la misma que el motor ya usa
+  para decidir dónde instalar el runner. Si tu `<empresa>-ops` tiene su propio `node_modules`, ése sigue
+  ganando y nada cambia.
+
+  **No se adivina el layout, se lee el declarado**: no se sube por el árbol como hace Node —en un monorepo
+  podría encontrar un motor de otra versión, en silencio— ni se mira si hay repositorio git, porque tener
+  la instancia sin versionar es un uso legítimo.
+
+  Vale para los tres caminos, no sólo para el CLI: el shim que lanza cada guard y el bridge de Antigravity
+  repiten esa búsqueda porque corren antes de poder cargar el motor, y los tres se actualizaron juntos.
+
 ## [0.91.0] - 2026-09-15
 
 ### Agregado

package/automatization/hooks/run-hook.sh

@@ -14,12 +14,12 @@ if [ -z "$hook_name" ]; then
   exit 2
 fi
 
-# La misma cascada que `packagePath` en engine/core/ownership.js, repetida acá porque el shim corre
-# antes de poder cargar el motor: si cambia allá, cambia acá.
+# Copia de `packagePath`; su porqué vive allá. Son tres los que la repiten y el motor los nombra.
 runner=""
 for candidate in \
   "$ops_root/node_modules/@ingeniomaps/cauce/engine/hooks/run.js" \
-  "$ops_root/engine/hooks/run.js"
+  "$ops_root/engine/hooks/run.js" \
+  "$ops_root/../node_modules/@ingeniomaps/cauce/engine/hooks/run.js"
 do
   if [ -f "$candidate" ]; then runner="$candidate"; break; fi
 done
@@ -27,7 +27,7 @@ done
 # Un guard que no encuentra su motor bloquea, nunca permite.
 if [ -z "$runner" ]; then
   echo "BLOQUEADO [$hook_name]: no se encontró el motor de hooks de Cauce." >&2
-  echo "  Buscado en node_modules/@ingeniomaps/cauce y engine/ bajo $ops_root" >&2
+  echo "  Buscado en node_modules/@ingeniomaps/cauce y engine/ bajo $ops_root y su carpeta padre" >&2
   exit 2
 fi
 

package/automatization/runners/antigravity/hook.js

@@ -82,9 +82,9 @@ function runtimeAt(root) {
   const candidates = [
     path.join(root, 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', 'run.js'),
     path.join(root, 'engine', 'hooks', 'run.js'),
+    path.join(root, '..', 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', 'run.js'),
   ]
-  // El bridge corre antes de poder cargar el motor, así que repite la cascada de
-  // engine/core/ownership.js en vez de requerirla. Si cambia una, cambian las dos.
+  // Copia de `packagePath`; su porqué vive allá. Son tres los que la repiten y el motor los nombra.
   const runtime = candidates.find(fs.existsSync)
   if (!runtime) throw new Error('No se encontró el runtime engine/hooks/run.js.')
   return require(runtime)

package/automatization/workflows/agent-eval.js

@@ -5,7 +5,7 @@
 // misma razón por la que nadie corrige su propio examen.
 //
 // Dónde trabaja el cargo lo decide el modo: en el toolkit, un banco desechable por caso; en una
-// empresa, su propia instancia. El porqué del banco está en `evaluationBench` (engine/cli/catalog.js).
+// empresa, su propia instancia. El porqué del banco está en `evaluationBench` (engine/cli/bench.js).
 // El veredicto, en cambio, se escribe siempre junto al cargo: el banco se borra, el contrato queda.
 export const meta = {
   name: 'agent-eval',

package/automatization/workflows/autobuild.js

@@ -36,7 +36,6 @@ const BACKLOG = `${P}/BACKLOG.md`
 const doneFile = (slug) => `${P}/done/${slug}.md`
 const HUMAN = `${P}/HUMAN_ACTIONS.md`
 const GATE = `${P}/AWAITING_REVIEW.md`
-const ROADMAP = `${P}/roadmap`
 
 // Estado de planning tal como lo emite `ops context --json`; ningún modelo parsea BACKLOG ni WIP.
 // De a pares, y sin regex: una comilla dentro de un literal de regex desincroniza a las dos puertas que
@@ -87,6 +86,21 @@ const CONTEXT = {
     inbox: { ...INBOX_HEADS },
     // Las reglas que rigen el proyecto, con los overrides ya resueltos por el motor (caso 105).
     rules: { type: 'array', items: { type: 'string' } },
+    // Cuántos pasos del plan están tildados y cuántos no. Es lo único que separa «esta tarea viene de una
+    // corrida que paró a mitad» de «esta tarea no empezó», y sin eso Build se lanzaba igual con los nueve
+    // pasos hechos: el agente releía el WIP, miraba el disco y contestaba que no había nada pendiente —
+    // medido en 893.000 tokens sobre tres corridas de una sola tarea (caso 154).
+    //
+    // Viene de `ops context --json`, que ya lo emite; acá sólo hacía falta declararlo, porque
+    // `additionalProperties: false` lo descartaba aunque llegara. Es opcional: una instancia sin WIP
+    // activo no lo trae, y pedirlo siempre obligaría a inventar ceros donde no hay plan.
+    wip: {
+      type: 'object', additionalProperties: false, required: ['complete', 'pending'],
+      properties: {
+        phase: { type: 'string' },
+        complete: { type: 'integer' }, pending: { type: 'integer' },
+      },
+    },
   },
 }
 const CLAIM = {
@@ -290,6 +304,22 @@ const VERDICT = ' Cerrá con verdict=aprobado si no queda nada por corregir ante
 const RULED = ' En rules nombrá, por su ruta, cada una de las reglas que rigen contra la que revisaste el diff.'
 // Lo que hay que corregir antes de entregar. El resto de los hallazgos no desaparece: se registra.
 const blockers = (verdict) => verdict.concerns.filter((one) => one.blocking).map((one) => one.detail)
+// El resultado de Build cuando no hubo nada que construir en esta corrida. Devuelve lo que de verdad
+// pasó y nada más: `redFirst` y `discovered` van **vacíos** porque acá no hubo ningún rojo nuevo que
+// mostrar ni ningún borde nuevo que fijar, y rellenarlos para que se parezca a una construcción sería
+// fabricar la evidencia que este recorrido exige justamente para no tener que creerle a nadie.
+//
+// `completed: true` afirma que el plan no tiene pasos pendientes, que es lo que el WIP dice y lo único
+// que se está usando. No afirma que lo construido esté bien: eso lo miran Review, Verify y QA sobre el
+// diff real, que existe en disco venga de la corrida que venga.
+const reusedBuild = (wip) => ({
+  completed: true,
+  closedTask: false,
+  redFirst: [],
+  discovered: [],
+  summary: `sin construir en esta corrida: el WIP traía ${wip.complete} paso(s) tildado(s) y ninguno `
+    + 'pendiente, así que lo que sigue revisa lo que ya estaba en disco',
+})
 // Atajo para reconocer un gate que corrió pruebas sin preguntarle a nadie. No alcanza solo y no
 // pretende hacerlo: `mvn verify`, `gradle build`, `tox`, `bin/rails t` y cualquier `make` con nombre
 // propio corren pruebas y no se parecen a esto, así que el que corrió el comando además lo declara en
@@ -389,7 +419,8 @@ const registerHuman = async (prompt, label) => (await write(prompt, { label })
 const readContext = () => read(
   `Corré "node tools/ops.js context ${P} --json" desde ${ROOT} y reportá sólo lo que imprimió. Derivá hasTask ` +
   `de si task es null, wipActive de si wip es null, claimed del campo claimed, today y wipFile de sus ` +
-  `campos, rules del campo rules tal cual, y lane ` +
+  `campos, rules del campo rules tal cual, wip con sus campos complete y pending tal cual si viene —y ` +
+  `omitilo entero si wip es null, sin inventar ceros—, y lane ` +
   `de task.tier; copiá slug, ` +
   `hito, service, acceptance, ` +
   `epic y cast de task, epicContext de epic.context —vacío si no hay épica— e inbox tal cual. El comando es ` +
@@ -710,8 +741,25 @@ while (rounds++ < MAX_TASKS) {
     }
   }
 
-  phase('Build')
-  const build = await run(
+  // Un WIP que viene de una corrida anterior con todos sus pasos tildados no tiene nada que construir, y
+  // lanzar el agente para que lo confirme cuesta lo mismo que construir. El recorrido delegaba la
+  // reanudación en el prompt —«retomá en el primer paso pendiente»—, así que el agente hacía lo correcto
+  // y lo caro era haberlo llamado (caso 154).
+  //
+  // **La fase no se saltea: se saltea la llamada.** Los cuatro contrastes de abajo —la tarea cerrada en
+  // Build, el rojo sin su fallo literal, el borde sin prueba, las decisiones abiertas— son lo único que
+  // vuelve a mirar el disco, y darlos por buenos porque el WIP dice que está todo hecho camina al modo de
+  // fallo que registra la fase WIP acá arriba: alguien construyó todo y Review, Verify y QA no lo vieron.
+  // Por eso lo que sigue no afirma que la construcción estuvo bien, sólo que en **esta** corrida no hubo
+  // ninguna: lo que ya estaba en disco lo revisan igual las fases siguientes, sobre el diff real.
+  // Y la fase se anuncia distinto, que es la otra mitad del caso: hoy «Build corrió y construyó» y «Build
+  // corrió, miró y no hizo nada» se ven idénticos salvo por el costo, así que R21 —que manda comprobar la
+  // reanudación en vez de suponerla— no se puede cumplir sobre este recorrido sin abrir el `.output` y
+  // sumar tokens a mano. El nombre viaja por el mismo canal que las otras quince fases: entra en `ran`,
+  // que va al resultado de la corrida y a la entrada de DONE.
+  const resumed = planning.wip && planning.wip.pending === 0 && planning.wip.complete > 0
+  phase(resumed ? 'Build (reanudado)' : 'Build')
+  const build = resumed ? reusedBuild(planning.wip) : await run(
     `${asRole(cast.build)}Implementá sólo ${task.id} dentro de ${task.service}. Retomá en el primer paso ` +
     `pendiente del WIP; comprobá en el disco los pasos ya hechos y tildá cada uno que salga bien. Para cada ` +
     `comportamiento escribí primero la prueba, corréla y anotá en redFirst el test y el fallo literal que ` +

package/engine/agents/learning.js

@@ -352,8 +352,6 @@ function prepareProposal(root, agent, now = new Date(), period = '', kind = 'age
   const reportDir = path.join(target, 'learning', 'reports')
   const reports = pendingReports(target, sealing)
   const red = verdictFindings(root, target)
-  if (!reports.length && !red.findings.length) return { file: '', created: false, reports: 0 }
-
   const reportPaths = reports.map((name) => path.join(reportDir, name))
   // La misma regla que la rama de recorridos, por el mismo motivo: un documento que no puede decir qué
   // corregir no cambia ningún contrato y cuesta igual la firma humana que uno que sí. Un informe puede

package/engine/automation/check.js

@@ -0,0 +1,95 @@
+'use strict'
+
+// Qué le falta a la superficie de automatización de una instancia, y nada más. Se mira sin tocar: `check`
+// enumera y devuelve; quien decide qué hacer con esa lista es el CLI.
+//
+// Vive aparte de `index.js` porque no comparte nada con los otros tres verbos. Medido antes de partir:
+// `doctor`, `install` y `uninstall` se apoyan en los mismos ayudantes —`deliveryKey`, `deliveryState`,
+// `removeFile`, `probeBridge`—, y este par no toca ninguno. Lo único que comparte son los imports, que es
+// lo que comparte cualquier archivo del directorio.
+//
+// La partición estaba anotada como deuda desde que el archivo cruzó las 500 líneas con el aviso de
+// sidecar del caso 138, estando en 499.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const O = require('../core/ownership')
+const {
+  RUNNER_NAMES, packagedAutomation, runnerManifest, runnerPaths, resolveItem, runnerConfig,
+} = require('./runners')
+const { expectedHooks, staleHooks } = require('./hooks')
+const { hasHooks } = require('./config')
+
+function check(root) {
+  const errors = []
+  const hookDir = path.join(root, 'automatization', 'hooks')
+  if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
+    errors.push('falta automatization/AGENTS.md')
+  }
+  for (const name of expectedHooks()) {
+    const file = path.join(hookDir, name)
+    if (!fs.existsSync(file)) errors.push(`falta automatization/hooks/${name}`)
+    else if (!(fs.statSync(file).mode & 0o111)) {
+      errors.push(`automatization/hooks/${name} no es ejecutable`)
+    }
+  }
+  // El motor puede venir de la dependencia npm o del propio repositorio, y la cascada la resuelve
+  // `packagePath`. Eran tres: la copia vendorizada se retiró en 0.10.0 y esta línea la sobrevivió.
+  if (!O.engineAt(root, path.join('hooks', 'run.js'))) {
+    errors.push('falta engine/hooks/run.js: corré "npm install" en la raíz del repo ops')
+  }
+  const workflows = [
+    'autobuild.js',
+    'flow.js',
+    path.join('integrations', 'sync.js'),
+    path.join('integrations', 'promote.js'),
+  ]
+  const packaged = packagedAutomation(root)
+  for (const name of workflows) {
+    if (!packaged || !fs.existsSync(path.join(packaged, 'workflows', name))) {
+      errors.push(`falta automatization/workflows/${name}: corré "npm install" en la raíz del repo ops`)
+    }
+  }
+  // Un choque que `upgrade` conservó (caso 110) también queda distinto del paquete, y mandarlo a correr
+  // `upgrade` era una vuelta sin salida: lo conservaría otra vez. Se dice qué es y qué hacer.
+  const choques = new Set(O.collisions(root))
+  for (const { file, edited } of staleHooks(root)) {
+    if (choques.has(`automatization/hooks/${file}`)) {
+      errors.push(`automatization/hooks/${file}: es tuyo y se llama como uno que trae el paquete, así que el `
+        + "del paquete no está instalado; renombrá el tuyo y corré `cauce upgrade`")
+      continue
+    }
+    errors.push(edited
+      ? `automatization/hooks/${file}: lo editaste y es del toolkit; agregá un guard propio al lado `
+        + 'o descartá tu cambio con `cauce upgrade --force`'
+      : `automatization/hooks/${file}: quedó atrás del paquete y ya no protege lo que dice; `
+        + 'corré `cauce upgrade` antes de instalar el runner')
+  }
+  for (const name of RUNNER_NAMES) validateRunnerManifest(root, name, errors)
+  return errors
+}
+
+function validateRunnerManifest(root, name, errors) {
+  try {
+    const runner = runnerManifest(root, name)
+    if (runner.name !== name || runner.schemaVersion !== 1
+      || !runner.config || !runner.capabilities) {
+      errors.push(`${name}: manifest incompleto`)
+      return
+    }
+    const paths = runnerPaths(root, name, runner)
+    const config = runnerConfig(paths, root)
+    if (runner.capabilities.nativeHooks && !hasHooks(config)) {
+      errors.push(`${name}: declara hooks nativos pero no los configura`)
+    }
+    for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
+      const resolved = resolveItem(paths, root, name, item)
+      if (!fs.existsSync(resolved.source)) errors.push(`${name}: falta ${item.source}`)
+    }
+  } catch (error) {
+    errors.push(`${name}: configuración inválida (${error.message})`)
+  }
+}
+
+
+module.exports = { check }

package/engine/automation/index.js

@@ -9,89 +9,22 @@ const O = require('../core/ownership')
 const M = require('../core/manifest')
 const RL = require('./rules')
 const {
-  RUNNER_NAMES, OPS_DIR, OPS_ROOT, packagedAutomation, runnerManifest, installRoot, opsPrefix,
+  RUNNER_NAMES, OPS_DIR, OPS_ROOT, runnerManifest, installRoot, opsPrefix,
   runnerPaths, resolveItem, inline, render, runnerConfig, activated,
 } = require('./runners')
 const { roleCatalog, roleSkill, installRoleSkills } = require('./roles')
 const {
-  GUARD_NAMES, groupWrappers, expectedHooks, supersededGuards,
-  legacyGuardWiring, staleHooks, listHooks,
+  GUARD_NAMES, groupWrappers, supersededGuards,
+  legacyGuardWiring, listHooks,
 } = require('./hooks')
 const {
-  blockStart, mergeConfig, withoutDeliveredHooks, deliveredHookCommands, reportRemoved, includesConfig, hasHooks,
+  blockStart, mergeConfig, withoutDeliveredHooks, deliveredHookCommands, reportRemoved, includesConfig,
   unmergeConfig, isSharedFile, withoutBlock, mergeInstruction, blockUpToDate,
 } = require('./config')
 
-function check(root) {
-  const errors = []
-  const hookDir = path.join(root, 'automatization', 'hooks')
-  if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
-    errors.push('falta automatization/AGENTS.md')
-  }
-  for (const name of expectedHooks()) {
-    const file = path.join(hookDir, name)
-    if (!fs.existsSync(file)) errors.push(`falta automatization/hooks/${name}`)
-    else if (!(fs.statSync(file).mode & 0o111)) {
-      errors.push(`automatization/hooks/${name} no es ejecutable`)
-    }
-  }
-  // El motor puede venir de la dependencia npm o del propio repositorio, y la cascada la resuelve
-  // `packagePath`. Eran tres: la copia vendorizada se retiró en 0.10.0 y esta línea la sobrevivió.
-  if (!O.engineAt(root, path.join('hooks', 'run.js'))) {
-    errors.push('falta engine/hooks/run.js: corré "npm install" en la raíz del repo ops')
-  }
-  const workflows = [
-    'autobuild.js',
-    'flow.js',
-    path.join('integrations', 'sync.js'),
-    path.join('integrations', 'promote.js'),
-  ]
-  const packaged = packagedAutomation(root)
-  for (const name of workflows) {
-    if (!packaged || !fs.existsSync(path.join(packaged, 'workflows', name))) {
-      errors.push(`falta automatization/workflows/${name}: corré "npm install" en la raíz del repo ops`)
-    }
-  }
-  // Un choque que `upgrade` conservó (caso 110) también queda distinto del paquete, y mandarlo a correr
-  // `upgrade` era una vuelta sin salida: lo conservaría otra vez. Se dice qué es y qué hacer.
-  const choques = new Set(O.collisions(root))
-  for (const { file, edited } of staleHooks(root)) {
-    if (choques.has(`automatization/hooks/${file}`)) {
-      errors.push(`automatization/hooks/${file}: es tuyo y se llama como uno que trae el paquete, así que el `
-        + "del paquete no está instalado; renombrá el tuyo y corré `cauce upgrade`")
-      continue
-    }
-    errors.push(edited
-      ? `automatization/hooks/${file}: lo editaste y es del toolkit; agregá un guard propio al lado `
-        + 'o descartá tu cambio con `cauce upgrade --force`'
-      : `automatization/hooks/${file}: quedó atrás del paquete y ya no protege lo que dice; `
-        + 'corré `cauce upgrade` antes de instalar el runner')
-  }
-  for (const name of RUNNER_NAMES) validateRunnerManifest(root, name, errors)
-  return errors
-}
-
-function validateRunnerManifest(root, name, errors) {
-  try {
-    const runner = runnerManifest(root, name)
-    if (runner.name !== name || runner.schemaVersion !== 1
-      || !runner.config || !runner.capabilities) {
-      errors.push(`${name}: manifest incompleto`)
-      return
-    }
-    const paths = runnerPaths(root, name, runner)
-    const config = runnerConfig(paths, root)
-    if (runner.capabilities.nativeHooks && !hasHooks(config)) {
-      errors.push(`${name}: declara hooks nativos pero no los configura`)
-    }
-    for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
-      const resolved = resolveItem(paths, root, name, item)
-      if (!fs.existsSync(resolved.source)) errors.push(`${name}: falta ${item.source}`)
-    }
-  } catch (error) {
-    errors.push(`${name}: configuración inválida (${error.message})`)
-  }
-}
+// Qué le falta a la superficie de automatización, que no comparte ayudantes con los tres verbos que
+// escriben. Se reexporta para que sus consumidores sigan pidiéndoselo a este módulo.
+const { check } = require('./check')
 
 // Ejecuta el puente del runner tal como él lo invoca, y desde otra carpeta. Instalado no es lo mismo que
 // operativo: un bridge que el runner no puede lanzar —porque su ruta es relativa y el cwd es otro, o

package/engine/cli/args.js

@@ -21,6 +21,7 @@ const FLAGS = {
   tree: ['--json', '--no-color'],
   context: ['--json', '--hito'],
   contract: ['--json'],
+  bench: ['--force'],
   recurring: ['--json', '--promote'],
   claim: ['--json'],
   runners: ['--json'],