@ingeniomaps/cauce 0.77.0 → 0.79.0

package/CHANGELOG.md

@@ -14,6 +14,80 @@ 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.79.0] - 2026-09-10
+
+### Corregido
+
+- **La fila que registra una parada se escribe antes de parar.** Cuando ningún plan sobrevive a la
+  crítica, el recorrido pide que la tarea quede en `HUMAN_ACTIONS.md` con su motivo —así `context` deja
+  de ofrecerla y alguien la ve—. Esa escritura se lanzaba y el recorrido volvía en la línea siguiente,
+  así que el agente que la escribía se quedaba a mitad de camino: en una corrida real el resumen contó
+  diez agentes y el registro nueve. La parada se informaba bien y el disco no la tenía.
+
+  Ahora se espera. Y en las tres paradas que dejan fila —plan rechazado, tarea que no está lista,
+  criterio que no dice qué aserciar— si el agente no contesta, el detalle de la parada lo dice: el
+  motivo sigue siendo el que la causó, y se agrega que la fila hay que escribirla a mano.
+
+  **Qué cambia para vos**: relanzar después de un plan rechazado deja de repetir la planificación
+  entera, porque la tarea queda registrada. Si venías viendo que `context` te ofrecía otra vez la tarea
+  que acababa de rechazarse, era esto.
+
+- **El guard de migraciones frena por haber viajado, no por estar en disco.** Escribir una migración son
+  dos pasos —crearla y completarla— y el segundo se bloqueaba: el chequeo preguntaba si el archivo
+  existía, que no es la pregunta. Un stub de hace dos segundos y una migración publicada hace un año
+  daban la misma respuesta, y **ninguna herramienta lo esquivaba** —`Write`, `Edit` y `MultiEdit` se
+  bloqueaban igual—, así que lo único que quedaba a la vista era apagar el guard entero, incluida la
+  protección contra SQL destructivo.
+
+  Ahora se le pregunta a git si el archivo está en `HEAD`. En el índice no alcanza: un archivo apenas
+  agregado no viajó a ninguna parte. Y sin repositorio con el que contestar —un proyecto sin git— se
+  conserva la conducta anterior en vez de dejar pasar, que es el lado correcto para equivocarse cuando
+  no se puede saber.
+
+  **Qué cambia para vos**: completar una migración recién creada deja de frenarse. El mensaje del
+  bloqueo pasa a decir el hecho que lo sostiene —que está en el historial, o que existe y acá no hay con
+  qué saberlo— y a nombrar cómo aprobar esa ruta puntual en `planning/.ops-approval`, que es lo que el
+  bloqueo hermano ya hacía. Si tenías `OPS_MIGRATIONS_OVERRIDE=1` puesto para poder trabajar, ya no hace
+  falta y conviene sacarlo: apagaba también lo que sí te cuida.
+
+## [0.78.0] - 2026-09-10
+
+### Corregido
+
+- **Las puertas que revisan un recorrido leen los literales de regex.** Tres pruebas analizan cada
+  workflow como texto —que su `meta` sea un literal puro, que no llame a nada inexistente y que no use un
+  nombre que no declaró— y ninguna sabía qué es un regex. La barra escapada que cierra uno deja un `//`
+  literal, que se leía como el arranque de un comentario: a partir de ahí se perdía el resto de la línea,
+  en silencio. Dos recorridos del catálogo tenían cuatro líneas así.
+
+  **Qué cambia para vos**: nada en lo que recibís, y sí en lo que se puede confiar. Un recorrido propio
+  con un regex adentro ahora se revisa entero en vez de a medias, y un `meta` con un regex o con una
+  interpolación —que hasta acá pasaba siempre, porque esa regla no podía dispararse— se rechaza.
+- **El nombre de un banco de pruebas no trae nada que la prueba no haya pedido.** La suite aísla lo que
+  cada prueba mide filtrando la salida de `check`, y esa salida empieza con la ruta del banco: cuando el
+  sufijo aleatorio del directorio terminó en `adr`, un error ajeno entró a una prueba de plantillas de
+  ADR y la puso en rojo. Falla una vez cada muchas corridas y se lee como un hipo del entorno.
+
+  **Qué cambia para vos**: nada — es la suite del toolkit, no algo que recibas. Va acá porque una puerta
+  que falla al azar enseña a relanzar en vez de a mirar, y eso sí llega a quien la usa.
+
+- **`autobuild` lee `blocked` por su valor y no por su verdad.** El campo del contexto es un vocabulario
+  de tres valores —vacío, `awaiting-review` y `blocked-on-human`—, y el recorrido lo probaba con un `if`
+  a secas. Dos consecuencias, y la que más costaba no era intermitente: una cola trabada por acciones
+  humanas frenaba con el motivo del checkpoint de hito y mandaba a mirar `AWAITING_REVIEW.md`, un archivo
+  que en ese escenario no existe. Ahora cada bloqueo para con su motivo y nombra su archivo:
+  `AWAITING_REVIEW.md` para el checkpoint, `HUMAN_ACTIONS.md` —con las tareas trabadas— para la cola.
+
+  La otra es la que se ve al azar: el agente que transcribe el contexto a veces entrega el vacío como la
+  cadena de dos comillas, y eso frenaba la corrida en la fase 1 sin que hubiera nada que resolver. Medido
+  sobre siete corridas de una instancia real: 3 de 24 lecturas llegaron así, y una de cada siete cayó en
+  la única lectura que consulta el campo. Las formas equivocadas del vacío se desenvuelven antes de leer.
+
+  Y lo que no está en el vocabulario ya no se adivina en ninguna de las dos direcciones: no se sigue como
+  si no hubiera bloqueo ni se inventa cuál es — para diciendo que el contexto llegó fuera del
+  vocabulario. El esquema declara los tres valores, igual que `lane`; eso documenta el contrato, y lo que
+  sostiene el arreglo es la lectura.
+
 ## [0.77.0] - 2026-09-10
 
 ### Corregido

