@ingeniomaps/cauce 0.96.0 → 0.97.0

package/CHANGELOG.md

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

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/cli/planning.js

@@ -162,11 +162,14 @@ function context(dir, cli) {
   const report = {
     // Toda la cola trabada por una persona no es lo mismo que no tener cola, y decir lo segundo manda a
     // buscar trabajo que no existe en vez de a resolver la fila que lo destraba.
-    blocked: fs.existsSync(gate) ? 'awaiting-review' : (!task && skipped.length ? 'blocked-on-human' : ''),
+    blocked: P.checkpointHolds(root) ? 'awaiting-review' : (!task && skipped.length ? 'blocked-on-human' : ''),
     task: task && {
       slug: task.slug, hito: task.hito, tier: task.tier, cast: task.cast, service: task.service,
       // Una tarea puede heredar su aceptación del criterio citado; el runner necesita el texto, no la cita.
       acceptance: task.acceptance || criteria.map((criterion) => criterion.text).join(' '),
+      // Las decisiones que la línea ya tomó. Viaja con la tarea y no aparte porque es de ella: quien la
+      // reciba tiene que poder leerla al lado de su aceptación, que es contra lo que se contrasta.
+      description: task.description || '',
       epic: task.epic,
     },
     criteria,

package/engine/hooks/shell.js

@@ -45,6 +45,20 @@ const COMANDO = String.raw`$|[;&|)'"\`]`
 // de frenar trabajo legítimo nombraba una violación que no estaba.
 const MISMO = String.raw`[^;&|\n]`
 
+// Si algún remoto alcanza al commit que está en HEAD. Lectura local e inocua: `branch -r` mira lo que ya
+// está en `refs/remotes/`, no habla con ningún servidor. Un `fetch` que nadie corrió deja la respuesta
+// desactualizada hacia el lado seguro — cree que no está publicado algo que sí lo está—, y por eso esto
+// acota un bloqueo y no autoriza nada: lo que decide publicar sigue siendo `push`, que mira otra cosa.
+//
+// Sin git, sin repositorio o con el comando fallando, la respuesta es **sí**: cerrado por defecto (R27).
+// No saber si algo se publicó no es lo mismo que saber que no.
+function publishedHead(input) {
+  const cwd = (input && input.cwd) || process.cwd()
+  const result = spawnSync('git', ['branch', '-r', '--contains', 'HEAD'], { cwd, encoding: 'utf8' })
+  if (result.status !== 0) return true
+  return Boolean(result.stdout.trim())
+}
+
 // Un mensaje de commit es dato, no código. `git commit -m "fix: bloquear git push --force"` disparaba
 // el guard de publicación, y lo mismo `rm -rf /` nombrado en una explicación; con el heredoc que se usa
 // para un mensaje largo, el cuerpo entero entra en el comando, así que la línea que arregla esto no se
@@ -80,13 +94,22 @@ function destructive(input) {
   publish(input, command)
   const rules = [
     [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales.", true],
-    // R8 lo prohíbe sin excepción configurable y ningún guard lo miraba: `grep -rn amend engine/hooks/`
-    // no devolvía una línea. Se bloquea por política y no por daño —un `--amend` sobre algo que nadie vio
-    // no rompe nada—, así que el mensaje manda a lo que sí corresponde: otro commit.
-    [
+    // Lo que R8 protege es la historia que **otro ya leyó**, y el motor ya hace esa distinción para el
+    // push: publicar se autoriza, reescribir lo publicado no. Acá se hace la misma, mirando si algún
+    // remoto alcanza a HEAD.
+    //
+    // Antes se bloqueaba siempre, «por política y no por daño», y eso no impedía el resultado sino el
+    // comando que lo nombra: `git reset --soft HEAD~1` y volver a commitear produce exactamente lo mismo,
+    // no lo frena ningún guard y no deja constancia de nada. Una regla que se cumple mejor esquivándola se
+    // termina esquivando siempre (caso 178).
+    //
+    // Y no lleva salida por chat ni publicado ni sin publicar: sin publicar no la necesita, y publicado es
+    // la misma reescritura que el force-push, que tampoco la tiene.
+    ...(publishedHead(input) ? [[
       new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s--amend\b`),
-      "'git commit --amend' reescribe un commit ya creado. R8 pide uno nuevo en su lugar.",
-    ],
+      "'git commit --amend' sobre un commit ya publicado reescribe historia que otro leyó. R8 lo "
+        + 'prohíbe: hacé otro commit encima.',
+    ]] : []),
     [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento.", true],
     // `git checkout -- .` destruye lo mismo que `reset --hard` y sin recuperación, pero se escribe como
     // una limpieza. Se bloquea sólo la forma ancha —`.`, `*`, `:/`, o sin ruta—: revertir un archivo

package/engine/planning/contracts.js

@@ -383,6 +383,25 @@ function validateState({
     if (!row.valid) {
       errors.push(`HUMAN_ACTIONS ${row.task}: estado "${row.state}" fuera de `
         + `${P.HUMAN_ACTION_STATES.join(' | ')}; mientras no se entienda, la tarea queda bloqueada`)
+      continue
+    }
+    // La primera columna es a la vez lo que una persona lee y la clave con la que el motor bloquea:
+    // la selección de tarea (`state.js`) arma su conjunto de bloqueadas con ella tal cual. Esa doble
+    // función es libre a propósito —el molde manda
+    // nombrar la épica o el recorrido cuando la tarea todavía no existe— así que lo que no se puede
+    // recortar es la libertad, y lo que sí se puede es la forma intermedia: la celda que **menciona** una
+    // tarea de la cola sin ser su slug.
+    //
+    // Es la peor de las tres porque promete un bloqueo que no ocurre, y nada lo dice: la fila se escribe
+    // sin error, sale en `ops context` bajo HUMAN como si estuviera registrada, y la tarea se sigue
+    // ofreciendo. `**slug: de qué se trata**` es la que sale natural, porque esta tabla la lee una
+    // persona. Sin esto la ausencia no deja rastro, que es la forma de R15 aplicada a un mecanismo.
+    if (backlogSlugs.has(row.task)) continue
+    const casi = [...backlogSlugs].find((slug) => new RegExp(`\\b${slug}\\b`).test(row.task))
+    if (casi) {
+      errors.push(`HUMAN_ACTIONS: la fila "${row.task}" nombra a ${casi} y no bloquea nada, porque el `
+        + `motor bloquea por la primera columna exacta. Dejá "${casi}" sola ahí y contá el resto en la `
+        + 'acción, o nombrá la épica o el recorrido si lo que se frena no es esa tarea')
     }
   }
 

package/engine/planning/parser.js

@@ -176,6 +176,10 @@ function readCast(rest) {
 // devolvía `MAX` con `check` en verde, que es la forma cara del error —la tarea se lee completa y no
 // lo está—. Cierra el `_` que markdown cerraría: el que no está entre caracteres de palabra.
 const ACCEPTANCE = /_Aceptaci[oó]n:\s*(.*?\S)_(?![A-Za-z0-9])/i
+// Los paréntesis del contrato de una línea de tarea. Se enumeran por su clave y no como «cualquier
+// paréntesis» para no llevarse puesta una aclaración de la prosa: la descripción usa paréntesis igual
+// que cualquier texto, y el criterio `(→ C1)` va acá porque `criteria` ya lo extrae.
+const MARKERS = /\((?:→|->|criterios?\s|epic:|service:|cast:|depende:|sin partir:)[^)]*\)/gi
 
 // Cuántas condiciones tiene una aceptación escrita en prosa. Estuvo mucho tiempo sin contarse con una
 // razón buena —contar condiciones en una frase es una lectura, y un número inventado es peor que
@@ -207,6 +211,19 @@ function taskFromLine(line) {
     epic: ((rest.match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
     service: ((rest.match(/\(service:\s*([^)]+)\)/) || [])[1] || '').trim(),
     acceptance,
+    // Lo que la aceptación no puede decir y alguien ya decidió: dónde vive un símbolo, qué queda fuera de
+    // alcance, con qué se produce la evidencia. Por contrato la aceptación describe estado observable del
+    // producto, así que una decisión de diseño no cabe ahí — y hasta acá tampoco salía del BACKLOG: el
+    // texto vivía en `rest` y se descartaba.
+    //
+    // Sin ella el que planifica vuelve a decidir lo ya decidido, y decide distinto. La crítica **sí** abre
+    // el BACKLOG y bloquea el plan citando la línea palabra por palabra: una compuerta juzga contra un
+    // texto que la otra no recibió. Dos corridas reales se pagaron enteras para descubrirlo, 1,10 M y
+    // 815 k tokens, la segunda con sus cuatro objeciones diciendo lo mismo (caso 177).
+    //
+    // Se recorta la aceptación y los marcadores del contrato porque cada uno ya tiene su campo: repetirlos
+    // acá los pone dos veces en el prompt de cada fase, que es lo que R16 cobra una vez por etapa.
+    description: rest.replace(ACCEPTANCE, '').replace(MARKERS, '').replace(/\s+/g, ' ').trim(),
     conditions: acceptanceConditions(acceptance),
     criteria: criteriaRefs(rest),
     // De qué otras tareas depende. El orden del BACKLOG alcanzaba mientras hubiera un runner: con dos,
@@ -388,6 +405,23 @@ function readWip(dir, runner) {
   return parseWip(read(path.join(dir, 'wip', `${name}.md`)), name)
 }
 
+// Si el checkpoint de hito sigue frenando, leído del archivo y no de que el archivo esté. Es la misma
+// forma que el WIP de acá arriba —`status: IDLE` es un estado escrito— y la razón es R28: un centinela
+// cuya única información es existir obliga a que el borrado sea parte de la resolución, y esa es una
+// convención que alguien va a olvidar. Cuando se olvida, quien revisa lee que el hito ya se revisó
+// mientras el mecanismo sigue leyendo que el archivo está, y la corrida siguiente muere en la puerta de
+// entrada habiendo cargado el estado entero.
+//
+// Cerrado por defecto (R27): frena salvo que diga `resuelta`. Un archivo de una instancia anterior no
+// trae `status`, y abrirlo por eso destrabaría en silencio al actualizar, que es la quita escrita como
+// agregado que R9 nombra. El vocabulario es el mismo de `HUMAN_ACTIONS.md` a propósito: es el mismo acto
+// —una persona contesta— y dos palabras para eso serían dos convenciones que aprender.
+function checkpointHolds(dir) {
+  const text = read(path.join(dir, 'AWAITING_REVIEW.md'))
+  if (!text) return false
+  return !/^status:\s*resuelta\b/mi.test(text)
+}
+
 // Todos los que hay. Lo pregunta `check`, que juzga si cada plan apunta a una tarea que existe, y `tree`,
 // que muestra qué está en vuelo: las dos son preguntas sobre la instancia y no sobre quien pregunta.
 function readWips(dir) {
@@ -436,6 +470,7 @@ module.exports = {
   EPIC_STATES, HUMAN_ACTION_STATES, LANES, MILESTONE_HEADING, STOP_REASONS,
   TASK_LINE, TASK_LINE_ANY_LANE,
   read, section, withoutComments, frontmatter, readEpics, readBacklog, readDone, readWip, readWips, wipName,
+  checkpointHolds,
   acceptanceConditions, tableRows, taskFromLine,
   readInbox, inboxHeads, readHumanActions,
 }

package/package.json

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

package/template/planning/rules/system/commits.md

@@ -3,7 +3,13 @@
 ## R8 — Un commit por naturaleza
 
 Stagear rutas explícitas, revisar el diff staged y crear un Conventional Commit en inglés. No usar
-`git add .`, `git add -A`, amend, force ni trailers de IA.
+`git add .`, `git add -A`, force ni trailers de IA.
+
+**Y no reescribir historia que otro ya leyó.** Lo que se protege es eso, no el comando: un `--amend`
+sobre un commit publicado es la misma reescritura que un force-push y se frena igual; sobre uno que no
+salió de tu máquina es la corrección, y prohibirlo no impide el resultado —`git reset --soft HEAD~1` y
+volver a commitear produce exactamente lo mismo— sino el comando que lo nombra. Una regla que se cumple
+mejor esquivándola se termina esquivando siempre.
 
 Dónde corta un commit lo decide la naturaleza del diff, no su tamaño ni un conteo. Una tarea suele
 tener una sola, y por eso un commit por tarea es lo habitual; cuando tiene dos, se hacen dos. Un
@@ -90,7 +96,8 @@ Push, PR, merge, tags, deploy y rollback requieren la autorización configurada
 De esos seis, el motor comprueba uno: el push, contra `runner.allowPush` —que no llega a la rama viva
 sin `runner.pushToLiveBranches`, ni a un subagente— o contra la orden que la persona da en el chat
 nombrando el remoto y la rama. Reescribir historia publicada
-no entra en esa autorización y se frena siempre, igual que `--amend`. Los otros cinco no tienen una
+no entra en esa autorización y se frena siempre — también cuando la reescritura es un `--amend`, que el
+guard distingue mirando si algún remoto alcanza al commit. Los otros cinco no tienen una
 forma reconocible en un comando —un deploy es `kubectl`, `terraform`, un script o un botón— y los
 sostiene esta regla y el review, no un guard.