@ingeniomaps/cauce 0.53.0 → 0.53.2

package/CHANGELOG.md

@@ -14,6 +14,41 @@ 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.53.2] - 2026-08-29
+
+### Cambiado
+
+- **`tools/ops.js` se reemplaza y no cambia lo que hace.** Su comentario prohibía `import` y dos líneas
+  después nombraba el `import()` dinámico que el propio shim usa; ahora dice que lo prohibido es el
+  estático. Y citaba `team list`, un comando que dejó de existir. Se lo nombra porque vive en tu
+  instancia: `upgrade` lo va a reemplazar y, hasta que lo corras, aparece como desactualizado.
+
+## [0.53.1] - 2026-08-29
+
+### Corregido
+
+- **`init` no instalaba el motor en Windows.** Lanzaba `npm.cmd` directo, y la documentación de Node
+  dice que un `.cmd` no es ejecutable por sí solo: ahora va por `cmd.exe` con el comando de argumento.
+  Fallaba en silencio útil —imprimía el error de npm y dejaba `npm install` entre los pasos
+  pendientes—, así que si venías corriéndolo a mano en Windows, ya no hace falta. Sin comprobar en un
+  Windows real: acá no hay uno, y el comentario del código lo dice.
+
+### Cambiado
+
+- **Los trece shims de guards se reemplazan y ninguno cambia lo que bloquea.** Su comentario prometía
+  «qué bloquea y cómo lo hace» en `engine/hooks/run.js`, que es un registro de una línea por guard: lo
+  que bloquea vive en otro módulo, y el puntero mandaba al lugar equivocado. Los trece cambian sólo en
+  comentarios, sin una línea ejecutable distinta. Se los nombra porque viven en tu instancia: `upgrade`
+  los va a reemplazar y, hasta que lo corras, `automation check` los reporta desactualizados.
+- **El motor se repartió en más archivos de los que tenía**, sin cambiar una sola conducta:
+  `engine/automation/index.js` en cinco, `engine/agents/learning.js` en tres y `engine/hooks/run.js` en
+  cuatro, cada uno cortado por lo que lo hace cambiar. Llega con `npm install` y no pide nada de tu
+  parte; se menciona porque un `require` a una ruta interna del motor —que nunca fue superficie
+  pública— puede haber dejado de resolver.
+- Los recorridos que instala tu runner cambiaron de texto —comentarios y nombres internos, ahora en
+  inglés como pide la convención—. Para recibirlos hay que reinstalar el wiring; si no lo hacés, los
+  que ya tenés siguen funcionando igual.
+
 ## [0.53.0] - 2026-08-27
 
 ### Corregido

package/automatization/hooks/guard-dependencies.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → dependencies().
+# Shim: delega `dependencies` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" dependencies

package/automatization/hooks/guard-destructive.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → destructive().
+# Shim: delega `destructive` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" destructive

package/automatization/hooks/guard-engine.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → engine().
+# Shim: delega `engine` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" engine

package/automatization/hooks/guard-generated.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → generated().
+# Shim: delega `generated` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" generated

package/automatization/hooks/guard-git-add.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → gitAdd().
+# Shim: delega `git-add` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" git-add

package/automatization/hooks/guard-governance.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → governance().
+# Shim: delega `governance` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" governance

package/automatization/hooks/guard-integration-snapshot.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → integrationSnapshot().
+# Shim: delega `integration-snapshot` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" integration-snapshot

package/automatization/hooks/guard-migrations.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → migrations().
+# Shim: delega `migrations` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" migrations

package/automatization/hooks/guard-planning-drift.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → planningDrift().
+# Shim: delega `planning-drift` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" planning-drift

package/automatization/hooks/guard-secrets.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → secrets().
+# Shim: delega `secrets` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" secrets

package/automatization/hooks/guard-test-evidence.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → testEvidence().
+# Shim: delega `test-evidence` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" test-evidence

package/automatization/hooks/guard-verify.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → verify().
+# Shim: delega `verify` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" verify

