@ingeniomaps/cauce 0.95.0 → 0.97.0

package/CHANGELOG.md

@@ -14,6 +14,156 @@ 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.97.0] - 2026-09-17
+
+### Agregado
+
+- **La revisión de `autobuild` tiene dónde poner una decisión que no le toca tomar.** Tenía dos puertas:
+  marcar el hallazgo como bloqueante —y mandar a tocar código— o dejarlo en el INBOX como propuesta, con
+  tope de tres. Un contrato público que alguien tiene que definir no es ninguna de las dos, así que el
+  revisor elegía frenar, que de las dos es la correcta y costaba la corrida entera sobre trabajo que
+  estaba bien.
+
+  Ahora ese hallazgo va a `HUMAN_ACTIONS.md` con qué lo cierra y quién puede tomarlo, nombrando la épica o
+  el hito al que alcanza —nunca la tarea, para no bloquear a la que lo encontró—, y la corrida sigue. La
+  entrada de DONE cuenta cuántas quedaron registradas.
+
+### Corregido
+
+- **Una parada que espera una decisión tuya suelta la tarea que había reservado.** Al registrar la fila
+  en `HUMAN_ACTIONS.md`, la tarea queda bloqueada; si además seguía reservada, el runner quedaba ocupado
+  por algo que nadie podía tomar y la corrida siguiente moría reclamando la que sigue —«este runner ya
+  tiene …»—. Pasaba en toda parada anterior a Build, que son las más frecuentes mientras una tarea
+  todavía se está definiendo, y costaba una corrida entera por vez.
+
+  Las paradas de después de construir **no** sueltan nada: ahí el WIP existe y es resumible, y la reserva
+  es lo único que dice de quién es ese trabajo.
+
+- **Lo que la línea de una tarea ya decidió llega a las fases que deciden.** La descripción —dónde vive un
+  símbolo, qué queda fuera de alcance, con qué se produce la evidencia— se leía del BACKLOG y se
+  descartaba, así que Plan la volvía a decidir por su cuenta y decidía distinto. Critique **sí** abre el
+  BACKLOG, y bloqueaba el plan citando la línea palabra por palabra: una compuerta juzgando contra un
+  texto que la otra no recibió. Dos corridas medidas se pagaron enteras por esto, 1,10 M y 815 k tokens,
+  sin escribir una línea.
+
+  Ahora `ops context` la emite con la tarea y llega a Ready, Plan, Critique y Build, dicha como lo que es:
+  decisiones ya tomadas, que no se re-deciden. **No tenés que cambiar nada en tus líneas** — es el texto
+  que ya escribías antes de la aceptación.
+
+- **`git commit --amend` se frena sobre historia publicada, y ya no sobre la que nadie vio.** Lo que R8
+  protege es la historia que otro leyó —lo mismo que ya decía del force-push—, y el guard lo bloqueaba
+  siempre «por política y no por daño». Eso no impedía el resultado: `git reset --soft HEAD~1` y volver a
+  commitear produce exactamente lo mismo, no lo frena nada y no deja constancia. Sólo impedía el comando
+  que lo nombra.
+
+  Ahora el guard mira si algún remoto alcanza al commit, con una lectura local que no habla con ningún
+  servidor. Publicado sigue cerrado y sin salida por chat, igual que el force-push. **R8 también cambió**:
+  pasa a prohibir reescribir historia que otro ya leyó, en vez de nombrar el comando.
+
+- **Una etapa de un recorrido ya no muere por escribir de más.** Pasado cierto tamaño el modelo deja de
+  emitir los campos y devuelve el JSON envuelto como texto, que no valida; cinco reintentos después la
+  etapa se cae y la corrida entera se para. Cada campo de la respuesta lleva ahora su tope declarado
+  —`summary` 1000 caracteres, `missing` y `humanAction` 500, cada evidencia 200—, así que el rechazo
+  nombra el campo y el número en vez de decir que no se pudo parsear.
+
+  Lo que no entra no se pierde: va al archivo de análisis, que es lo que lee quien sintetiza al final.
+  Si escribís un recorrido propio, no tenés que hacer nada — el tope es del esquema, no del contrato.
+
+- **`autobuild` ya no frena una tarea correcta porque el nombre del test venga anotado de dos formas.**
+  La puerta comprueba que un borde que el build arregló aparezca en algún rojo declarado, comparando los
+  dos nombres por contención. Eso cubría que uno fuera prefijo del otro, y dejaba afuera la forma que
+  aparece de verdad: los dos nombran el mismo test y cada uno le agrega **su propia** anotación entre
+  paréntesis —dónde está la línea de un lado, por qué se vio en rojo del otro—. Ahí ninguno contenía al
+  otro y la corrida paraba con `edge-unproven` sobre trabajo terminado y en verde.
+
+  Si te pasó, la tarea estaba bien: no hacía falta rehacerla. Y el motivo de la parada ya no se contradice
+  solo — dice qué comparó la puerta en vez de afirmar que faltaba la prueba.
+
+- **Una corrección de Review se lleva también lo que ella misma dejó desactualizado.** «Corregí sólo estos
+  hallazgos» acota el alcance y dejaba un cabo suelto: el conteo que enumeraba lo que cambió, el
+  comentario que describía la forma vieja, la fila que la afirmaba. Como Review tiene una sola vuelta de
+  corrección, esa deriva aterrizaba en la re-revisión y la corrida frenaba sobre trabajo correcto.
+
+- **El checkpoint de hito se destraba escribiendo, no borrando.** `AWAITING_REVIEW.md` frenaba a todos los
+  runners por el hecho de existir, así que resolverlo exigía acordarse de borrarlo — y mientras tanto
+  quien lo leía podía ver ahí escrito que ya estaba revisado. Es lo que R28 prohíbe, y el propio archivo
+  lo decía de sí mismo.
+
+  Ahora lleva `status: pendiente` en su frontmatter y se destraba cambiándolo a `resuelta`, con lo cual el
+  archivo **se queda** y se puede leer después qué se revisó. Borrarlo sigue funcionando.
+
+  **Tu archivo actual no cambia de conducta**: sin `status` sigue frenando, que es lo que corresponde
+  —abrirlo al actualizar sería destrabar una compuerta en silencio—. Agregale la línea cuando quieras
+  resolverlo sin perderlo; los que escriba `autobuild` de acá en más ya vienen con ella.
+
+- **`check` rechaza una fila de `HUMAN_ACTIONS.md` que nombra a su tarea sin ser su slug.** El motor
+  bloquea por esa primera columna **exacta**, así que `| **alta-de-cliente: falta el token** | pendiente |`
+  se escribía sin error, salía en `ops context` bajo `HUMAN` como si estuviera registrada, y la tarea se
+  seguía ofreciendo. Es la forma que sale natural, porque esa tabla la lee una persona; en la instancia
+  donde se midió, **once filas pendientes bloqueaban cero tareas** y la corrida siguiente volvía a elegir
+  lo mismo y a pagar la misma fase.
+
+  Si te aparece, el mensaje dice qué fila y a qué tarea apuntaba: dejá el slug solo en esa celda y contá
+  el resto en la columna de la acción. Las otras dos formas no cambian — el slug exacto sigue bloqueando,
+  y nombrar la épica, el hito o el recorrido sigue siendo válido cuando lo que se frena no es una tarea.
+
+- **Una decisión que `autobuild` deja abierta ya no bloquea la tarea que la encontró.** Esas filas se
+  registran para que la corrida siga —lo que de verdad frena tiene otro camino—, pero la fase que las
+  escribe podía poner en la primera columna el slug de la tarea en construcción y bloquearla. No se veía
+  mientras la corrida vivía, porque un WIP activo manda sobre la acción humana; aparecía al cerrar el WIP.
+
+- **Una corrida de `autobuild` que no puede tomar nada lo dice, en vez de terminar como si la cola
+  estuviera vacía.** Eran dos estados distintos con la misma salida: la cola terminada, y la cola cuyas
+  tareas están todas reclamadas por otro runner o esperando una dependencia. La corrida informaba que no
+  había nada que hacer sobre una cola que sí tenía trabajo.
+
+  Se paga después de una parada que espera una decisión tuya: ahí el reclamo se queda puesto a propósito
+  —quien paró va a volver y su `claim` es idempotente—, así que cuando contestás, **otro** runner pregunta
+  y se va sin nada. Ahora para con `queue-unavailable` y dice cuántas hay; la línea `TAKEN` de
+  `ops context` nombra quién tiene cada una, y se sueltan con `ops release`.
+
+## [0.96.0] - 2026-09-16
+
+### Corregido
+
+- **Tres errores que el CLI contestaba con exit 1 ahora contestan 2, que es lo que dice la convención.**
+  Son «no se llegó a la pregunta»: `integrations/config.json` ilegible, un proveedor que no está en ese
+  registro, y un `package.json` inválido al declarar el motor. Sus hermanos —un `ops.config.json`
+  ilegible, un proveedor que Cauce no trae— ya contestaban 2.
+
+  El corte, que hasta ahora estaba en la cabeza de quien escribía cada salida, está escrito y sale en
+  `ops --help`: **2** es que el comando no existe, falta un argumento, o la raíz que nombrás no es lo que
+  dice ser —lo arreglás cambiando la invocación—; **1** es que se llegó y la respuesta es que no —una
+  validación encontró problemas, el estado se niega, o una operación falló a mitad de camino—.
+
+  Si tenés un script que distingue los dos, revisá esos tres casos. Si sólo mira «distinto de cero», no
+  cambia nada.
+
+- **`ops flow list|check|show` acepta la raíz de la instancia, como el resto.** Todos los comandos que leen
+  una instancia la toman como posicional; `flow` la descartaba y resolvía por el directorio actual, así que
+  `ops flow list <raíz>` contestaba sobre otra cosa — y una lista de recorridos se lee igual de bien venga
+  de donde venga. Ahora es `ops flow list [ops-root]`, y con recorrido va después de él.
+
+- **Una lista de cargos o recorridos vacía dice si es porque no hay o porque no se pudo resolver el
+  paquete.** Eran dos hechos distintos con la misma respuesta, y las acciones son opuestas. El aviso sale
+  por `stderr` y sólo cuando la lista viene vacía; el código de salida y el `--json` no cambian, porque
+  ese JSON lo consume el cron del ciclo de aprendizaje.
+
+- **`automation check` nombra un `ops.config.json` ilegible en vez de culpar al motor.** La resolución del
+  paquete cuelga de esa configuración, así que un JSON roto se propagaba como archivos del motor que faltan
+  y el aviso mandaba a correr `npm install` sobre un motor instalado: la acción sugerida no arreglaba nada.
+
+- **El catálogo de cargos y recorridos se encuentra también cuando el paquete vive un nivel arriba.** Es el
+  layout que documenta el arranque —`npm install @ingeniomaps/cauce` en la carpeta de la empresa y la
+  instancia adentro—, y 0.92.0 lo arregló para el motor y dejó afuera el catálogo. En ese estado `check`
+  pasaba en verde y `agents list` contestaba **una lista vacía con exit 0**, indistinguible de «esta
+  instancia no tiene cargos»; `flow list` igual, y `evaluate` culpaba a un `SKILL.md` que falta, mandando
+  a mirar el cargo en vez del paquete.
+
+  Si te pasó, no hacía falta bajar una segunda copia: con esta versión los cargos aparecen donde ya estaban.
+  Verificado instalando el paquete publicado desde el registro y recorriendo la superficie del CLI: de 0
+  cargos y 0 recorridos a **53 y 7**, sobre la misma instancia.
+
 ## [0.95.0] - 2026-09-16
 
 ### Corregido