package/automatization/workflows/autobuild.js

@@ -38,6 +38,11 @@ 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
+// leen este archivo sin parsearlo —caso 084—, y de a pares es además lo correcto, porque una comilla
+// suelta no es un envoltorio. Por eso también la escapada en vez de alternar el estilo de comillas.
+const QUOTES = ['\'', '"']
+
 const CONTEXT = {
   type: 'object', additionalProperties: false,
   required: ['blocked', 'hasTask', 'wipActive', 'queued', 'cast', 'readOk'],
@@ -46,7 +51,13 @@ const CONTEXT = {
     // exactamente lo que un modelo completa cuando no tiene qué poner. Sin este campo esa invención se
     // lee igual que una cola terminada, y Pick la toma como permiso para promover.
     readOk: { type: 'boolean' },
-    blocked: { type: 'string' }, hasTask: { type: 'boolean' }, wipActive: { type: 'boolean' },
+    // Vocabulario cerrado, igual que `lane` acá abajo, y por la misma razón: el motor emite tres valores
+    // y nada más —`ops context` los decide con un `existsSync` y un conteo—, así que dejarlo como texto
+    // libre le pedía a quien lo transcribe que acertara una convención invisible. Un modelo que rellena
+    // «el valor vacío» puede escribir la cadena vacía o **escribir las comillas**, y las dos satisfacían
+    // el esquema: medido en una instancia real, 3 de 24 lecturas llegaron como `"\"\""` (caso 083).
+    blocked: { type: 'string', enum: ['', 'awaiting-review', 'blocked-on-human'] },
+    hasTask: { type: 'boolean' }, wipActive: { type: 'boolean' },
     queued: { type: 'integer' }, slug: { type: 'string' }, hito: { type: 'string' },
     service: { type: 'string' }, acceptance: { type: 'string' }, epic: { type: 'string' },
     // Sin declararlo acá no llega: `additionalProperties: false` lo descartaría, y el aplanado de la
@@ -344,6 +355,14 @@ const read = (prompt, options = {}) => agent(`${BASE}\n\n${prompt}`, options)
 const run = (prompt, options = {}) => agent(`${SCOPE}\n\n${prompt}`, options)
 const write = (prompt, options = {}) => agent(`${LEDGER}\n\n${prompt}`, options)
 
+// Las tres paradas que dejan una fila en HUMAN_ACTIONS delegan esa escritura a un agente, y esa fila es
+// el único rastro de la parada: sin ella el recorrido informa un estado que el disco no tiene. Por eso
+// se espera —lanzarla y volver en la línea siguiente la abandona— y por eso se mira si contestó.
+// Devuelve lo que hay que agregarle al detalle, vacío cuando la fila quedó pedida. Caso 087.
+const registerHuman = async (prompt, label) => (await write(prompt, { label })
+  ? ''
+  : ` — la fila en ${HUMAN} no se pudo registrar: escribila a mano`)
+
 // Gate, mutex de WIP y selección de tarea salen de un comando determinista: AWAITING_REVIEW, BACKLOG,
 // WIP y HUMAN_ACTIONS nunca entran al contexto de un modelo, y su tamaño deja de costar tokens.
 const readContext = () => read(
@@ -364,7 +383,28 @@ if (!planning) return stop('context-unavailable', `no se pudo leer el estado de
 // Que el agente conteste no significa que haya leído: el schema se completa igual con ceros. Parar acá
 // cuesta una corrida; seguir sobre una lectura fallida escribe en el BACKLOG, y eso no se revierte solo.
 if (!planning.readOk) return stop('context-unavailable', `${P} no se pudo leer; revisá la ruta y el cwd`)
-if (planning.blocked) return stop('awaiting-human-review', `${GATE} tiene un checkpoint humano sin resolver`)
+// `blocked` se lee por su valor y no por su verdad. Como verdad, **cualquier** cadena no vacía frenaba la
+// corrida con el mismo motivo, y eso mentía dos veces: con `blocked-on-human` —la cola trabada por
+// acciones humanas, que es otra cosa— mandaba a mirar un gate que no existe, y eso no era intermitente;
+// y con la cadena `""` que a veces llega del transcriptor, frenaba sin que hubiera nada que resolver.
+//
+// El vacío se normaliza antes porque sus formas equivocadas no son ambiguas: dos comillas o unos espacios
+// no son ningún bloqueo legítimo. Lo que no se reconoce **no se adivina**: para diciendo que el contexto
+// llegó fuera del vocabulario, que es lo que esta familia de casos —056, 074, 075— pide para lo que no se
+// pudo determinar.
+let blocker = String(planning.blocked || '').trim()
+while (blocker.length > 1 && QUOTES.includes(blocker[0]) && blocker[blocker.length - 1] === blocker[0]) {
+  blocker = blocker.slice(1, -1).trim()
+}
+if (blocker === 'awaiting-review') {
+  return stop('awaiting-human-review', `${GATE} tiene un checkpoint humano sin resolver`)
+}
+if (blocker === 'blocked-on-human') {
+  return stop('blocked-on-human', `toda la cola espera una acción humana. Está en ${HUMAN}`
+    + `${(planning.blockedTasks || []).length ? `, sobre ${planning.blockedTasks.join(', ')}` : ''}`)
+}
+if (blocker) return stop('context-unavailable', `${P} contestó blocked=${JSON.stringify(planning.blocked)}, `
+  + 'que no es del vocabulario. No se sabe si hay bloqueo, así que no se sigue como si no lo hubiera.')
 
 let currentMilestone = planning.wipActive ? planning.hito : ''
 const completed = []
@@ -520,12 +560,13 @@ while (rounds++ < MAX_TASKS) {
   //
   // Lo que la fila le pide a una persona lo dice R17: dos rechazos sobre lo mismo son el disparador
   // posterior de división. No se parte acá porque partir es una decisión, y ésa no le toca al recorrido.
-  const planRejected = (reason, unit, found) => {
+  const planRejected = async (reason, unit, found) => {
     const detail = found.join('; ') || 'sin condiciones nombradas'
-    write(`Registrá ${unit.id} en ${HUMAN}: nadie pudo escribir un plan que sobreviva a la crítica. `
+    const nota = await registerHuman(
+      `Registrá ${unit.id} en ${HUMAN}: nadie pudo escribir un plan que sobreviva a la crítica. `
       + `Motivo: ${detail}. La acción humana es revisar si la unidad son dos resultados con vidas `
-      + `distintas y partirla —R17—, o dejarla entera con la razón escrita.`, { label: 'plan-human' })
-    return stop(reason, detail)
+      + `distintas y partirla —R17—, o dejarla entera con la razón escrita.`, 'plan-human')
+    return stop(reason, `${detail}${nota}`)
   }
 
   if (!planning.wipActive) {
@@ -539,9 +580,10 @@ while (rounds++ < MAX_TASKS) {
       )
       if (!ready) return stop('agent-unavailable', 'Ready no devolvió resultado')
       if (!ready.ready) {
-        await write(`Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
-          { label: 'ready-human' })
-        return stop('not-ready', ready.reason)
+        const nota = await registerHuman(
+          `Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
+          'ready-human')
+        return stop('not-ready', `${ready.reason}${nota}`)
       }
       if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
     }
@@ -761,9 +803,10 @@ while (rounds++ < MAX_TASKS) {
   // hacer parar a una persona por eso le cobra una interrupción por algo que se resolvía solo.
   const ambiguous = verified.uncovered.find((entry) => entry.cause === 'ambiguous')
   if (ambiguous) {
-    await write(`Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
-      `que aserciar, y hace falta la decisión que lo fija.`, { label: 'verify-human' })
-    return stop('acceptance-ambiguous', ambiguous.criterion)
+    const nota = await registerHuman(
+      `Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
+      `que aserciar, y hace falta la decisión que lo fija.`, 'verify-human')
+    return stop('acceptance-ambiguous', `${ambiguous.criterion}${nota}`)
   }
   if (verified.uncovered.length) {
     await run(`${asRole(cast.build)}Escribí sólo las pruebas que faltan en ${task.id}, con el mismo rojo ` +

package/engine/hooks/files.js

@@ -6,6 +6,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
+const { spawnSync } = require('node:child_process')
 const {
   patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot,
   writableRoots, outsideRoots, DECLARE_IT,
@@ -26,6 +27,29 @@ function opsRoot(input) {
 // el guard hasta que cierre la sesión.
 const approved = (input, file) => !AP.pending(opsRoot(input), [file]).length
 
+// Si la migración ya viajó a otra copia, que es lo que el bloqueo de abajo quiere saber y `existsSync`
+// no contesta. Devuelve el motivo del bloqueo o cadena vacía.
+//
+// **`HEAD` y no el índice**: un archivo apenas `git add`eado no viajó a ninguna parte, y `git ls-files`
+// lo daría por historial. Y **resolver la raíz es una pregunta aparte** de si el archivo está en `HEAD`:
+// las dos fallan con 128 y confundirlas repite el error que este caso arregla —decidir por la respuesta
+// equivocada—. Sin raíz resoluble se degrada a la conducta de antes, que bloquea de más, porque cuando
+// no se puede saber ése es el lado correcto para equivocarse. Es la degradación que `check` ya declara
+// cuando no puede resolver el repositorio de un servicio. Caso 086.
+function alreadyShipped(file) {
+  if (!fs.existsSync(file)) return ''
+  const cwd = path.dirname(file)
+  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
+  if (top.status !== 0) {
+    return 'existe, y acá no hay repositorio con el que saber si ya viajó a otra copia'
+  }
+  const rel = path.relative(top.stdout.trim(), file).split(path.sep).join('/')
+  return spawnSync('git', ['cat-file', '-e', `HEAD:${rel}`], { cwd }).status === 0
+    ? 'ya está en el historial del repositorio'
+    : ''
+}
+
+
 function secrets(input) {
   for (const file of filesOf(input)) {
     const base = path.basename(file)
@@ -232,9 +256,15 @@ function migrations(input) {
     if (destructiveSql.test(contentOf(input))) {
       block(`${raw} contiene SQL destructivo.\n${AP.HOW('OPS_MIGRATIONS_OVERRIDE')}`)
     }
+    // El mensaje nombra el hecho que sostiene el bloqueo y no su interpretación: «historial» era una
+    // lectura que `existsSync` no podía dar, y se la daba igual sobre stubs de la misma sesión. Y lleva
+    // la salida angosta, que hasta 0.79.0 sólo tenía el bloqueo hermano: éste es el que aparece en el
+    // flujo normal de escribir una migración, así que era justo el que no podía quedarse sin decirla.
     const file = path.resolve(cwdOf(input), raw)
-    if (fs.existsSync(file)) {
-      block(`${raw} es una migración existente. Crea una nueva en vez de reescribir historial.`)
+    const shipped = alreadyShipped(file)
+    if (shipped) {
+      block(`${raw} ${shipped}. Crea una nueva en vez de reescribirla.\n`
+        + AP.HOW('OPS_MIGRATIONS_OVERRIDE'))
     }
   }
 }

package/package.json

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