package/automatization/hooks/guard-workspace-boundary.sh

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
-# Shim: qué bloquea y cómo lo hace están en engine/hooks/run.js → workspaceBoundary().
+# Shim: delega `workspace-boundary` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
 exec "$(dirname "$0")/run-hook.sh" workspace-boundary

package/automatization/hooks/run-hook.sh

@@ -8,14 +8,14 @@ ops_root=$(CDPATH= cd -- "$hook_dir/../.." && pwd)
 # abre en la carpeta de la compañía y la raíz ops es un hermano, que ninguna búsqueda hacia arriba
 # encuentra: sin esto el guard no halla `ops.config.json` y deja pasar todo en silencio.
 export OPS_ROOT="$ops_root"
-# Mismo orden que tools/ops.js: la dependencia npm y, por último, el propio repositorio del toolkit.
-# Un guard que no encuentra su motor bloquea, nunca permite.
 # Primero el argumento, que además es lo que nombra el error de abajo.
 if [ -z "$hook_name" ]; then
   echo "BLOQUEADO: run-hook.sh requiere el nombre del guard o grupo que debe ejecutar." >&2
   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á.
 runner=""
 for candidate in \
   "$ops_root/node_modules/@ingeniomaps/cauce/engine/hooks/run.js" \
@@ -24,6 +24,7 @@ do
   if [ -f "$candidate" ]; then runner="$candidate"; break; fi
 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

package/automatization/runners/antigravity/hook.js

@@ -28,7 +28,7 @@ const OPS_ROOT = '{{OPS_ROOT}}'
 // desde el repositorio lo que sólo existe instalado. Sin eso, la resolución de la raíz —donde ya se
 // escondieron dos fallas que negaban cada llamada a herramienta— sólo se puede probar sobre una copia,
 // y una copia no la mide ninguna cobertura.