package/automatization/workflows/autobuild.js

@@ -60,6 +60,9 @@ const CONTEXT = {
     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, igual que le pasó a `epicContext`: `additionalProperties: false` lo
+    // descarta y las fases lo reciben vacío para siempre.
+    description: { type: 'string' },
     // Sin declararlo acá no llega: `additionalProperties: false` lo descartaría, y el aplanado de la
     // épica a su número —dos líneas arriba— hace fácil creer que ya viene. La fase Plan lo pedía en su
     // prompt y planificaba contra el título; `readEpics` cuenta de dónde sale.
@@ -153,8 +156,29 @@ const DECISION = {
 }
 // Review nombra contra qué reglas revisó (caso 105): recibir las rutas no garantiza abrirlas, y esto es lo único
 // que deja rastro de que se hizo. Critique no lo lleva porque no recibe la lista.
+//
+// Y `decision` es el tercer destino, el que R6 le da a lo que aparece y no le toca a este cargo: queda
+// registrado con qué lo cierra y quién puede tomarlo. Las otras fases lo tienen —`ready-human`,
+// `plan-human`, `verify-human`, y `open-decisions` en Build— y Review no, así que un revisor que
+// encontraba una decisión elegía entre frenar la corrida o degradarla a propuesta con tope de tres.
+// Elegía frenar, que de las dos es la correcta, y costaba la corrida entera sobre trabajo que estaba
+// bien. Es la misma separación que `uncovered` hace en Verify, en el otro extremo del recorrido.
+//
+// Medido sobre un banco desechable el 2026-09-17, corridas `wf_99130468-2c4` y `wf_5dcc3828-a9f`: las dos
+// terminaron en `review-failed` con la suite del producto en verde y los tres casos de la aceptación
+// dando lo pedido, y las dos por un hallazgo que el propio revisor describió como una decisión que no le
+// tocaba.
 const REVIEWED = { ...DECISION, required: [...DECISION.required, 'rules'],
-  properties: { ...DECISION.properties, rules: { type: 'array', items: { type: 'string' } } } }
+  properties: {
+    ...DECISION.properties,
+    rules: { type: 'array', items: { type: 'string' } },
+    // Extiende el concern de `DECISION` en vez de reescribirlo: copiado entero, un campo nuevo allá no
+    // llegaría acá y ninguna prueba lo notaría.
+    concerns: { ...DECISION.properties.concerns,
+      items: { ...DECISION.properties.concerns.items,
+        properties: { ...DECISION.properties.concerns.items.properties, decision: { type: 'boolean' } },
+      } },
+  } }
 // Un exit code dice que el test corrió, no que pruebe lo que la tarea prometió: un test que asercia de
 // menos —o que ni existe— sale verde igual, y el guard de verify tampoco lo ve porque también mira exit
 // codes. Por eso `uncovered` se contrasta contra la aceptación leyendo el fuente, no la salida (R9).
