@ingeniomaps/cauce 0.96.0 → 0.98.0

package/agents/roles/system/release-manager/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en Release Management y software delivery para

package/agents/roles/system/sales-representative/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en ventas responsables y procesos comerciales para
@@ -15,4 +15,4 @@ no compres listas, envíes outreach, publiques, hagas commit ni push. Termina co
 `make agent-evaluate AGENT=sales-representative`.
 ```
 
-Programar semanalmente en cada instalación.
+Programar mensualmente en cada instalación.

package/agents/roles/system/security-engineer/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en Security Engineering para mantener
@@ -16,4 +16,4 @@ hagas commit ni push. Termina con
 `make agent-evaluate AGENT=security-engineer`.
 ```
 
-Programar semanalmente en cada instalación.
+Programar mensualmente en cada instalación.

package/agents/roles/system/site-reliability-engineer/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en Site Reliability Engineering para mantener
@@ -15,4 +15,4 @@ no ejecutes carga, caos, failover, publiques, hagas commit ni push. Termina con
 `make agent-evaluate AGENT=site-reliability-engineer`.
 ```
 
-Programar semanalmente en cada instalación.
+Programar mensualmente en cada instalación.

package/agents/roles/system/software-architect/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en Software Architecture para mantener
@@ -15,4 +15,4 @@ no generes migraciones, publiques, hagas commit ni push. Termina con
 `make agent-evaluate AGENT=software-architect`.
 ```
 
-Programar semanalmente en cada instalación.
+Programar mensualmente en cada instalación.

package/agents/roles/system/solutions-engineer/learning/AUTOMATION.md

@@ -1,6 +1,6 @@
 # Automatización de aprendizaje
 
-## Semanal con Codex
+## Mensual con Codex
 
 Ejecutar `make agent-learn AGENT=solutions-engineer`. Completar el informe generado con novedades relevantes, versiones, aplicabilidad, evidencia primaria, impacto y recomendación. Investigar no autoriza cambiar `SKILL.md`, materiales, producto ni sistemas.
 

package/agents/roles/system/tech-lead/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en la práctica de liderazgo técnico —revisión y aprobación
@@ -22,4 +22,4 @@ apruebes, despliegues, hagas commit ni push, y no autorices gasto. Termina con
 `make agent-evaluate AGENT=tech-lead`.
 ```
 
-Programar semanalmente en cada instalación.
+Programar mensualmente en cada instalación.

package/agents/roles/system/technical-program-manager/learning/AUTOMATION.md

@@ -1,6 +1,6 @@
 # Automatización de aprendizaje
 
-## Semanal con Codex
+## Mensual con Codex
 
 Ejecutar `make agent-learn AGENT=technical-program-manager`. Registrar fuentes primarias, estándar/versión/estado, fit organizacional, evidencia de outcome y validación de owners. Investigar no autoriza cambiar planes, compromisos o sistemas.
 

package/agents/roles/system/technical-writer/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en Technical Writing y documentación de software

package/agents/roles/system/treasury-analyst/learning/AUTOMATION.md

@@ -1,4 +1,4 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
 ```text
 Investiga cambios recientes en tesorería corporativa, liquidez y pagos salientes para mantener
@@ -17,4 +17,4 @@ no actualices SKILL.md, código ni planificación; no publiques, hagas commit ni
 con `make agent-evaluate AGENT=treasury-analyst`.
 ```
 
-Programar semanalmente en cada instalación.
+Programar mensualmente en cada instalación.

package/agents/roles/system/ui-designer/learning/AUTOMATION.md

@@ -1,6 +1,6 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
-Configurar una automatización semanal con este prompt:
+Configurar una automatización mensual con este prompt:
 
 ```text
 Investiga cambios recientes en UI Design para mantener agents/roles/system/ui-designer.
@@ -16,4 +16,4 @@ permiso, publiques, hagas commit ni push. Termina ejecutando
 `make agent-evaluate AGENT=ui-designer`.
 ```
 
-La frecuencia recomendada es semanal; cada instalación define el horario.
+La frecuencia recomendada es mensual; cada instalación define el horario.

package/agents/roles/system/user-researcher/learning/AUTOMATION.md

@@ -1,6 +1,6 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
-Configurar una automatización semanal en la raíz del repositorio con este prompt:
+Configurar una automatización mensual en la raíz del repositorio con este prompt:
 
 ```text
 Investiga cambios recientes en User Research para mantener el agente