-const MARCAS = { dir: OPS_DIR, root: OPS_ROOT, plugin: __dirname }
+const MARKERS = { dir: OPS_DIR, root: OPS_ROOT, plugin: __dirname }
 
 function isRoot(dir) {
   const instance = fs.existsSync(path.join(dir, 'planning'))
@@ -36,11 +36,11 @@ function isRoot(dir) {
   return fs.existsSync(path.join(dir, 'ops.config.json')) && (instance || toolkit)
 }
 
-function declaredRoot(marcas) {
-  if (!marcas.root.startsWith('{{') && isRoot(marcas.root)) return marcas.root
+function declaredRoot(markers) {
+  if (!markers.root.startsWith('{{') && isRoot(markers.root)) return markers.root
   // El plugin corriendo desde donde `automation install` lo dejó, que es el caso sin registrar.
-  const installed = path.resolve(marcas.plugin, '..', '..', '..')
-  const root = marcas.dir.startsWith('{{') ? installed : path.join(installed, marcas.dir)
+  const installed = path.resolve(markers.plugin, '..', '..', '..')
+  const root = markers.dir.startsWith('{{') ? installed : path.join(installed, markers.dir)
   return fs.existsSync(path.join(root, 'ops.config.json')) ? root : ''
 }
 
@@ -58,8 +58,8 @@ function childRoot(dir) {
   return roots.length === 1 ? roots[0] : ''
 }
 
-function findRoot(input, marcas = MARCAS) {
-  const declared = declaredRoot(marcas)
+function findRoot(input, markers = MARKERS) {
+  const declared = declaredRoot(markers)
   if (declared) return declared
   const args = input.toolCall && input.toolCall.args || {}
   const starts = [args.Cwd, process.cwd(), ...(input.workspacePaths || [])].filter(Boolean)
@@ -79,7 +79,6 @@ function findRoot(input, marcas = MARCAS) {
 }
 
 function runtimeAt(root) {
-  // Mismo orden que tools/ops.js: dependencia npm y, por último, el repositorio del toolkit.
   const candidates = [
     path.join(root, 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', 'run.js'),
     path.join(root, 'engine', 'hooks', 'run.js'),
@@ -93,8 +92,8 @@ function runtimeAt(root) {
 
 // La carpeta que el runner abrió, deducida de la raíz: en sidecar la raíz ops es su hija, y en modo
 // embebido son la misma.
-function workspaceOf(root, marcas) {
-  const relative = marcas.dir.startsWith('{{') ? '' : marcas.dir.replace(/\/+$/, '')
+function workspaceOf(root, markers) {
+  const relative = markers.dir.startsWith('{{') ? '' : markers.dir.replace(/\/+$/, '')
   if (!relative) return root
   return path.resolve(root, ...relative.split('/').map(() => '..'))
 }
@@ -109,20 +108,20 @@ function within(dir, base) {
 // juzgando otro archivo, y uno que busque el repo git lo buscaría fuera del proyecto. Se respeta el
 // que manda sólo si cae adentro del workspace —si algún día manda uno real, es mejor que el nuestro—;
 // si no, el workspace, que es donde el runner dice estar trabajando.
-function cwdFor(args, root, marcas) {
+function cwdFor(args, root, markers) {
   const declared = args.Cwd && path.resolve(String(args.Cwd))
-  const workspace = workspaceOf(root, marcas)
+  const workspace = workspaceOf(root, markers)
   return declared && within(declared, workspace) ? declared : workspace
 }
 
-function normalize(input, root, marcas = MARCAS) {
+function normalize(input, root, markers = MARKERS) {
   const args = input.toolCall && input.toolCall.args || {}
   const file = args.TargetFile || args.AbsolutePath || ''
   const content = args.CodeContent || args.ReplacementContent
     || (args.ReplacementChunks && JSON.stringify(args.ReplacementChunks)) || ''
   return {
     sessionId: input.conversationId,
-    cwd: cwdFor(args, root, marcas),
+    cwd: cwdFor(args, root, markers),
     tool_input: {
       command: args.CommandLine || '',
       file_path: file,

package/automatization/shared/eval-only.js

@@ -18,7 +18,7 @@ const onlyCases = (input) => (Array.isArray(input.cases) ? input.cases : String(
 
 // Devuelve los casos pedidos, o los que faltan para que quien llama frene con su propio vocabulario.
 function pickCases(items, only) {
-  const existen = items.map((item) => item.id)
-  const missing = only.filter((id) => !existen.includes(id))
-  return { existen, missing, items: items.filter((item) => only.includes(item.id)) }
+  const present = items.map((item) => item.id)
+  const missing = only.filter((id) => !present.includes(id))
+  return { present, missing, items: items.filter((item) => only.includes(item.id)) }
 }

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/ops.js).
+// empresa, su propia instancia. El porqué del banco está en `evaluationBench` (engine/cli/catalog.js).
 // El veredicto, en cambio, se escribe siempre junto al cargo: el banco se borra, el contrato queda.
 export const meta = {
   name: 'agent-eval',
@@ -105,10 +105,10 @@ if (ONLY.length) {
   const pick = pickCases(context.items, ONLY)
   if (pick.missing.length) {
     return stop('caso-inexistente',
-      `${AGENT} no tiene ${pick.missing.join(', ')}. Tiene: ${pick.existen.join(', ')}`)
+      `${AGENT} no tiene ${pick.missing.join(', ')}. Tiene: ${pick.present.join(', ')}`)
   }
   context.items = pick.items
-  log(`Sólo ${ONLY.join(', ')}: el registro va a cubrir ${ONLY.length} de ${pick.existen.length}`)
+  log(`Sólo ${ONLY.join(', ')}: el registro va a cubrir ${ONLY.length} de ${pick.present.length}`)
 }
 // Un banco por caso, preparados por un solo agente: son comandos deterministas, y después la ruta de
 // cada caso se arma sola.

package/automatization/workflows/agent-promote.js

@@ -29,7 +29,7 @@ export const meta = {
 const AGENT = String((typeof args === 'string' ? args : (args || {}).agent) || '').trim()
 const PERIOD = String((args || {}).period || '').trim()
 
-const FIRMA = {
+const SIGNATURE = {
   type: 'object', additionalProperties: false, required: ['dir', 'proposal', 'approved'],
   properties: {
     dir: { type: 'string' },
@@ -42,7 +42,7 @@ const FIRMA = {
   },
 }
 
-const APLICADO = {
+const APPLIED = {
   type: 'object', additionalProperties: false, required: ['applied', 'files'],
   properties: {
     applied: { type: 'boolean' },
@@ -74,7 +74,7 @@ const signature = await agent(
   `- state: the literal state line.\n` +
   `- status: the literal value of the frontmatter "status:" field.\n` +
   `- hasChange: true only if "Cambio propuesto" carries a concrete change; "por definir" means false.`,
-  { schema: FIRMA, label: 'signature' },
+  { schema: SIGNATURE, label: 'signature' },
 )
 if (!signature) return stop('sin-propuesta', `no se pudo leer una propuesta de ${AGENT}`)
 if (!signature.hasChange) {
@@ -119,7 +119,7 @@ const applied = await agent(
   `aplicó de lo que firmó.\n\n` +
   `No toques otros cargos. No hagas commit ni push. Devolvé qué archivos modificaste, el caso nuevo si ` +
   `lo creaste, y las desviaciones —o cadena vacía si no hubo—.`,
-  { schema: APLICADO, label: `aplica:${AGENT}` },
+  { schema: APPLIED, label: `aplica:${AGENT}` },
 )
 if (!applied || !applied.applied) {
   return stop('no-aplicada', 'el cambio no se pudo aplicar; la propuesta queda como estaba')

package/automatization/workflows/autobuild.js

@@ -86,6 +86,7 @@ const PLAN = {
 // Un veredicto sin manifiesto no se puede contrastar: `consulted` enumera lo que quien revisó abrió de
 // verdad, y es lo único que separa al que miró del que aprobó de memoria. No prueba que lo haya leído bien
 // —para eso habría que releerlo—, y esa asimetría es la que lo deja barato (R14).
+//
 // Tres estados porque hay tres cosas distintas que decir, y con un booleano dos se pisan: «no puedo
 // aprobar esto» y «apruebo con algo que hay que corregir antes de entregar» caían las dos en el mismo
 // `false`, así que la primera gastaba igual una vuelta de corrección sobre algo que la corrección no
@@ -147,11 +148,9 @@ const BUILD = {
       properties: { test: { type: 'string' }, failure: { type: 'string' } },
     } },
     blockers: { type: 'array', items: { type: 'string' } },
-    // Estricto en el cómo, flexible en el qué: lo que aparece y el plan no previó tiene dos destinos y
-    // ninguno es el silencio. Un caso que esta tarea puede fijar entra con la prueba que lo fija —por eso
-    // su `test` tiene que estar en `redFirst`—; una decisión que no le toca queda registrada con quién
-    // puede tomarla. Implementarlo sin prueba lo vuelve invisible y descartarlo lo pierde: en los dos
-    // casos el próximo que lo encuentre empieza de cero.
+    // Estricto en el cómo, flexible en el qué: un `kind` por cada uno de los dos destinos que R6 le da a
+    // lo que aparece y el plan no previó. Lo que agrega este recorrido es el enganche — el caso que esta
+    // tarea puede fijar entra con la prueba que lo fija, y por eso su `test` tiene que estar en `redFirst`.
     discovered: { type: 'array', items: { type: 'object', additionalProperties: false,
       required: ['kind', 'detail'],
       properties: {
@@ -228,23 +227,23 @@ const BASE = `Nunca inventes credenciales ni decisiones; registrá los bloqueos
 // Acompaña a todo prompt con schema DECISION: el schema obliga a llenar `consulted`, y esto obliga a
 // llenarlo con lo que se abrió en vez de con lo que se pensaba mirar.
 const MANIFEST = ' Enumerá en consulted cada archivo, diff o comando que hayas abierto de verdad, con su ruta.'
-// Acompaña a todo prompt con schema DECISION. El criterio va escrito porque tres estados sin criterio son
-// tres nombres, y el del medio —el que evita gastar una corrección en lo que no se corrige— es el que se
-// pierde primero.
+// Acompaña a todo prompt con schema DECISION. Sin el criterio escrito los tres estados son tres nombres
+// y el del medio se pierde primero; por qué son tres está donde se declaran.
 const VERDICT = ' Cerrá con verdict=aprobado si no queda nada por corregir antes de entregar; ' +
   'verdict=con-condiciones si lo que falta se corrige dentro de este mismo cambio; y verdict=bloqueado ' +
   'si algo no se resuelve acá —el diseño no lo cubre, falta una decisión ajena, o la corrección excede el ' +
   'alcance—. Marcá blocking=true sólo en el hallazgo que impide entregar: el resto queda registrado y no ' +
   'manda a tocar código.'
+// 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)
 // 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
 // `ranTests` y vale cualquiera de los dos. Una lista de nombres siempre le va a faltar el siguiente;
 // lo que no puede es frenar una corrida legítima por no conocerlo.
+//
 // El borde izquierdo va explícito en vez de `\b` porque `\b(?:` se lee igual que una llamada a `b()`
 // y la comprobación de identificadores del paquete de pruebas la marca como función inexistente.
-// 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)
 const RUNS_TESTS = /(?:^|[\s/:=-])(?:tests?|specs?|pytest|jest|vitest|mocha|rspec|phpunit|ci|check)\b/i
 {{INCLUDE:shared/workflow-finish.js}}
 
@@ -512,8 +511,8 @@ while (rounds++ < MAX_TASKS) {
   // Lo que queda abierto no lo cierra quien lo encuentra, pero tampoco frena lo que sí se pudo entregar.
   // Tres corridas reales terminaron acá y las tres traían `completed: true`: el hueco nunca fue «no puedo»
   // sino «hay un borde que alguien tiene que decidir», y una aceptación escrita en prosa siempre tiene uno.
-  // Frenar por eso frenaba siempre, y un freno que salta siempre se termina apagando. Lo que de verdad
-  // bloquea ya tiene camino —`completed: false` con su blocker—; esto se registra y sigue.
+  // Frenar por eso frenaba siempre, que es el freno que R6 desaconseja. Lo que de verdad bloquea ya
+  // tiene camino —`completed: false` con su blocker—; esto se registra y sigue.
   const openDecisions = build.discovered.filter((entry) => entry.kind === 'open')
   if (openDecisions.length) {
     await write(`Registrá en ${HUMAN} una fila por cada decisión que ${task.id} dejó abierta, con qué la ` +
@@ -522,6 +521,7 @@ while (rounds++ < MAX_TASKS) {
   }
   // Y un caso que sí se fijó acá entra con su prueba o no entró: sin ella el comportamiento nuevo queda
   // sin nada que lo sostenga, y nadie sabe después que debía existir.
+  //
   // Los dos campos salen de la misma respuesta pero se escriben por separado, así que pedirles la misma
   // cadena exacta frena una tarea correcta por haber nombrado el test de dos formas —`TestAlta` acá y
   // `users_test.go::TestAlta` allá—. Alcanza con que uno nombre al otro; lo que sigue frenando, que es de

package/automatization/workflows/flow-eval.js

@@ -39,10 +39,9 @@ const CASES = {
       },
     } },
     forbidden: { type: 'array', items: { type: 'string' } },
-    // Qué CLI existe acá. Una empresa tiene el shim `tools/ops.js`; el repo del toolkit no lo tiene y su
-    // motor está en `engine/cli/ops.js`. `agent-eval` lo aprendió esta mañana y esto quedó con la ruta
-    // puesta a mano: el agente de bancos reportó los cuatro casos como fallidos y el freno de banco
-    // viejo detuvo cuatro corridas cuyos bancos estaban recién borrados.
+    // Qué CLI existe acá, por lo mismo que en `agent-eval` y con el mismo síntoma: sin la ruta puesta,
+    // el agente de bancos reportó los cuatro casos como fallidos y el freno de banco viejo detuvo cuatro
+    // corridas cuyos bancos estaban recién borrados.
     cli: { type: 'string' },
     mode: { type: 'string' },
   },
@@ -92,10 +91,10 @@ if (ONLY.length) {
   const pick = pickCases(context.items, ONLY)
   if (pick.missing.length) {
     return stop('caso-inexistente',
-      `${FLOW} no tiene ${pick.missing.join(', ')}. Tiene: ${pick.existen.join(', ')}`)
+      `${FLOW} no tiene ${pick.missing.join(', ')}. Tiene: ${pick.present.join(', ')}`)
   }
   context.items = pick.items
-  log(`Sólo ${ONLY.join(', ')}: el registro va a cubrir ${ONLY.length} de ${pick.existen.length}`)
+  log(`Sólo ${ONLY.join(', ')}: el registro va a cubrir ${ONLY.length} de ${pick.present.length}`)
 }
 
 // El recorrido escribe: épica candidata, INBOX, acciones humanas. Sin un `planning/` propio no puede
@@ -117,9 +116,13 @@ const benches = await agent(
 )
 if (!benches || !benches.path) return stop('sin-banco', 'no se pudieron preparar los bancos')
 if (benches.failed && benches.failed.length) {
+  // Los bancos de los casos que fallaron, no el del recorrido entero. Nombrar `BENCH_ROOT` se llevaba
+  // por delante los bancos de los casos que nadie estaba re-corriendo: pasó re-midiendo uno solo de
+  // `change-review`, y el mensaje proponía borrar también el del caso vecino. Los ids ya están acá.
   return stop('banco-sin-rehacer',
     `${benches.failed.join(', ')}: su banco conserva trabajo sin recoger de una corrida anterior. ` +
-    `Guardá el registro de esa corrida y volvé a armarlo con --force, o borrá ${BENCH_ROOT}.`)
+    `Guardá el registro de esa corrida y volvé a armarlo con --force, o borrá ` +
+    `${benches.failed.map((id) => `${BENCH_ROOT}/${id}`).join(', ')}.`)
 }
 // Un caso de recorrido gasta el recorrido entero, no dos agentes: de ahí que se diga aparte.
 log(`${context.items.length} caso(s) de ${FLOW} — cada uno corre el recorrido completo`)

package/automatization/workflows/flow.js

@@ -69,9 +69,8 @@ const MANIFEST = {
       id: { type: 'string' }, agent: { type: 'string' }, exitGate: { type: 'string' },
       phase: { type: 'string', enum: ['discovery', 'delivery'] },
       produces: { type: 'array', items: { type: 'string' } },
-      // El recorrido no lo usa —las etapas corren en orden—, pero el contrato lo trae y al agente se le
-      // pide que reporte lo que el comando imprimió. Rechazarlo hacía que el reintento volviera a
-      // copiarlo hasta agotar el cap, y la corrida moría sin haber hecho nada.
+      // El recorrido no lo usa —las etapas corren en orden—, pero el contrato lo trae y el agente lo
+      // copia, así que rechazarlo mataba la corrida por el reintento que se describe en `completion`.
       dependsOn: { type: 'array', items: { type: 'string' } },
       // Resuelto acá una vez: sin esto cada etapa gasta llamadas buscando el contrato de su cargo,
       // que además ya no vive en el proyecto sino en el paquete.
@@ -190,11 +189,11 @@ const owners = (contract.owners || []).map((owner) => `${owner.domain}=${owner.a
 // Qué recorridos existen. Va en las reglas comunes y no sólo en la etapa que enruta: cualquier etapa
 // puede nombrar un destino al cerrar, y son unos pocos slugs. Sin esto `intake` —que existe para
 // enrutar— recomendaba de memoria, que es la conducta que los casos de los cargos castigan.
-const catalogo = (contract.flows || []).filter((slug) => slug !== FLOW)
+const catalog = (contract.flows || []).filter((slug) => slug !== FLOW)
 const RULES = `${BASE}\n\nRecorrido ${contract.name}: ${contract.purpose}\n` +
   `Guardrails: ${contract.guardrails.join(' ')}\n` +
   `${owners ? `Dueños de decisión: ${owners}. Ningún otro cargo resuelve en su dominio.\n` : ''}` +
-  `${catalogo.length ? `Recorridos que existen además de éste: ${catalogo.join(', ')}. Si nombrás un `
+  `${catalog.length ? `Recorridos que existen además de éste: ${catalog.join(', ')}. Si nombrás un `
     + `destino, sale de esa lista; si ninguno sirve, decilo con su razón en vez de inventar uno.\n` : ''}` +
   `Contexto de la empresa en ${WORKDIR}/organization/. Intención a evaluar: ${GOAL}`
 
@@ -219,8 +218,8 @@ function ancestors(stage, index) {
     if (out.has(id)) continue
     out.add(id)
     const found = discovery.find((one) => one.id === id)
-    const arriba = found && found.dependsOn ? found.dependsOn : []
-    for (const up of arriba) pending.push(up)
+    const upstream = found && found.dependsOn ? found.dependsOn : []
+    for (const up of upstream) pending.push(up)
   }
   return [...out]
 }
@@ -250,12 +249,12 @@ function levels(stages) {
 
 const runStage = (stage, index) => {
   const visible = handoffs.filter((entry) => ancestors(stage, index).includes(entry.id))
-  const abiertas = openConditions(visible)
+  const open = openConditions(visible)
   const previous = visible.length
     ? `Handoffs previos:\n${visible.map((entry) => `- ${entry.id}: ${entry.summary}`).join('\n')}`
-      + (abiertas.length
+      + (open.length
         ? '\n\nCondiciones que dejaron las etapas anteriores y tenés que respetar:\n'
-          + abiertas.map((one) => `- ${one}`).join('\n')
+          + open.map((one) => `- ${one}`).join('\n')
         : '')
     : 'Sos la primera etapa: no hay handoff previo.'
   return agent(

package/automatization/workflows/onboard.js

@@ -80,9 +80,8 @@ const SCAN = {
           required: ['kind', 'command', 'source'], properties: {
             kind: { type: 'string' }, command: { type: 'string' }, source: { type: 'string' },
           } } },
-        // Los nombres de variable que ese servicio espera, copiados del inventario. En un multirepo cada
-        // repositorio trae su propio ejemplo, y sin esto las credenciales de tres repos no existían para
-        // el arranque: las filas terminaban diciendo «la credencial del proveedor» sin nombrarla.
+        // Los nombres de variable que ese servicio espera, copiados del inventario y no deducidos: de
+        // acá sale la fila que nombra la credencial en vez de decir «la del proveedor».
         env: { type: 'array', items: { type: 'string' } },
       } } },
     externals: { type: 'array', items: { type: 'string' } },
@@ -144,8 +143,8 @@ if (!CONTEXT && state.opening) {
   return finish({ needsContext: true, opening: state.opening, dimensions, services: services.length })
 }
 
-const INVENTARIO = { services, externals: state.externals || [], secrets: state.secrets || [] }
-const EVIDENCE = `Inventario del workspace:\n${JSON.stringify(INVENTARIO)}` +
+const INVENTORY = { services, externals: state.externals || [], secrets: state.secrets || [] }
+const EVIDENCE = `Inventario del workspace:\n${JSON.stringify(INVENTORY)}` +
   `${CONTEXT ? `\n\nContexto aportado por la persona, que vale como hecho: ${CONTEXT}` : ''}` +
   `${services.length ? '' : '\n\nNo hay ningún servicio en el workspace: el código todavía no está acá.'}`
 

package/engine/agents/evaluations.js

@@ -39,7 +39,7 @@ function caseFiles(dir) {
 //
 // Existe porque un caso que *describe* un artefacto externo sin entregarlo mide algo más fácil de lo
 // que dice medir: al cargo se le pregunta si obedecería un documento del que se le está hablando, y un
-// texto que nunca leyó no puede inyectarlo. Los 47 casos adversariales del catálogo nacieron así, y uno
+// texto que nunca leyó no puede inyectarlo. Los casos adversariales del catálogo nacieron así, y uno
 // produjo un fallo falso: el cargo escribió que había leído una guía inexistente porque el arnés se la
 // había afirmado.
 function fixtureFiles(dir, prefix = '') {
@@ -89,7 +89,7 @@ function list(root, agent, kind) {
   })
 }
 
-// Lo que el cargo no debe hacer, declarado por cargo en `expected-behaviors.yaml`.
+// Lo que el cargo debe y no debe hacer, declarado por cargo en `expected-behaviors.yaml`.
 //
 // Se parsea a mano porque el archivo es una lista de escalares y el repositorio no tiene dependencias:
 // traer un parser de YAML para leer dos listas sería pagar una dependencia por un `split`.
@@ -116,7 +116,8 @@ function behaviors(root, agent, kind) {
 }
 
 // Cuándo cambió por última vez el contrato que la corrida midió. Sale de git y no del mtime del
-// archivo: un `npm ci` o un checkout reescriben mtimes y dirían que todo cambió hoy.
+// archivo: un `npm ci` o un checkout reescriben mtimes y dirían que todo cambió hoy —comprobado con
+// git 2.43.0, un `git checkout <commit> -- <archivo>` le deja el mtime de la corrida—.
 //
 // Sin esto, un contrato que se endurece deja atrás registros que siguen diciendo «pasa» — y el que
 // endurece es justo el que puede hacerlos fallar. Es la misma confusión que el resultado que cubre
@@ -231,17 +232,18 @@ function composed(root, agent, kind) {
   }
 }
 
-// Coherencia entre lo que hay y lo que se corrió. Todo sale como advertencia y ninguno afecta el
-// código de salida, y no es blandura: correr los casos exige un modelo, y CI no lo tiene. Un `evaluate`
-// que fallara por un resultado viejo obligaría a pagar una corrida para poder integrar, y volvería a
-// fallar cada vez que el contrato cambie. Quien falla fuerte es el recorrido que sí los ejecuta.
+// Coherencia entre lo que hay y lo que se corrió. Lo que mide una corrida sale como advertencia y no
+// toca el código de salida, y no es blandura: correr los casos exige un modelo, y CI no lo tiene. Un
+// `evaluate` que fallara por un resultado viejo obligaría a pagar una corrida para poder integrar, y
+// volvería a fallar cada vez que el contrato cambie. Quien falla fuerte es el recorrido que sí los
+// ejecuta. Lo que sí corta con 1 es `errors`, y por qué es la excepción está donde se arma.
 function validate(root, agent, kind) {
   const warnings = []
   const cases = list(root, agent, kind)
   const total = cases.length
   // Esto sí es control estructural y no advertencia: que el artefacto esté entregado es una propiedad
-  // estática del caso, verificable sin modelo, y dejarla en advertencia es lo que permitió que 47 casos
-  // midieran la versión débil de su propia pregunta.
+  // estática del caso, verificable sin modelo, y dejarla en advertencia es lo que permitió que el
+  // catálogo entero midiera la versión débil de su propia pregunta.
   const errors = cases
     .filter((item) => item.id.includes('adversarial') && !item.fixtures.length)
     .map((item) => `${item.id}: caso adversarial sin artefacto en cases/${item.id}/`)
@@ -255,17 +257,17 @@ function validate(root, agent, kind) {
     warnings.push(`sin resultados de casos: corré el recorrido de evaluación para los ${total} casos`)
     return { errors, warnings, cases: total, last: null }
   }
-  const sinMedir = cases.map((item) => item.id).filter((id) => !state.measured.has(id))
-  if (sinMedir.length) {
-    warnings.push(`${state.total} de ${total} caso(s) con veredicto: sin medir ${sinMedir.join(', ')}`)
+  const unmeasured = cases.map((item) => item.id).filter((id) => !state.measured.has(id))
+  if (unmeasured.length) {
+    warnings.push(`${state.total} de ${total} caso(s) con veredicto: sin medir ${unmeasured.join(', ')}`)
   }
   if (state.failed.length) {
     warnings.push(`${state.failed.length} caso(s) no pasan: ${state.failed.join(', ')}`)
   }
-  const cambio = contractChangedAt(subject(root, agent, kind), kind)
-  if (cambio && cambio > state.oldest) {
-    const parte = state.oldest === state.newest ? 'la última corrida es' : 'el veredicto más viejo es'
-    warnings.push(`el contrato cambió el ${cambio} y ${parte} del ${state.oldest}: `
+  const changedAt = contractChangedAt(subject(root, agent, kind), kind)
+  if (changedAt && changedAt > state.oldest) {
+    const which = state.oldest === state.newest ? 'la última corrida es' : 'el veredicto más viejo es'
+    warnings.push(`el contrato cambió el ${changedAt} y ${which} del ${state.oldest}: `
       + 'mide una versión anterior')
   }
   return { errors, warnings, cases: total, last, state }