@@ -301,9 +325,19 @@ const VERDICT = ' Cerrá con verdict=aprobado si no queda nada por corregir ante
   'alcance—. Marcá blocking=true sólo en el hallazgo que impide entregar: el resto queda registrado y no ' +
   'manda a tocar código.'
 // Acompaña a todo prompt con schema REVIEWED.
-const RULED = ' En rules nombrá, por su ruta, cada una de las reglas que rigen contra la que revisaste el diff.'
+const RULED = ' En rules nombrá, por su ruta, cada una de las reglas que rigen contra la que revisaste'
+  + ' el diff. Y marcá decision=true en el hallazgo que no te toca resolver a vos —una definición de'
+  + ' producto, un contrato público, una autoridad que el cargo no tiene—: ése se registra para una'
+  + ' persona 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)
+// Una decisión no cuenta como bloqueante aunque venga marcada: su destino es la fila, no la corrección.
+// Critique no la emite —no está en su esquema— así que para él `one.decision` es siempre `undefined`.
+const blockers = (verdict) => verdict.concerns
+  .filter((one) => one.blocking && !one.decision).map((one) => one.detail)
+// Lo que una parada tiene que nombrar es todo lo que el revisor señaló, no sólo lo que manda a corregir:
+// con `blockers` solo, un veredicto cuyo único hallazgo es una decisión paraba diciendo que nadie nombró
+// ninguna condición. El motivo es lo único que queda para leer cuando la corrida terminó.
+const named = (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
@@ -423,7 +457,8 @@ const readContext = () => read(
   `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 ` +
+  `epic, cast y description de task, epicContext de epic.context —vacío si no hay épica— e inbox tal `
+  + `cual. El comando es ` +
   `la fuente de ` +
   `verdad: no abras archivos de planning para completarlo. Poné readOk en true sólo si el comando salió ` +
   `con código 0 y devolvió JSON; si falló, readOk en false y el resto en sus valores vacíos, sin ` +
@@ -485,10 +520,31 @@ while (rounds++ < MAX_TASKS) {
   //
   // `context` nombra la que sigue, igual que nombra una recurrencia vencida y por el mismo motivo: la
   // máquina calcula y la persona encola.
+  // Una cola con trabajo y sin tarea disponible no es una cola terminada. Romper el bucle igual deja la
+  // corrida informando que no había nada que hacer sobre una cola que sí tiene tareas —reclamadas por otro
+  // runner, o esperando una dependencia—, que es la forma del caso 075: una respuesta vacía que se lee
+  // como un hecho del dominio. El dato ya venía: `queued` cuenta la cola entera, y `context` además la
+  // nombra con su dueño en la línea TAKEN.
+  //
+  // Se paga sobre todo después de una parada que espera a una persona: ahí el reclamo se queda puesto a
+  // propósito —quien paró va a volver, y `claim` le es idempotente—, así que cuando la persona contesta es
+  // un runner distinto el que pregunta y el que se va sin nada.
+  if (!planning.hasTask && planning.queued > 0) {
+    return stop('queue-unavailable', `la cola tiene ${planning.queued} tarea(s) y ninguna disponible para `
+      + 'este runner. Mirá la línea TAKEN de "ops context": lo reclamado por otro se suelta con '
+      + '"ops release" o se retoma desde el runner que lo tiene; lo que espera una dependencia, no.')
+  }
   if (!planning.hasTask || (currentMilestone && planning.hito !== currentMilestone)) break
+  // Las decisiones que la línea ya tomó, dichas como lo que son. Sin ese rótulo se leen como contexto
+  // opinable y el que planifica las re-decide igual, que es el defecto entero: la crítica abre el
+  // BACKLOG por su cuenta y bloquea el plan citando la línea palabra por palabra (caso 177).
+  const DECIDED = () => (task.description
+    ? ` Lo que la línea de la tarea ya decidió, y no se re-decide acá: ${task.description}`
+    : '')
   const task = {
     id: planning.slug, hito: planning.hito, service: planning.service,
     acceptance: planning.acceptance, epic: planning.epic, epicContext: planning.epicContext || '',
+    description: planning.description || '',
   }
   // Reservar antes de construir, y antes de fijar el hito de la corrida. Sin esto dos corridas en
   // paralelo trabajan la misma tarea: `context` sólo puede saltear lo que alguien ya reclamó, y el
@@ -614,12 +670,32 @@ 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.
+  // Una parada que registra la fila **bloquea** la tarea: la fila pendiente la saca de la cola. Si además
+  // el reclamo se queda puesto, el runner queda ocupado por algo que nadie puede tomar, y la corrida
+  // siguiente —que hace bien en no reintentarla— muere reclamando la que sigue: `claim` le contesta «este
+  // runner ya tiene …». Es la forma del 163 por la otra puerta, y la diferencia es que el estado lo creó
+  // esta corrida, así que soltarlo también le toca (caso 176).
+  //
+  // Sólo las paradas de **antes** de construir. Las de después —`verify-regression`, `qa-failed`,
+  // `commit-failed`— dejan el WIP en disco y es resumible: ahí el reclamo es lo único que dice de quién es
+  // ese trabajo, y soltarlo lo abandonaría.
+  //
+  // Cuesta un agente, porque el recorrido no tiene con qué correr un comando. Un agente contra una
+  // corrida entera.
+  const releaseBlocked = async () => write(
+    `Corré "node tools/ops.js release ${P} ${task.id}" desde ${ROOT}: quedó bloqueada por la fila que `
+    + 'acabás de registrar y todavía no hay nada construido, así que su reserva no reserva trabajo. No '
+    + 'escribas ningún archivo vos: lo escribe el comando.',
+    { label: `release:${task.id}` },
+  )
+
   const planRejected = async (reason, unit, found) => {
     const detail = found.join('; ') || 'sin condiciones nombradas'
     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, o dejarla entera con la razón escrita.`, 'plan-human')
+    await releaseBlocked()
     return stop(reason, `${detail}${nota}`)
   }
 
@@ -628,7 +704,8 @@ while (rounds++ < MAX_TASKS) {
       phase('Ready')
       const ready = await read(
         `${asRole(OWNERS.ready)}Revisá que ${task.id} tenga aceptación concreta, dependencias resueltas y ` +
-        `ninguna decisión pendiente: ${task.acceptance}. Aclará la redacción y nada más; nunca amplíes el ` +
+        `ninguna decisión pendiente: ${task.acceptance}.${DECIDED()} Aclará la redacción y nada más; ` +
+        `nunca amplíes el ` +
         `alcance.`,
         { schema: READY, label: 'ready' },
       )
@@ -637,6 +714,7 @@ while (rounds++ < MAX_TASKS) {
         const nota = await registerHuman(
           `Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
           'ready-human')
+        await releaseBlocked()
         return stop('not-ready', `${ready.reason}${nota}`)
       }
       if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
@@ -703,7 +781,8 @@ while (rounds++ < MAX_TASKS) {
       `vecinas y el git status de ${task.id}.` +
       `${task.epicContext ? ` Contexto de la épica: ${task.epicContext}` : ''}` +
       ` Producí el plan más chico que satisfaga ` +
-      `${task.acceptance}. Un archivo de planning no puede ser un archivo de implementación. El plan cubre ` +
+      `${task.acceptance}.${DECIDED()} Un archivo de planning no puede ser un archivo de implementación. ` +
+      `El plan cubre ` +
       `sólo el cambio dentro de ${task.service}: correr los gates del repositorio, hacer QA, commitear y ` +
       `cerrar la tarea son fases posteriores de este recorrido, cada una con su dueño, así que no van como ` +
       `pasos.`,
@@ -714,7 +793,7 @@ while (rounds++ < MAX_TASKS) {
       phase('Critique')
       let critique = await read(
         `Atacá este plan por correctitud, alcance, seguridad, pruebas y conflictos con el código ` +
-        `existente.${MANIFEST}${VERDICT} Plan: ${JSON.stringify(plan)}`,
+        `existente.${DECIDED()}${MANIFEST}${VERDICT} Plan: ${JSON.stringify(plan)}`,
         { schema: DECISION, label: 'critique' },
       )
       if (!critique) return stop('agent-unavailable', 'Critique no devolvió resultado')
@@ -729,7 +808,7 @@ while (rounds++ < MAX_TASKS) {
           { schema: PLAN, label: 'replan' },
         )
         critique = await read(
-          `Volvé a criticar el plan corregido contra ${task.acceptance}.${MANIFEST}${VERDICT} ` +
+          `Volvé a criticar el plan corregido contra ${task.acceptance}.${DECIDED()}${MANIFEST}${VERDICT} ` +
           `Plan: ${JSON.stringify(plan)}`,
           { schema: DECISION, label: 'critique' },
         )
@@ -798,7 +877,7 @@ while (rounds++ < MAX_TASKS) {
     `nombrás en test y anotás en redFirst—, kind=open si lo notaste y no impide entregar la aceptación: se ` +
     `registra para que lo decida quien corresponde y el recorrido sigue. Si de verdad no podés entregar sin ` +
     `esa decisión, eso no va en discovered: es completed=false con su blocker. ` +
-    `Aceptación: ${task.acceptance}.`,
+    `Aceptación: ${task.acceptance}.${DECIDED()}`,
     { schema: BUILD, label: 'build' },
   )
   if (!build) return stop('agent-unavailable', 'Build no devolvió resultado')
@@ -819,8 +898,16 @@ while (rounds++ < MAX_TASKS) {
   // tiene camino —`completed: false` con su blocker—; esto se registra y sigue.
   const openDecisions = build.discovered.filter((entry) => entry.kind === 'open')
   if (openDecisions.length) {
+    // Y la fila no puede nombrar a la tarea que la produjo. El motor bloquea por esa primera celda
+    // exacta, así que escribirla ahí registra «esto no impide entregar» y produce el bloqueo igual —lo
+    // contrario de lo que este registro decidió dos líneas arriba—. No se nota mientras la corrida vive,
+    // porque el WIP activo manda sobre la acción humana; aparece cuando el WIP cierra, y entonces la
+    // tarea queda frenada por una pregunta que ya se había resuelto seguir sin contestar. En la corrida
+    // que lo mostró la atrapó Review, tres fases después de escribirla.
     await write(`Registrá en ${HUMAN} una fila por cada decisión que ${task.id} dejó abierta, con qué la ` +
-      `cierra y quién puede tomarla. No inventes responsables ni fechas: ` +
+      `cierra y quién puede tomarla. La primera columna nunca es ${task.id}: el motor bloquea por esa ` +
+      `celda exacta y estas decisiones no impiden entregarla. Va la épica, el hito o el recorrido al que ` +
+      `alcanza la decisión. No inventes responsables ni fechas: ` +
       `${JSON.stringify(openDecisions.map((entry) => entry.detail))}`, { label: 'open-decisions' })
   }
   // Y un caso que sí se fijó acá entra con su prueba o no entró: sin ella el comportamiento nuevo queda
@@ -830,11 +917,25 @@ while (rounds++ < MAX_TASKS) {
   // 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
   // lo que se trata, es el caso que no aparece en ningún rojo.
-  const namesTest = (red, item) => Boolean(item.test)
-    && (red.test.includes(item.test) || item.test.includes(red.test))
+  //
+  // Y la contención sola no alcanza, porque el caso que aparece no es que uno esté contenido en el otro:
+  // los dos nombran el mismo test y cada uno le agrega **su propia** anotación entre paréntesis —dónde
+  // está la línea de un lado, por qué se vio en rojo del otro—. Ahí ninguno contiene al otro y la puerta
+  // frenaba una entrega correcta, que es lo que R26 dice que termina apagándola. Se compara sin esa
+  // anotación final; una que esté en el medio se conserva, porque ahí sí es parte del nombre.
+  const core = (name) => String(name || '').replace(/\s*\([^)]*\)\s*$/, '').trim()
+  const namesTest = (red, item) => Boolean(core(item.test))
+    && (core(red.test).includes(core(item.test)) || core(item.test).includes(core(red.test)))
   const loose = build.discovered.find((entry) => entry.kind === 'edge'
     && !build.redFirst.some((red) => namesTest(red, entry)))
-  if (loose) return stop('edge-unproven', `${loose.detail} entró sin la prueba que lo fija`)
+  // El motivo dice qué comprobó la puerta y no una conclusión sobre el trabajo: pegarle al detalle del
+  // build un «entró sin la prueba que lo fija» producía una parada que se contradecía sola cuando el
+  // detalle contaba que la prueba sí estaba —la frase del agente y la de la puerta hablaban de cosas
+  // distintas y se leían como una—.
+  if (loose) {
+    return stop('edge-unproven', `${loose.detail} — su campo "test" (${loose.test || 'vacío'}) no nombra `
+      + `ninguno de los rojos declarados: ${build.redFirst.map((red) => red.test).join(' | ') || '(ninguno)'}`)
+  }
 
   // Qué revisión hubo, para que el cierre no pueda inventar una. Nace diciendo que no hubo porque
   // `express` no convoca a nadie, y ése es el caso que se escribió como si un cargo hubiera aprobado.
@@ -848,17 +949,35 @@ while (rounds++ < MAX_TASKS) {
       { schema: REVIEWED, label: 'review' },
     )
     if (!review) return stop('agent-unavailable', 'Review no devolvió resultado')
+    // Se junta apenas cada pasada contesta, y no al final: las paradas de abajo salen antes de llegar al
+    // registro, y sin esto lo que el revisor señaló se iba con la corrida.
+    const reviewDecisions = review.concerns.filter((one) => one.decision)
+    let decidedNote = ''
     if (review.verdict === 'bloqueado') {
-      return stop('review-blocked', blockers(review).join('; ') || 'sin condiciones nombradas')
+      return stop('review-blocked', named(review).join('; ') || 'sin condiciones nombradas')
     }
     if (blockers(review).length) {
-      await write(`Corregí sólo estos hallazgos con evidencia y actualizá el WIP: ${blockers(review).join('; ')}`,
+      // «Sólo estos hallazgos» acota el alcance (R6) y por sí solo deja un cabo suelto: una corrección
+      // tiene dependientes y no se anuncian —el conteo que enumeraba lo que cambió, el comentario que
+      // describía la forma vieja, la fila que la afirmaba—. Es R9 leído al derecho: lo que deja de valer
+      // se lleva puesto a quien lo daba por cierto, y eso vive casi siempre en otro archivo.
+      //
+      // Sin pedirlo, la vuelta siguiente rechaza por la deriva que la corrección acabó de crear, y como
+      // la vuelta es una sola eso termina en `review-failed` sobre trabajo correcto. Medido: una
+      // corrección agregó una mutación y un caso de prueba, y la re-revisión frenó porque la fila de
+      // acciones humanas seguía diciendo el número viejo y dos comentarios seguían contando los casos
+      // anteriores —corrida `wf_99130468-2c4`, 2026-09-17, sobre un banco desechable—. Traerlos no
+      // amplía el alcance: es terminar la corrección.
+      await write(`Corregí sólo estos hallazgos con evidencia y actualizá el WIP: ${blockers(review).join('; ')}. `
+        + 'Traé también lo que tu propia corrección deje desactualizado —un conteo, un comentario que '
+        + 'describa la forma vieja, una fila que la enumere— y nada más que eso.',
         { label: 'review-fix' })
       review = await run(`Volvé a revisar el diff corregido de ${task.id}.${MANIFEST}${VERDICT}${RULED}`,
         { schema: REVIEWED, label: 'review' })
       if (!review) return stop('agent-unavailable', 'la re-revisión no devolvió resultado')
+      reviewDecisions.push(...review.concerns.filter((one) => one.decision))
       if (review.verdict === 'bloqueado' || blockers(review).length) {
-        return stop('review-failed', blockers(review).join('; ') || 'sin condiciones nombradas')
+        return stop('review-failed', named(review).join('; ') || 'sin condiciones nombradas')
       }
     }
     // Con reglas que rigen, aprobar sin nombrar contra cuáles es la misma falla que la de abajo en otro eje.
@@ -871,7 +990,30 @@ while (rounds++ < MAX_TASKS) {
     // Contra qué reglas se revisó va también a la entrada de DONE, y no sólo al journal: el journal muere
     // con la corrida y la entrada queda, así que sin esto no había cómo reconstruir contra cuáles se
     // revisó cuando alguien audita la entrega meses después (caso 122).
+    // Lo que la revisión encontró y no le toca resolver va a la fila que una persona lee. No al INBOX, que
+    // es para propuestas: quien lo lea ahí puede promoverlo, y esto no se promueve, se decide.
+    //
+    // Se acumula desde la primera pasada y no se lee sólo de la última: al corrector se le pasa nada más
+    // lo que manda a corregir, así que nunca se entera de la decisión y no la puede cerrar. Leyendo sólo
+    // la re-revisión, una decisión que el agente no repitiera desaparecía sin dejar rastro, y el mismo
+    // camino la perdía entera cuando la revisión paraba antes de llegar acá.
+    //
+    // El tope es el mismo del INBOX y por la misma razón: una revisión que deja treinta filas en una tabla
+    // que lee una persona no está priorizando (caso 101). Lo que no entra queda contado en el hecho.
+    const decided = [...new Set(reviewDecisions.map((one) => one.detail))]
+    const filed = decided.slice(0, INBOX_CAP)
+    if (filed.length) {
+      // La nota que devuelve viaja al hecho: sin ella la entrega afirma una fila que el disco no tiene,
+      // que es el caso 087 entrando por otra puerta.
+      const nota = await registerHuman(`Registrá en ${HUMAN} una fila por cada decisión que la revisión de `
+        + `${task.id} dejó abierta, con qué la cierra y quién puede tomarla. La primera columna nunca es `
+        + `${task.id} —el porqué es el mismo que en Build—: va la épica, el hito o el recorrido al que `
+        + `alcanza. No inventes responsables ni fechas: ${JSON.stringify(filed)}`, 'review-human')
+      decidedNote = `${nota}`
+    }
     reviewFact = `${review.verdict} por ${cast.review}, sobre ${review.consulted.join(', ')}`
+      + (filed.length ? ` · ${filed.length} decisión(es) registrada(s)${decidedNote}` : '')
+      + (decided.length > filed.length ? ` · ${decided.length - filed.length} decisión(es) sin volcar` : '')
       + ((review.rules || []).length ? ` · reglas: ${review.rules.join(', ')}` : '')
     // Lo que no impide entregar no manda a tocar código, y tampoco desaparece: la mejora opinable que se
     // corrige a las apuradas cuesta una vuelta y un riesgo que nadie pidió. Va a Propuestas y no a
@@ -881,7 +1023,10 @@ while (rounds++ < MAX_TASKS) {
     // De qué vía salió cada una: este recorrido, la tarea que la dejó anotada y la fecha del motor. La
     // arma el recorrido, que es el único de los dos que sabe las tres cosas (caso 115).
     const origin = inboxOrigin('autobuild', task.id, planning.today)
-    const noted = review.concerns.filter((one) => !one.blocking).map((one) => withOrigin(one.detail, origin))
+    // Lo marcado como decisión ya tiene destino y no se duplica acá: escrito en los dos lados, además de
+    // aparecer dos veces, le come una ranura del tope a una propuesta que sí lo era.
+    const noted = review.concerns.filter((one) => !one.blocking && !one.decision)
+      .map((one) => withOrigin(one.detail, origin))
     const kept = noted.slice(0, INBOX_CAP)
     // Lo que pasa del tope no se escribe y tampoco desaparece: queda contado en el hecho de revisión, que
     // viaja a `done/`. Una revisión que anota treinta y seis cosas no está priorizando, y el INBOX no las
@@ -1009,9 +1154,14 @@ const closing = await write(
 )
 if (!closing) return stop('agent-unavailable', 'Closing no devolvió resultado')
 if (!closing.passed) return stop('planning-check-failed', closing.details)
+// El archivo nace con su estado escrito porque la compuerta lo lee de ahí —R28, y el porqué vive junto a
+// esa lectura—. Sin decirlo acá la fase escribe prosa sin `status`, y la instancia queda con una compuerta
+// que sólo se destraba borrando: la forma que la regla prohíbe, escrita por el propio recorrido.
 if (completed.length && contract.humanCheckpoint) await write(
   `Creá ${GATE} con el hito terminado, las tareas ${completed.join(', ')}, la evidencia, las acciones humanas ` +
-  `pendientes y las instrucciones exactas para continuar. Nunca hagas push ni deploy.`,
+  `pendientes y las instrucciones exactas para continuar. Arrancá el archivo con un frontmatter ` +
+  `"status: pendiente", y decí que se destraba cambiándolo a "resuelta" —no borrando el archivo, que es ` +
+  `lo que deja leer después qué se revisó—. Nunca hagas push ni deploy.`,
   { label: 'human-checkpoint' },
 )
 return finish({ done: completed, count: completed.length, hito: currentMilestone, phases: ran })

package/automatization/workflows/flow.js

@@ -111,16 +111,30 @@ const STAGE = {
   properties: {
     gate: { type: 'string', enum: ['cumplido', 'con-condiciones', 'no-cumplido'] },
     // La ruta del análisis, no el análisis. Ver el comentario de arriba: mientras el campo pudo
-    // contener el texto entero, lo contuvo, y la respuesta no llegaba.
-    analysis: { type: 'string' }, summary: { type: 'string' },
-    evidence: { type: 'array', items: { type: 'string' } },
-    assumptions: { type: 'array', items: { type: 'string' } },
-    openQuestions: { type: 'array', items: { type: 'object', additionalProperties: false,
+    // contener el texto entero, lo contuvo, y la respuesta no llegaba. Es la única excepción al techo:
+    // una ruta se acota sola.
+    analysis: { type: 'string' },
+    // Y el resto lleva su techo por la misma razón, que el arreglo de `analysis` no alcanzó a cubrir: la
+    // etapa que **frena** escribe largo en `missing` y `humanAction` —lo dice el párrafo de arriba y lo
+    // volvió a mostrar una corrida sobre un banco, con los cinco reintentos envueltos—. Sin tope, cada
+    // campo nuevo nace sin él y lo que revienta es la etapa que menos se ejercita.
+    //
+    // Los números salen de lo que el prompt ya pedía —`summary` en 150 palabras o menos, que es del orden
+    // de mil caracteres— y de R16: entre etapas viaja lo que la siguiente necesita para decidir, no todo
+    // lo que la anterior produjo. Lo que no entra no se pierde: vive en el archivo de análisis.
+    //
+    // Un techo por debajo de lo que el prompt pide no acota: contradice. Medido en una corrida real con
+    // `summary` en 400, el agente achicó en cada reintento —2766, 2078, 2064, 1934, 1854— y murió
+    // convergiendo hacia un número siete veces menor que el que la misma instrucción le pedía escribir.
+    summary: { type: 'string', maxLength: 1000 },
+    evidence: { type: 'array', maxItems: 5, items: { type: 'string', maxLength: 200 } },
+    assumptions: { type: 'array', maxItems: 4, items: { type: 'string', maxLength: 160 } },
+    openQuestions: { type: 'array', maxItems: 4, items: { type: 'object', additionalProperties: false,
       required: ['detail', 'blocking'],
-      properties: { detail: { type: 'string' }, blocking: { type: 'boolean' } },
+      properties: { detail: { type: 'string', maxLength: 200 }, blocking: { type: 'boolean' } },
     } },
-    missing: { type: 'string' },
-    humanAction: { type: 'string' },
+    missing: { type: 'string', maxLength: 500 },
+    humanAction: { type: 'string', maxLength: 500 },
   },
 }
 // Tres salidas porque el contrato del equipo enumera tres —«hacer, no hacer o investigar»— y con un
@@ -281,14 +295,16 @@ const runStage = (stage, index) => {
     `condiciona la decisión siguiente. ` +
     `Escribí primero tu análisis completo en ${REPORTS} como ${stage.id}-analisis.md —ahí no hay ` +
     `límite de extensión y es lo que lee quien sintetiza al final— y devolvé esa ruta en analysis.\n` +
-    `Lo que devolvés en el esquema es corto, todo junto por debajo de 2000 caracteres: si algo no ` +
-    `entra, va al archivo y en el campo queda lo esencial. Vale también para missing y humanAction ` +
-    `cuando el gate no se cumple, que es cuando más se escribe. ` +
+    `Lo que devolvés en el esquema es corto y cada campo tiene su tope, que el esquema rechaza si lo `
+    + `pasás: summary 1000 caracteres, missing y humanAction 500, cada evidencia 200. Si algo no entra, `
+    + `va al archivo y en el campo queda lo esencial. El tope rige sobre todo cuando el gate no se `
+    + `cumple, que es cuando más se escribe. ` +
     `Devolvé los campos directamente: nunca envuelvas la respuesta en {"raw": ..., "len": ...} ni ` +
     `mandes el JSON como string adentro de un campo, porque eso no valida. ` +
-    `En summary va, en 150 ` +
-    `palabras o menos, lo que la etapa siguiente necesita para decidir —no un resumen de tu análisis, ` +
-    `sino lo que le cambia el trabajo—, porque eso se le reenvía a cada etapa posterior.`,
+    `En summary va, en los 1000 caracteres que el esquema admite, lo que la etapa siguiente necesita ` +
+    `para decidir —no un resumen de tu análisis, sino lo que le cambia el trabajo—, porque eso se le ` +
+    `reenvía a cada etapa posterior. El límite va en caracteres y no en palabras porque es lo que el ` +
+    `esquema mide.`,
     { schema: STAGE, label: `stage:${stage.id}` })
 }
 

package/engine/automation/check.js

@@ -22,6 +22,12 @@ const { hasHooks } = require('./config')
 
 function check(root) {
   const errors = []
+  // La configuración se lee primero y se corta ahí. La resolución del paquete cuelga de ella —`declaredRoot`
+  // la parsea— así que un JSON roto se propagaba como archivos del motor que faltan, y el aviso mandaba a
+  // correr `npm install` sobre un motor que está instalado: la acción sugerida no arreglaba nada. Nombrar
+  // la causa y no seguir es lo que separa este aviso del ruido — enumerar ausencias que salen de una causa
+  // ya nombrada manda a arreglar lo que no está roto (caso 174).
+  try { O.mode(root) } catch (error) { return [error.message] }
   const hookDir = path.join(root, 'automatization', 'hooks')
   if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
     errors.push('falta automatization/AGENTS.md')

package/engine/cli/archive.js

@@ -11,7 +11,7 @@ const P = require('../planning/parser')
 const PC = require('../planning/contracts')
 const AD = require('../planning/adoption')
 const F = require('../core/files')
-const { fail, planningRoot, TODAY } = require('./io')
+const { fail, planningRoot, TODAY, USAGE, REFUSED } = require('./io')
 
 // El historial de acciones humanas se acumula en un solo archivo y no por épica: una fila no pertenece
 // a ninguna, y esperar el cierre de una épica dejaría sin archivar las de un planning que todavía no
@@ -30,7 +30,7 @@ function adopt(dir) {
     const existing = fs.readFileSync(target, 'utf8')
     if (!AD.sealWarnings(root).some((one) => /sin huella/.test(one))) {
       fail(`${AD.BASELINE} ya existe: se genera una vez. Para retirar un renglón, ponele \`#~\` `
-        + 'delante; `check` marca los que ya cumplen.')
+        + 'delante; `check` marca los que ya cumplen.', REFUSED)
     }
     const slugs = AD.declared(existing)
     F.atomicWrite(target, existing.replace(/\n?$/, `\n# huella: ${slugs.length} entradas · `
@@ -78,7 +78,7 @@ function archiveHumanActions(root) {
 function archive(dir, rawNum) {
   if (String(rawNum || '') === 'human-actions') return archiveHumanActions(planningRoot(dir))
   return fail('Sólo se archiva `human-actions`. La evidencia de una tarea ya vive en su propio archivo '
-    + 'de `done/`, así que archivar una épica dejó de tener sentido.', 2)
+    + 'de `done/`, así que archivar una épica dejó de tener sentido.', USAGE)
 }
 
 module.exports = { archive, adopt }