@@ -19,4 +19,4 @@ contactes participantes, accedas a datos personales, publiques, hagas commit ni
 push. Termina ejecutando `make agent-evaluate AGENT=user-researcher`.
 ```
 
-La frecuencia recomendada es semanal; cada instalación elige día y hora.
+La frecuencia recomendada es mensual; cada instalación elige día y hora.

package/agents/roles/system/ux-designer/learning/AUTOMATION.md

@@ -1,6 +1,6 @@
-# Automatización semanal del aprendizaje
+# Automatización mensual del aprendizaje
 
-Configurar una automatización semanal con este prompt:
+Configurar una automatización mensual con este prompt:
 
 ```text
 Investiga cambios recientes en UX Design para mantener agents/roles/system/ux-designer.
@@ -15,4 +15,4 @@ referencias, evaluaciones, fuentes ni planificación; no publiques, hagas commit
 ni push. Termina con `make agent-evaluate AGENT=ux-designer`.
 ```
 
-La frecuencia recomendada es semanal; cada instalación define el horario.
+La frecuencia recomendada es mensual; cada instalación define el horario.

package/automatization/hooks/README.md

@@ -74,11 +74,12 @@ guards lo leen:
 
 - lo que la persona **pidió nombrándolo** pasa: «leé el `.env`» autoriza leer el `.env`; «no toques el
   `.env`» no, y tampoco una pregunta o un comentario que sólo lo nombra —«¿qué tiene el `.env`?»—;
-- lo que se frenó sin que lo nombrara queda anotado, y un «dale» en el mensaje siguiente aprueba
-  exactamente eso;
+- lo que se frenó sin que lo nombrara queda anotado, y su confirmación en el mensaje siguiente —con las
+  palabras que sea— aprueba exactamente eso. Si ese mensaje niega, frena o pregunta, no aprueba nada; y lo
+  que se frenó mientras ella decía que no, no queda esperando;
 - lo que un guard dejó pasar porque ella lo pidió sigue valiendo mientras dure la sesión, **salvo en los
   gates de un commit** —`governance`, `verify` y `dependencies`—, que preguntan cada vez: ahí vale lo que
-  pidió el mensaje en curso o un «dale», igual que para publicar;
+  pidió el mensaje en curso o su confirmación al bloqueo, igual que para publicar;
 - `plan-first` no aplica: el plan es del trabajo que va por tareas.
 
 No cuenta cuando no hay persona —CI, o un aviso del runner como el de un subagente que terminó—, cuando lo

package/automatization/workflows/agent-propose.js

@@ -1,6 +1,6 @@
 // Convierte la recomendación de los informes en el cambio concreto que una persona puede aprobar.
 //
-// `learn --proposal` consolida qué recomendaron los informes de la semana, pero deja «Cambio
+// `learn --proposal` consolida qué recomendaron los informes de investigación, pero deja «Cambio
 // propuesto: por definir». Eso no es aprobable: nadie firma una intención. Este recorrido escribe el
 // texto exacto que habría que agregar, archivo por archivo, y lo contrasta contra los casos
 // adversariales vigentes antes de proponerlo.
@@ -70,7 +70,7 @@ phase('Proponer')
 
 const proposal = await agent(
   `Sos quien mantiene el cargo ${AGENT}. La propuesta ${context.proposal} consolidó lo que ` +
-  `recomendaron los informes semanales, pero le falta lo único que una persona puede aprobar: el ` +
+  `recomendaron los informes de investigación, pero le falta lo único que una persona puede aprobar: el ` +
   `cambio concreto.\n\n` +
   `Leé los informes citados en su sección «Hallazgos», el SKILL.md del cargo, ` +
   `${context.dir}/learning/sources.yaml, ${context.dir}/evaluations/expected-behaviors.yaml y sus ` +

package/automatization/workflows/autobuild.js

@@ -43,6 +43,13 @@ const GATE = `${P}/AWAITING_REVIEW.md`
 // suelta no es un envoltorio. Por eso también la escapada en vez de alternar el estilo de comillas.
 const QUOTES = ['\'', '"']
 
+// Si la fila que registró una parada quedó pendiente. `context` sólo lista las pendientes, así que
+// preguntar por la presencia de la tarea alcanza, y no hace falta que un modelo lea el estado.
+const HUMAN_ROW = {
+  type: 'object', additionalProperties: false, required: ['readOk', 'pending'],
+  properties: { readOk: { type: 'boolean' }, pending: { type: 'boolean' } },
+}
+
 const CONTEXT = {
   type: 'object', additionalProperties: false,
   required: ['blocked', 'hasTask', 'wipActive', 'queued', 'cast', 'readOk'],
@@ -60,6 +67,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 +163,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 +332,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
@@ -406,13 +447,32 @@ const read = (prompt, options = {}) => agent(`${BASE}\n\n${prompt}`, options)
 const run = (prompt, options = {}) => agent(`${SCOPE()}\n\n${prompt}`, options)
 const write = (prompt, options = {}) => agent(`${LEDGER()}\n\n${prompt}`, options)
 
-// Las tres paradas que dejan una fila en HUMAN_ACTIONS delegan esa escritura a un agente, y esa fila es
-// el único rastro de la parada: sin ella el recorrido informa un estado que el disco no tiene. Por eso
-// se espera —lanzarla y volver en la línea siguiente la abandona— y por eso se mira si contestó.
-// Devuelve lo que hay que agregarle al detalle, vacío cuando la fila quedó pedida. Caso 087.
-const registerHuman = async (prompt, label) => (await write(prompt, { label })
-  ? ''
-  : ` — la fila en ${HUMAN} no se pudo registrar: escribila a mano`)
+// Las paradas que dejan una fila en HUMAN_ACTIONS delegan esa escritura a un agente, y esa fila es el
+// único rastro de la parada: sin ella el recorrido informa un estado que el disco no tiene. Por eso se
+// espera —lanzarla y volver en la línea siguiente la abandona— y por eso se mira si contestó (caso 087).
+// Devuelve lo que hay que agregarle al detalle, vacío cuando la fila quedó como tiene que quedar.
+//
+// Contestar no alcanza: el agente que acaba de escribir el diagnóstico entero lo lee como ya resuelto, y
+// en una corrida real escribió la fila `resuelta` y la firmó como «decidido por el dueño», desbloqueando
+// la tarea sin que nadie decidiera nada (caso 180). Por eso cada pedido arranca diciendo que la fila nace
+// pendiente, y cuando la fila es de la propia tarea se relee en `context`, que sólo lista las pendientes.
+const HUMAN_ROW_STATE = 'La fila nace con estado `pendiente`, sin excepción: registrás el bloqueo, no lo '
+  + 'resolvés —lo resuelve una persona—. No escribas una decisión ni se la atribuyas a nadie.'
+const registerHuman = async (prompt, label, slug = '') => {
+  if (!(await write(`${HUMAN_ROW_STATE}\n\n${prompt}`, { label }))) {
+    return ` — la fila en ${HUMAN} no se pudo registrar: escribila a mano`
+  }
+  if (!slug) return ''
+  const row = await read(
+    `Corré "node tools/ops.js context ${P} --json" desde ${ROOT}. Poné pending en true sólo si humanActions `
+    + `trae una fila cuya task sea ${slug}, y readOk en true sólo si el comando salió con código 0 y devolvió `
+    + 'JSON. El comando es la fuente de verdad: no abras archivos de planning.',
+    { schema: HUMAN_ROW, label: 'human-row' },
+  )
+  if (!row || !row.readOk) return ` — no se pudo comprobar la fila de ${slug} en ${HUMAN}: revisala a mano`
+  return row.pending ? ''
+    : ` — la fila de ${slug} en ${HUMAN} no quedó pendiente: la resuelve una persona, revisala a mano`
+}
 
 // Gate, mutex de WIP y selección de tarea salen de un comando determinista: AWAITING_REVIEW, BACKLOG,
 // WIP y HUMAN_ACTIONS nunca entran al contexto de un modelo, y su tamaño deja de costar tokens.
@@ -423,7 +483,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 +546,35 @@ 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}`
+    : '')
+  // Sobrevive al bloque del plan porque Build vive afuera —y porque una corrida que reanuda desde un WIP
+  // no tiene plan en memoria—. Sin esto la estrategia no era que se descartara: es que no estaba en
+  // alcance, que es la forma que ninguna prueba de la fase ve.
+  let testStrategy = ''
   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 +700,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')
