@ingeniomaps/cauce 0.78.0 → 0.79.0

package/CHANGELOG.md

@@ -14,6 +14,42 @@ 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

package/automatization/workflows/autobuild.js

@@ -355,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(
@@ -552,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) {
@@ -571,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
     }
@@ -793,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.78.0",
+  "version": "0.79.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",