+      + `distintas y partirla, o dejarla entera con la razón escrita.`, 'plan-human', unit.id)
+    await releaseBlocked()
     return stop(reason, `${detail}${nota}`)
   }
 
@@ -628,7 +734,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' },
       )
@@ -636,7 +743,8 @@ while (rounds++ < MAX_TASKS) {
       if (!ready.ready) {
         const nota = await registerHuman(
           `Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
-          'ready-human')
+          'ready-human', task.id)
+        await releaseBlocked()
         return stop('not-ready', `${ready.reason}${nota}`)
       }
       if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
@@ -703,7 +811,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 +823,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 +838,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' },
         )
@@ -742,6 +851,7 @@ while (rounds++ < MAX_TASKS) {
       if (!critique.consulted.length) return stop('critique-unbacked', 'aprobó el plan sin declarar qué inspeccionó')
     }
     }
+    testStrategy = plan.testStrategy || ''
     phase('WIP')
     // Esta llamada escribe un archivo y nada más, y hay que decirlo con todas las letras. En una corrida
     // real hizo el trabajo entero: leyó los pasos del plan como una orden, implementó, corrió RED/GREEN,
@@ -754,7 +864,15 @@ while (rounds++ < MAX_TASKS) {
       `en DONE. Los pasos van sin tildar porque todavía no ocurrieron. task=${task.id}, ` +
       `hito=${JSON.stringify(task.hito)}, phase=Build, service=${task.service}, ` +
       `acceptance=${JSON.stringify(task.acceptance)}, lane=${planning.lane || 'sin clasificar'}, ` +
-      `pasos sin tildar=${JSON.stringify(plan.steps)}. ` +
+      `pasos sin tildar=${JSON.stringify(plan.steps)}, ` +
+      // La estrategia de prueba es `required` en el plan y hasta acá se descartaba, así que un paso que
+      // decía «correr la mutación declarada en testStrategy» apuntaba a un lugar que no existía: quien
+      // revisa no podía distinguir la mutación corrida de la pensada, y la única salida que le quedaba
+      // era rehacer la revisión. R9 pide la mutación **declarada**, y el WIP es donde queda escrita.
+      //
+      // Es la tercera vez que algo decidido no llega a quien decide después: el contexto de la épica
+      // (027), la descripción de la tarea (177) y esto. Las tres se arreglan igual — que viaje.
+      `testStrategy=${JSON.stringify(testStrategy)}. ` +
       `Registrá el reparto de cargos ${JSON.stringify(cast)} en las decisiones del WIP, para que después se ` +
       `pueda auditar quién revisó qué. Seguí el contrato de WIP exactamente y reportá con qué status quedó.`,
       { label: 'wip', schema: {
@@ -798,7 +916,8 @@ 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()}`
+    + (testStrategy ? ` Estrategia de prueba que el plan fijó: ${testStrategy}` : ''),
     { schema: BUILD, label: 'build' },
   )
   if (!build) return stop('agent-unavailable', 'Build no devolvió resultado')
@@ -819,8 +938,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 +957,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 +989,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 +1030,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 +1063,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
@@ -925,7 +1110,7 @@ while (rounds++ < MAX_TASKS) {
   if (ambiguous) {
     const nota = await registerHuman(
       `Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
-      `que aserciar, y hace falta la decisión que lo fija.`, 'verify-human')
+      `que aserciar, y hace falta la decisión que lo fija.`, 'verify-human', task.id)
     return stop('acceptance-ambiguous', `${ambiguous.criterion}${nota}`)
   }
   if (verified.uncovered.length) {
@@ -1009,9 +1194,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 })