@ingeniomaps/cauce 0.74.0 → 0.76.0

package/CHANGELOG.md

@@ -14,6 +14,118 @@ 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.76.0] - 2026-09-10
+
+### Corregido
+
+- **Un comando que no encuentra tu planning lo dice, en vez de contestar un hecho sobre un directorio que
+  no existe.** `context` y `tree` ya lo hacían desde 0.71.0; los otros nueve no. `claim` contestaba «no
+  está en BACKLOG», `release` «no está tomada por nadie», `evidence` «DONE no tiene ninguna entrada»,
+  `runners` «ningún runner tiene trabajo abierto» — todos hechos concretos sobre lo que no pudieron leer.
+  **Cuatro de ellos salían con exit 0**, así que un script veía éxito.
+
+  El daño no es el mensaje sino lo que induce: en una corrida real, `claim` dijo «no está en BACKLOG»
+  sobre una tarea que **sí** estaba, y el recorrido mandó a una persona a promover lo único que ya estaba
+  bien, citando la regla correcta con la conclusión al revés. Ahora los once comandos que reciben un
+  planning fallan igual, con la ruta **resuelta** puesta — que es lo que hace falta cuando el error es de
+  resolución: en sidecar, `<empresa>-ops/planning` escrito desde adentro de la raíz apunta a
+  `<empresa>-ops/<empresa>-ops/planning`.
+
+  **Lo que te pide algo**: si tenías un script que trataba ese vacío como «nada que hacer», ahora falla.
+  Es la misma dirección que 0.63.0 y 0.71.0 ya tomaron. Y `ops check` sobre una ruta que no existe pasa a
+  decir eso en vez de «falta BACKLOG.md»: sale con 2 y nombra la ruta.
+
+### Agregado
+
+- **La entrada declara también `review:`, y `check` cruza los dos.** El carril dice cuánta ceremonia
+  **merecía** la tarea; `review:` dice cuánta **recibió** —el veredicto y quién revisó, o `n/a — razón`
+  cuando no corrió—. Es la dimensión que la propia ADR OPS-006 nombraba como la que falta: «se sabría
+  comparando hallazgos de review por carril, y hoy no se registra esa dimensión en DONE».
+
+  Con los dos campos, `check` avisa lo que hasta ahora no tenía cómo ver: una entrada cuyo carril convoca
+  revisor —`directo`, `lite`, `full`— y cuya revisión no corrió. `express` queda afuera porque es el único
+  que legítimamente no convoca a nadie. Avisa y no falla: es un hecho del pasado que no se arregla
+  editando la entrada, y el único camino al verde sería reescribir el registro.
+
+- **La entrada de una tarea cerrada declara `lane:`, el carril con el que corrió.** El carril decide qué
+  fases recibe una tarea —`express` se saltea Ready, Plan y QA; `full` las corre todas— y viajaba sólo en
+  la línea del BACKLOG, que **se borra al cerrar**. Con eso, «¿esta tarea recibió la ceremonia que su
+  superficie pedía?» dejaba de tener dónde contestarse: en una instancia real, **0 de 79 entradas de DONE
+  registraban el carril**. Ahora queda en el registro, y `sin clasificar` es un valor y no un hueco — dice
+  que la línea no lo declaraba, que es distinto de que nadie llenara el campo.
+
+  El plan en vuelo también lo lleva: una corrida que se reanuda arma la tarea desde `wip/<runner>.md`, y
+  sin el campo ahí llegaba al cierre con el carril ya perdido aunque la tarea sí lo tuviera.
+
+  **Lo que te pide algo**: `ops check` **avisa** cuántas entradas no lo traen y **no falla** — las
+  escritas antes de esta versión no lo tienen y no hay de dónde sacárselo. Lo que sí falla es un valor
+  inventado. Si cerrás a mano, agregá `lane:` a la entrada; si cerrás con `autobuild`, ya lo escribe.
+
+## [0.75.0] - 2026-09-10
+
+### Cambiado
+
+- **R9 dice ahora que una quita casi nunca se ve como una quita, y que eso no admite excepción.** Se
+  escribe como un agregado —una bandera que se pone, una variable que se exporta— y lo que la delata es
+  la frase que la justifica: «lo agrego **para que** deje de …». Silenciar un aviso, saltear una rama o
+  desarmar una confirmación son quitas, y una quita no se entrega sin su aserción de ausencia vista en
+  rojo devolviendo lo quitado.
+
+  Con un renglón propio para el caso que más se disfraza: **una confirmación que estorba casi siempre
+  está cuidando algo**, y si no sabés qué, eso es el resultado de la medición y no un permiso para
+  seguir. Lo que corresponde es quitarle a la herramienta el motivo de preguntar, no la pregunta.
+
+  **Lo que te pide algo**: es una regla del sistema, así que baja a tu `planning/` en el próximo
+  `upgrade` y aplica a todo cambio, no sólo a los del toolkit.
+
+- **Un punto y coma dentro de la prosa de `tests:` ya no parte la traza.** El `;` es el separador que R8
+  fija y a la vez el signo más común de la prosa española, y ese campo pide las dos cosas: el contrato
+  pide `CN → prueba` y R9 pide decir cómo se vio fallar esa prueba. Una sola traza con prosa se partía en
+  tres y `check` rechazaba el campo entero mandando a revisar la traza, que era lo único que estaba bien
+  — y la salida fácil era acortar la prosa hasta que pasara, o sea empobrecer justo la evidencia.
+
+  Ahora se corta sólo cuando detrás **empieza otra traza**, que es la misma decisión que `commit:` ya
+  tomaba para el sha. Las entradas con varias trazas siguen valiendo igual.
+
+  **Lo que te pide algo**: si tu prosa contiene literalmente `; A → algo`, se va a partir ahí — desde
+  afuera es indistinguible de dos trazas. Es la misma concesión que `commit:` aceptó.
+
+- **Un caso no se cierra sin haberlo probado corriendo.** El `## Cierre` nombra qué se corrió y qué
+  devolvió —la salida, la mutación vista en rojo, el número medido—; «la suite pasa» no cuenta, porque
+  dice que nada de lo que ya había se rompió y no que esto funcione. Vale igual cuando se decide no
+  arreglar: ahí se prueba el dato que sostiene la decisión. La puerta lo comprueba desde esta versión y
+  no hacia atrás, por lo mismo que el contraste rige desde 0.65.0.
+
+### Corregido
+
+- **`autobuild` deja de reintentar un reclamo que no puede salir bien.** Cuando la cola vuelve a ofrecer
+  la misma tarea después de un `claim` fallido, nadie la tomó: el reclamo falló por su cuenta y repetirlo
+  no cambia nada. Antes se repetía hasta agotar el cupo de tareas de la corrida — en una corrida real
+  **28 de 50 agentes** se fueron ahí, sin construir nada y sin que nada lo dijera. Ahora para con
+  `claim-stuck`, y el motivo lleva el slug que la cola ofreció y lo que contestó el reclamo. Perder la
+  carrera de verdad sigue sin frenar: ahí la cola pasa a ofrecer otra tarea, y ahora la corrida dice con
+  cuál sigue. Lo mismo en Decompose: si tras pedir la partición la cola sigue ofreciendo la tarea sin
+  partir, la escritura no ocurrió y para con `split-not-applied`.
+
+- **El registro de una corrida dice qué hace cada agente.** Las llamadas sin nombre se veían como el
+  arranque del preámbulo compartido, que es igual en todas: la misma cadena repetida treinta veces, y un
+  bucle de veintiocho agentes indistinguible de trabajo. Las veintisiete llamadas del recorrido llevan
+  etiqueta propia.
+
+- **Un gate ya no puede borrar el `node_modules` de tu proyecto, y se revierte el `CI=true` de 0.74.0.**
+  Esa variable resolvía el síntoma del caso anterior —pnpm dejaba de preguntar antes de purgar—
+  desarmando la confirmación en vez de quitarle el motivo. Y esa confirmación era lo único que protegía
+  al árbol enlazado: sin ella la reinstalación avanza y **borra por el enlace**. Medido: `require()`
+  dejaba de encontrar las dependencias del proyecto, y la instalación ni siquiera necesita completarse
+  para hacerlo — en la corrida medida abortó por `frozen-lockfile` y para entonces ya había borrado.
+
+  Ahora la copia lleva `verify-deps-before-run=false`, que le dice a pnpm que no sincronice nada antes de
+  correr el script. No hay purga que confirmar, así que no hay confirmación que desarmar.
+
+  **Lo que te pide algo**: si tenías un gate que se portaba distinto bajo `CI`, deja de verla. Vuelven el
+  color y los prompts de otras herramientas — y un prompt en un proceso sin terminal aborta, que es la
+  barrera que se quiere de vuelta.
+
 ## [0.74.0] - 2026-09-10
 
 ### Corregido

package/automatization/workflows/autobuild.js

@@ -332,6 +332,14 @@ const LEDGER = `${SCOPE}\n\nContratos de planning, textuales de ${P}/PROTOCOL.md
 // con un TypeError en la fase que sea, y lo que quedó a medias es una tarea con WIP escrito y código
 // sin revisar. Cada llamada corta con su etapa puesta: «no contestó» no es lo mismo que «dijo que no»,
 // y sólo la segunda significa que alguien juzgó algo.
+//
+// Y cada llamada lleva su `label`. Sin él el runtime muestra el arranque del prompt, que acá es el
+// preámbulo compartido: en cinco corridas reales el journal repitió treinta veces la misma cadena
+// —«Nunca inventes credenciales ni decisiones; registrá »— y un bucle de veintiocho agentes pidiendo
+// la misma tarea se vio igual que trabajo. Al revés que `phase`, esto no se puede envolver: el nombre
+// de la fase no alcanza —Critique planifica y critica, Review revisa y manda a corregir— y esa es
+// justo la distinción que hace falta. Lo que evita el olvido es el arnés, que rechaza la llamada sin
+// etiqueta en las cuatro suites del recorrido.
 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)
@@ -365,6 +373,9 @@ const completed = []
 // para siempre. Se corta con motivo porque agotarlo en silencio se lee igual que haber terminado.
 const MAX_TASKS = 50
 let rounds = 0
+// Lo dicen las dos vueltas que cambian de tarea a mitad de corrida —la carrera perdida y la partición—,
+// que no son errores y por eso no salen por `stop`.
+const nextUp = (state) => (state.hasTask ? state.slug : '(nada más en cola)')
 // Tareas que ya pasaron por el clasificador en esta corrida. Sin esto, una que vuelve sin lane
 // —porque la escritura falló o el modelo la salteó— se reclasifica en cada vuelta del bucle.
 const classified = new Set()
@@ -400,6 +411,28 @@ while (rounds++ < MAX_TASKS) {
     if (!reserva || !reserva.claimed) {
       planning = await readContext()
       if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
+      // Perder la carrera es legítimo y se ve en que la cola pasa a ofrecer **otra** tarea: quien la
+      // tomó ya la reclamó, así que `context` la saltea. Que vuelva a ofrecer la misma significa lo
+      // contrario — que nadie la tiene y el reclamo falló por su cuenta—, y eso no mejora repitiendo.
+      //
+      // Reintentar igual costó 28 de los 50 agentes de una corrida real, trece sobre un slug y quince
+      // sobre otro, sin construir nada y sin que nada lo dijera: el único tope es `MAX_TASKS`, así que
+      // el presupuesto de reintentos **es** el de tareas y una tarea irreclamable se lleva la corrida
+      // (caso 071).
+      //
+      // La parada nombra las dos cosas que hacen falta para saber cuál de los dos defectos fue: el slug
+      // que `context` entregó y lo que el reclamo contestó. Si el mensaje dice que ese slug no está en
+      // BACKLOG, los dos comandos discrepan sobre la misma cola; si dice otra cosa, el comando se compuso
+      // distinto del que se pidió.
+      if (planning.hasTask && planning.slug === task.id && !planning.claimed) {
+        return stop('claim-stuck', `${task.id} sigue siendo la próxima tarea y no se pudo reclamar. `
+          + `context la ofrece y claim la rechaza, así que repetir no cambia nada. `
+          + `El reclamo contestó: ${(reserva && reserva.details) || '(sin detalle)'}`)
+      }
+      // Con qué sigue, que es lo que cambia respecto de lo que esperaba quien autorizó la corrida: se
+      // pidió un hito y se va a construir otra tarea de ese hito. Sin decirlo, el cambio sólo aparece al
+      // final, en un cierre que nombra algo que nadie mandó a hacer.
+      log(`${task.id} la tomó otro: la corrida sigue con ${nextUp(planning)}`)
       continue
     }
   }
@@ -424,7 +457,7 @@ while (rounds++ < MAX_TASKS) {
       `corchetes después del slug y el reparto al final de la línea, con la forma ` +
       `"(cast: quien-entrega → quien-revisa, otro)". No toques nada más de la línea, ni el orden del hito, ` +
       `ni las tareas que ya declaran las dos cosas. Reportá lo que escribiste.`,
-      { schema: CLASSIFICATION },
+      { schema: CLASSIFICATION, label: 'classify' },
     )
     if (classification && classification.classified.length) {
       log(`Clasificadas: ${classification.classified
@@ -479,11 +512,12 @@ while (rounds++ < MAX_TASKS) {
         `${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 ` +
         `alcance.`,
-        { schema: READY },
+        { schema: READY, label: 'ready' },
       )
       if (!ready) return stop('agent-unavailable', 'Ready no devolvió resultado')
       if (!ready.ready) {
-        await write(`Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`)
+        await write(`Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
+          { label: 'ready-human' })
         return stop('not-ready', ready.reason)
       }
       if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
@@ -493,14 +527,22 @@ while (rounds++ < MAX_TASKS) {
       phase('Decompose')
       const estimate = await run(
         `Inspeccioná ${task.service} y estimá ${task.id}. Partila sólo si supera ${contract.maxTaskHours} horas.`,
-        { schema: ESTIMATE },
+        { schema: ESTIMATE, label: 'estimate' },
       )
       if (!estimate) return stop('agent-unavailable', 'Decompose no devolvió resultado')
       if (estimate.needsSplit) {
         await write(`Reemplazá sólo ${task.id} en ${BACKLOG} por subtareas ordenadas y verificables de forma ` +
-          `independiente: ${JSON.stringify(estimate.subtasks)}.`)
+          `independiente: ${JSON.stringify(estimate.subtasks)}.`, { label: 'split' })
         planning = await readContext()
         if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
+        // Misma forma que en Claim: si la cola sigue ofreciendo lo mismo, el estado no cambió y repetir
+        // no lo va a cambiar. Acá lo que no cambió es una escritura que se le pidió a un agente, y darla
+        // por hecha manda al bucle a partir la misma tarea otra vez.
+        if (planning.hasTask && planning.slug === task.id) {
+          return stop('split-not-applied', `se pidió reemplazar ${task.id} en ${BACKLOG} por sus `
+            + 'subtareas y la cola sigue ofreciéndola: la escritura no ocurrió como se pidió.')
+        }
+        log(`${task.id} quedó partida: la corrida sigue con ${nextUp(planning)}`)
         continue
       }
     }
@@ -519,7 +561,7 @@ while (rounds++ < MAX_TASKS) {
       `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.`,
-      { schema: PLAN },
+      { schema: PLAN, label: 'plan' },
     )
     if (!plan) return stop('agent-unavailable', 'Plan no devolvió resultado')
     if (!lite) {
@@ -527,7 +569,7 @@ while (rounds++ < MAX_TASKS) {
       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)}`,
-        { schema: DECISION },
+        { schema: DECISION, label: 'critique' },
       )
       if (!critique) return stop('agent-unavailable', 'Critique no devolvió resultado')
       // Un plan bloqueado no se corrige: lo que lo bloquea está fuera de lo que una segunda pasada puede
@@ -538,12 +580,12 @@ while (rounds++ < MAX_TASKS) {
       if (blockers(critique).length) {
         plan = await read(
           `Corregí el plan una vez por: ${blockers(critique).join('; ')}. Plan: ${JSON.stringify(plan)}`,
-          { schema: PLAN },
+          { schema: PLAN, label: 'replan' },
         )
         critique = await read(
           `Volvé a criticar el plan corregido contra ${task.acceptance}.${MANIFEST}${VERDICT} ` +
           `Plan: ${JSON.stringify(plan)}`,
-          { schema: DECISION },
+          { schema: DECISION, label: 'critique' },
         )
         if (!plan || !critique) return stop('agent-unavailable', 'la revisión del plan no devolvió resultado')
         if (critique.verdict === 'bloqueado' || blockers(critique).length) {
@@ -565,10 +607,11 @@ while (rounds++ < MAX_TASKS) {
       `Escribí el WIP y nada más: no toques código, no corras pruebas, no cierres la tarea y no escribas ` +
       `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)}, pasos sin tildar=${JSON.stringify(plan.steps)}. ` +
+      `acceptance=${JSON.stringify(task.acceptance)}, lane=${planning.lane || 'sin clasificar'}, ` +
+      `pasos sin tildar=${JSON.stringify(plan.steps)}. ` +
       `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ó.`,
-      { schema: {
+      { label: 'wip', schema: {
         type: 'object', additionalProperties: false, required: ['wipActive'],
         properties: { wipActive: { type: 'boolean' }, note: { type: 'string' } },
       } },
@@ -593,7 +636,7 @@ while (rounds++ < MAX_TASKS) {
     `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}.`,
-    { schema: BUILD },
+    { schema: BUILD, label: 'build' },
   )
   if (!build) return stop('agent-unavailable', 'Build no devolvió resultado')
   if (!build.completed) return stop('build-blocked', (build.blockers || []).join('; ') || build.summary)
@@ -615,7 +658,7 @@ while (rounds++ < MAX_TASKS) {
   if (openDecisions.length) {
     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: ` +
-      `${JSON.stringify(openDecisions.map((entry) => entry.detail))}`)
+      `${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
   // sin nada que lo sostenga, y nadie sabe después que debía existir.
@@ -639,16 +682,17 @@ while (rounds++ < MAX_TASKS) {
       `${asRole(cast.review)}Revisá el diff real por aceptación, regresiones, seguridad, arquitectura, código ` +
       `generado, migraciones y alcance accidental. Cada cargo revisa su dominio, no el ajeno.${MANIFEST}` +
       `${VERDICT}`,
-      { schema: DECISION },
+      { schema: DECISION, label: 'review' },
     )
     if (!review) return stop('agent-unavailable', 'Review no devolvió resultado')
     if (review.verdict === 'bloqueado') {
       return stop('review-blocked', blockers(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('; ')}`)
+      await write(`Corregí sólo estos hallazgos con evidencia y actualizá el WIP: ${blockers(review).join('; ')}`,
+        { label: 'review-fix' })
       review = await run(`Volvé a revisar el diff corregido de ${task.id}.${MANIFEST}${VERDICT}`,
-        { schema: DECISION })
+        { schema: DECISION, label: 'review' })
       if (!review) return stop('agent-unavailable', 'la re-revisión no devolvió resultado')
       if (review.verdict === 'bloqueado' || blockers(review).length) {
         return stop('review-failed', blockers(review).join('; ') || 'sin condiciones nombradas')
@@ -664,7 +708,7 @@ while (rounds++ < MAX_TASKS) {
     const noted = review.concerns.filter((one) => !one.blocking).map((one) => one.detail)
     if (noted.length) {
       await write(`Registrá en la sección Propuestas de ${P}/INBOX.md lo que la revisión de ${task.id} dejó ` +
-        `anotado sin frenar la entrega, sin promover ninguna: ${JSON.stringify(noted)}`)
+        `anotado sin frenar la entrega, sin promover ninguna: ${JSON.stringify(noted)}`, { label: 'review-noted' })
     }
   }
 
@@ -687,7 +731,7 @@ while (rounds++ < MAX_TASKS) {
     `passed=true exige comandos corridos y ninguna regresión causada por la tarea. Marcá ranTests en el ` +
     `comando que haya corrido las pruebas, sea cual sea su nombre. ` +
     `Aceptación: ${task.acceptance}.`
-  let verified = await run(VERIFY_ASK, { schema: VERIFY })
+  let verified = await run(VERIFY_ASK, { schema: VERIFY, label: 'verify' })
   if (!verified) return stop('agent-unavailable', 'Verify no devolvió resultado')
   // Un criterio que nadie sabe cómo aserciar no es trabajo que falta sino una definición que falta, y
   // definirla acá sería inventarla. Escribir la prueba que falta, en cambio, es trabajo del recorrido:
@@ -695,13 +739,14 @@ while (rounds++ < MAX_TASKS) {
   const ambiguous = verified.uncovered.find((entry) => entry.cause === 'ambiguous')
   if (ambiguous) {
     await write(`Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
-      `que aserciar, y hace falta la decisión que lo fija.`)
+      `que aserciar, y hace falta la decisión que lo fija.`, { label: 'verify-human' })
     return stop('acceptance-ambiguous', ambiguous.criterion)
   }
   if (verified.uncovered.length) {
     await run(`${asRole(cast.build)}Escribí sólo las pruebas que faltan en ${task.id}, con el mismo rojo ` +
-      `previo, y no toques el código de producción: ${verified.uncovered.map((e) => e.criterion).join('; ')}`)
-    verified = await run(VERIFY_ASK, { schema: VERIFY })
+      `previo, y no toques el código de producción: ${verified.uncovered.map((e) => e.criterion).join('; ')}`,
+      { label: 'missing-tests' })
+    verified = await run(VERIFY_ASK, { schema: VERIFY, label: 'verify' })
     if (!verified) return stop('agent-unavailable', 'la segunda pasada de Verify no devolvió resultado')
   }
   if (!verified.passed || !verified.commands.length) return stop('verify-failed', verified.details)
@@ -726,7 +771,7 @@ while (rounds++ < MAX_TASKS) {
         : 'Ejercitá el comportamiento real que ve quien lo usa'} para ` +
       `${task.id}. Las pruebas unitarias solas no son QA. Levantá el mínimo runtime necesario y bajalo ` +
       `después. Aceptación: ${task.acceptance}.`,
-      { schema: QA },
+      { schema: QA, label: 'qa' },
     )
     if (!qa) return stop('agent-unavailable', 'QA no devolvió resultado')
     if (!qa.passed) return stop('qa-failed', qa.evidence)
@@ -738,7 +783,7 @@ while (rounds++ < MAX_TASKS) {
     `stageá por nombre los archivos de la tarea, creá un solo Conventional Commit con el footer ` +
     `"Task: ${task.id}" y después verificá log y status. Nunca amend ni push; reportá lo que quedó suelto ` +
     `y no era de la tarea.`,
-    { schema: COMMIT },
+    { schema: COMMIT, label: 'commit' },
   ) : { committed: true, reason: 'runner.commitPerTask está apagado' }
   if (!commit) return stop('agent-unavailable', 'Commit no devolvió resultado')
   if (!commit.committed) return stop('commit-failed', commit.reason)
@@ -746,13 +791,15 @@ while (rounds++ < MAX_TASKS) {
   phase('Done')
   await write(
     `Cerrá ${task.id} de forma atómica: escribí ${doneFile(task.id)} con su evidencia —acept, ` +
-    `fecha: ${planning.today}, done, qa, tests y commit, en el formato de entrada que trae este preámbulo—; ` +
+    `fecha: ${planning.today}, done, qa, tests, commit, lane y review, en el formato de entrada que trae ` +
+    `este preámbulo—; ` +
     `sacala junto con sus notas indentadas de ${BACKLOG}; cerrá su épica sólo si no queda ` +
     `ninguna tarea etiquetada; dejá ${P}/${planning.wipFile} en status IDLE; y soltá la reserva corriendo ` +
     `"node tools/ops.js release ${P} ${task.id}". En decisions no nombres una fase ni un cargo ` +
     `que no figure en estos hechos. Hechos: lane=${planning.lane || 'sin clasificar'}; ` +
     `review=${reviewFact}; fases=${ran.join(' → ')}; build=${build.summary}; ` +
     `verify=${JSON.stringify(verified.commands)}; qa=${qa.evidence}; commit=${commit.hash || commit.reason}.`,
+    { label: 'done' },
   )
   completed.push(task.id)
   planning = await readContext()
@@ -767,6 +814,7 @@ phase('Closing')
 const closing = await write(
   `Corré "node tools/ops.js check ${P}" desde ${ROOT}. Si sale en rojo, reparás sólo estado derivado ` +
   `determinista; nunca reescribas aceptación ni decisiones para forzar el verde.`, {
+    label: 'closing',
     schema: {
       type: 'object', required: ['passed', 'details'],
       properties: { passed: { type: 'boolean' }, details: { type: 'string' } },
@@ -778,5 +826,6 @@ if (!closing.passed) return stop('planning-check-failed', closing.details)
 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.`,
+  { label: 'human-checkpoint' },
 )
 return finish({ done: completed, count: completed.length, hito: currentMilestone, phases: ran })

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 } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 // La fecha de hoy, la misma que usan los comandos que leen.
 const TODAY = () => new Date().toISOString().slice(0, 10)
@@ -24,7 +24,7 @@ const TODAY = () => new Date().toISOString().slice(0, 10)
 // trabajo de arreglar, y uno que crece a mano deja de ser una lista de perdones para ser una amnistía.
 // Achicarlo sí es a mano, borrando el renglón que `check` señala.
 function adopt(dir) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const target = path.join(root, AD.BASELINE)
   if (fs.existsSync(target)) {
     // Un baseline que ya trae huella no se toca: regenerarlo es exactamente lo que la huella impide.
@@ -79,7 +79,7 @@ function archiveHumanActions(root) {
 // no hace falta: sin esto contestaría «La épica debe ser NNN», que manda a corregir la forma de algo que
 // no existe.
 function archive(dir, rawNum) {
-  if (String(rawNum || '') === 'human-actions') return archiveHumanActions(path.resolve(dir || '.'))
+  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)
 }

package/engine/cli/catalog.js

@@ -66,6 +66,45 @@ function agents(action, dir, extra, cli) {
   }
 }
 
+// Qué decir cuando el banco sobrevivió a su propio borrado, que es lo único que va a permitir
+// establecer la causa. Devuelve el mensaje en vez de escribirlo donde ocurre, y eso es lo que lo hace
+// medible sin provocar el fallo; por qué eso importa acá lo dice su prueba.
+//
+// Tres cosas que el listado anterior no traía, y cada una separa dos diagnósticos distintos:
+//
+// - **Cuánto**, y no una muestra. Cortaba en cinco, así que «borró casi todo y quedaron cuatro objetos»
+//   y «no borró nada» se leían idénticos, y son problemas opuestos.
+// - **Si lo que quedó es anterior al borrado o se escribió durante.** Posterior significa que alguien
+//   reescribió mientras borrábamos; anterior, que el borrado no lo tocó. Es la pregunta central del
+//   caso y la contesta la fecha de modificación.
+// - **Qué hace un segundo borrado.** No lo rodea: quien lo llama corta igual.
+//   Distingue lo transitorio de lo permanente, que se arreglan distinto.
+function benchSurvived(dir, since) {
+  let files = 0
+  let dirs = 0
+  const sample = []
+  const walk = (base, relative = '') => {
+    for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+      const next = relative ? `${relative}/${entry.name}` : entry.name
+      if (entry.isDirectory()) { dirs += 1; walk(path.join(base, entry.name), next); continue }
+      files += 1
+      if (sample.length >= 5) continue
+      const stat = fs.statSync(path.join(base, entry.name), { throwIfNoEntry: false })
+      sample.push(`${next} (${!stat ? 'ya no está'
+        : stat.mtimeMs >= since ? 'escrito durante el borrado' : 'anterior al borrado'})`)
+    }
+  }
+  try { walk(dir) } catch { /* el listado es la explicación, no la comprobación */ }
+  let again = 'no se pudo reintentar'
+  try {
+    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })
+    again = fs.existsSync(dir) ? 'un segundo borrado tampoco lo sacó' : 'un segundo borrado sí lo sacó'
+  } catch (error) { again = `un segundo borrado lanzó ${error.code || error.message}` }
+  return `${dir} no se pudo borrar entero y el banco tiene que ser nuevo. Sobrevivieron ${files} `
+    + `archivo(s) en ${dirs} directorio(s), con Node ${process.version}: `
+    + `${sample.join(', ') || '(sólo directorios)'}. ${again}. Borralo a mano y volvé a correr.`
+}
+
 // Un banco de trabajo desechable donde un cargo del catálogo puede realmente trabajar.
 //
 // Hace falta porque el toolkit no es una raíz ops: el único `planning/` que vive acá es
@@ -96,43 +135,35 @@ function evaluationBench(root, agent, caso, force, kind) {
     fail(`${dir} tiene trabajo sin recoger. Guardá el registro de esa corrida antes de rehacerlo, `
       + 'o usá --force si ya lo tenés.', 2)
   }
-  // Con reintentos: el banco es un árbol grande y versionado —hay un `git status` dos líneas arriba— y
-  // borrarlo entero falla a veces con ENOTEMPTY, que es transitorio. Pasó en CI rehaciendo un banco que
-  // se acababa de crear: `ENOTEMPTY, Directory not empty: .cauce-eval/product-manager/11-otro`. Sin los
-  // reintentos, rehacer un banco es una operación que falla de vez en cuando y deja la corrida sin
-  // empezar.
+  // El instante de arranque, para poder fechar lo que sobreviva: es lo único que separa un archivo que
+  // el borrado no tocó de uno que alguien reescribió mientras borrábamos.
+  const since = Date.now()
+  // Con reintentos. Los puso el `ENOTEMPTY` que aparecía al rehacer un banco recién creado, y hoy se
+  // sabe que eso era el mantenimiento de git escribiendo por detrás —la causa está apagada quince líneas
+  // más abajo, en la creación—. Se quedan porque cubren a cualquier otro escritor transitorio, no porque
+  // sigan tapando éste; sacarlos es una decisión aparte y lo que la activaría es que nunca más disparen.
   fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })
-  // Y se comprueba que haya borrado. `rmSync` puede volver sin lanzar y dejar cosas —pasó en CI y no
-  // está establecido por qué—, y hasta acá cada síntoma se rodeaba por separado: `force` en el
-  // andamiaje, un `rm` antes del enlace. Rodearlo deja la corrida siguiendo sobre un banco que no es
-  // nuevo, y lo que falla después no dice nada del borrado: el test que lo destapó reportaba
-  // `true !== false` sobre un archivo de la corrida anterior, sin nombrar de dónde salía.
+  // Y se comprueba que haya borrado. `rmSync` puede volver sin lanzar y dejar cosas, y hasta acá cada
+  // síntoma se rodeaba por separado: `force` en el andamiaje, un `rm` antes del enlace. Rodearlo deja la
+  // corrida siguiendo sobre un banco que no es nuevo, y lo que falla después no dice nada del borrado: el
+  // test que lo destapó reportaba `true !== false` sobre un archivo de la corrida anterior, sin nombrar
+  // de dónde salía.
+  //
+  // Esta guarda es la que estableció la causa: fue su primer disparo instrumentado el que nombró al
+  // escritor. Se queda igual —lo que cubre ahora es que aparezca otro—.
   //
   // Falla en vez de seguir, porque un banco a medio borrar contamina la medición que viene, que es lo
-  // que la recreación existe para evitar. Y nombra lo que sobrevivió: es lo único que va a permitir
-  // establecer la causa la próxima vez que ocurra.
-  if (fs.existsSync(dir)) {
-    const sobreviven = []
-    const recorrer = (base, relative = '') => {
-      for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
-        if (sobreviven.length >= 5) return
-        const next = relative ? `${relative}/${entry.name}` : entry.name
-        if (entry.isDirectory()) recorrer(path.join(base, entry.name), next)
-        else sobreviven.push(next)
-      }
-    }
-    try { recorrer(dir) } catch { /* el listado es la explicación, no la comprobación */ }
-    fail(`${dir} no se pudo borrar entero y el banco tiene que ser nuevo. Sobrevivieron al borrado: `
-      + `${sobreviven.join(', ') || '(sólo directorios)'}. Borralo a mano y volvé a correr.`, 2)
-  }
+  // que la recreación existe para evitar. Qué trae el mensaje y por qué, en `benchSurvived`.
+  if (fs.existsSync(dir)) fail(benchSurvived(dir, since), 2)
   // Con `force`: el banco es desechable y se acaba de borrar, así que lo que sobreviva al `rmSync` se
   // pisa en vez de cortar la corrida. Sin esto, `copyTemplate` se niega ante cualquier archivo que
   // quede —«El destino contiene …/AGENTS.md»— y el mismo test falló así tres veces en un día, en las
-  // dos patas de la matriz. Por qué algo sobrevive a un borrado que no lanzó no está establecido.
+  // dos patas de la matriz.
   //
   // No ablanda ninguna protección: la pregunta «¿acá alguien trabajó?» la contesta el `git status` de
   // arriba, que exige `--force` explícito para seguir. Esta segunda puerta no la eligió nadie y sólo
-  // se cerraba a veces, que es la clase de freno que enseña a re-correr sin leer.
+  // se cerraba a veces, que es la clase de freno que enseña a re-correr sin leer. Ese «a veces» era el
+  // mismo escritor de fondo; con la causa apagada, esto cubre el residuo.
   IN.scaffold(dir, { name: 'Banco de evaluación', mode: 'sidecar', quiet: true, force: true })
   // El motor por symlink: la misma resolución que en una instancia real —`node_modules/@ingeniomaps`—
   // sin pagar un `npm install` por corrida. El cargo llega a un banco donde el CLI funciona.
@@ -172,6 +203,20 @@ function evaluationBench(root, agent, caso, force, kind) {
   git('init', '-q')
   git('config', 'user.email', 'banco@cauce.local')
   git('config', 'user.name', 'banco de evaluación')
+  // Y se le apaga el mantenimiento automático, que es el escritor de fondo que rompía el borrado del
+  // banco siguiente. `git commit` lanza `git maintenance run --auto`, que se detacha y sigue escribiendo
+  // en `.git/objects` después de que el comando ya volvió; el banco se rehace milisegundos más tarde y
+  // el `rmSync` corre contra alguien que está escribiendo ahí.
+  //
+  // Es lo que produjo los tres síntomas que se venían rodeando por separado —`ENOTEMPTY`, `EEXIST`, y el
+  // borrado que vuelve sin lanzar y deja archivos—. La guarda lo nombró el 2026-09-10:
+  // `maintenance.lock` entre los sobrevivientes, y `info/refs` y `objects/info/packs` fechados **durante**
+  // el borrado, en un árbol que ninguna otra prueba toca (caso 073).
+  //
+  // `maintenance.auto=false` y no `gc.auto=0`: medido con `GIT_TRACE=1`, el segundo deja que el commit
+  // lance el mantenimiento igual —sólo hace que su tarea de `gc` no encuentre trabajo— y el proceso
+  // toma su lock y escribe lo mismo. Se le quita el motivo de lanzarlo, no lo que hace una vez lanzado.
+  git('config', 'maintenance.auto', 'false')
   git('add', '-A')
   git('commit', '-q', '-m', 'banco limpio')
   return dir
@@ -353,4 +398,4 @@ function flow(action, slug, cli) {
   } catch (error) { fail(error.message, 2) }
 }
 
-module.exports = { agents, learn, evaluate, flow }
+module.exports = { agents, learn, evaluate, flow, benchSurvived }

package/engine/cli/claims.js

@@ -9,12 +9,12 @@ const path = require('node:path')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const ST = require('../planning/state')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 const TODAY = () => new Date().toISOString().slice(0, 10)
 
 function claim(dir, slug, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   if (!slug) return fail('Falta el slug. `ops claim <planning-dir> <tarea>`', 2)
   const state = ST.snapshot(root)
   const task = state.milestones.flatMap((milestone) => milestone.tasks).find((one) => one.slug === slug)
@@ -82,7 +82,7 @@ function claim(dir, slug, cli) {
 }
 
 function release(dir, slug) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   if (!slug) return fail('Falta el slug. `ops release <planning-dir> <tarea>`', 2)
   const from = CL.runner()
   const taken = CL.read(root).find((one) => one.slug === slug)
@@ -103,7 +103,7 @@ function release(dir, slug) {
 // La persona elige; el agente exporta. Pedirle a una persona que escriba una variable de entorno para
 // retomar su propio trabajo es hacerle hacer de intérprete.
 function runners(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const done = ST.snapshot(root).done
   const abiertos = CL.read(root).filter((one) => !done.set.has(one.slug))
   const hoy = TODAY()

package/engine/cli/io.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const fs = require('node:fs')
 const path = require('node:path')
 
 // Terminar la corrida con un mensaje y un código. Vive aparte porque lo usa cada familia de comandos, y
@@ -15,4 +16,32 @@ function opsRoot(dir) {
   return path.resolve(dir || process.env.OPS_ROOT || '.')
 }
 
-module.exports = { fail, opsRoot }
+// La raíz de planning de un comando: resuelta **y comprobada**, en un solo lugar. Lo que no se pudo leer
+// no contesta como si se hubiera leído, y eso no puede depender de que cada comando se acuerde: sobre un
+// directorio ausente, `claim` no encuentra el slug, `evidence` no encuentra entradas y `runners` no
+// encuentra runners, y los tres reportan ese vacío como un hecho del dominio.
+//
+// El daño no es el mensaje sino la acción que induce. Medido en una corrida real: `claim` contestó «no
+// está en BACKLOG» sobre una tarea que **sí** estaba, y el recorrido mandó a una persona a promover lo
+// único que ya estaba bien, citando la regla correcta con la conclusión al revés (caso 075). Y cuatro de
+// los ocho comandos que lo hacían salían con **exit 0**, así que un script veía éxito.
+//
+// Va en la resolución y no en cada comando porque es lo que cierra la clase en vez de la instancia: la
+// misma se arregló de a una en `stagedFiles` (0.63.0) y en `context` (0.71.0), y volvió las dos veces.
+//
+// La ruta va **resuelta** y no como se escribió, porque el error que ataca es de resolución: en sidecar
+// `<empresa>-ops/planning` desde adentro de la raíz apunta a `<empresa>-ops/<empresa>-ops/planning`.
+function planningRoot(dir) {
+  const root = path.resolve(dir || '.')
+  if (!fs.existsSync(root)) {
+    return fail(`no existe el planning en ${root} (ruta resuelta). Comprobá desde dónde estás invocando.`, 2)
+  }
+  // Existir no alcanza: un directorio cualquiera contestaría cola vacía igual. `BACKLOG.md` es el archivo
+  // del que sale la cola, así que sin él la respuesta no significa nada.
+  if (!fs.existsSync(path.join(root, 'BACKLOG.md'))) {
+    return fail(`${root} (ruta resuelta) no es un planning: falta BACKLOG.md.`, 2)
+  }
+  return root
+}
+
+module.exports = { fail, opsRoot, planningRoot }

package/engine/cli/planning.js

@@ -23,7 +23,7 @@ const OB = require('../core/onboarding')
 const C = require('../config/validate')
 const CP = require('../config/paths')
 const AG = require('../agents/catalog')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 // Qué dimensiones enumera el molde de `organization/` y cuáles dejaron de estar. Un agente que reescribe
 // esos archivos tiende a quedarse con el contenido y perder la estructura: el resultado se lee entero y
@@ -36,7 +36,7 @@ const { fail } = require('./io')
 // entrada de hace tres meses no tiene con qué cruzarse—. Acá se pregunta por una entrada, que es como
 // se cierra una tarea: se escribe la evidencia y se la mira contra el árbol y contra lo que corrió.
 function evidence(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const opsDir = path.join(root, '..')
   const entries = P.readDone(root).entries
   const slug = cli.value('--task')
@@ -76,7 +76,7 @@ function evidence(dir, cli) {
 const TODAY = () => new Date().toISOString().slice(0, 10)
 
 function check(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const errors = []
   const warnings = []
   // El plan no está: `wip/` es local y gitignoreado, así que un clon nuevo no lo trae y eso no es un
@@ -148,6 +148,7 @@ function check(dir, cli) {
     epics, milestones, done, wips, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
   }))
   warnings.push(...AD.report({ done, epics, adopted }))
+  warnings.push(...PC.doneCeremonyWarnings(done, new Set(adopted)))
   // Sin `RECURRING.md` no dice una palabra: una instancia que actualiza y no declara trabajo recurrente
   // no tiene por qué enterarse de que el contrato existe. Vencida avisa y no frena — lo que frena vive
   // en `HUMAN_ACTIONS.md`, y un aviso que salta siempre se termina apagando.
@@ -265,10 +266,9 @@ function treeJson({ epics, milestones, done, wips, inbox, queued, claims }) {
 }
 
 function tree(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   // Mismo motivo que en `context`, y por eso comparten la comprobación: sin ella un planning ausente
   // dibujaba un árbol vacío, que se lee como un roadmap sin épicas en vez de como una ruta equivocada.
-  assertPlanning(root)
   const state = ST.snapshot(root)
   if (cli.has('--json')) return treeJson(state)
   const { epics, milestones, done, wips, inbox, queued, claims } = state
@@ -307,29 +307,9 @@ function tree(dir, cli) {
   console.log(`${paint('1', 'DONE')}   ${done.entries.length} tareas\n`)
 }
 
-// Lo que no se pudo leer no contesta como si se hubiera leído: la misma regla que `stagedFiles` aplica
-// sobre el índice de git, y que esta familia ya aplicaba al `--hito` inexistente. Faltaba la raíz, y ahí
-// pesa más, porque el consumidor no siempre es una persona: `autobuild` toma la cola vacía como permiso
-// para expandir una épica, así que un error de ruta promovía trabajo en vez de fallar.
-//
-// La ruta va **resuelta** y no como se escribió, porque el error que ataca es de resolución: en sidecar
-// `<empresa>-ops/planning` desde adentro de la raíz apunta a `<empresa>-ops/<empresa>-ops/planning`.
-function assertPlanning(root) {
-  if (!fs.existsSync(root)) {
-    return fail(`no existe el planning en ${root} (ruta resuelta). Comprobá desde dónde estás invocando.`, 2)
-  }
-  // Existir no alcanza: un directorio cualquiera contestaría cola vacía igual. `BACKLOG.md` es el archivo
-  // del que sale la cola, así que sin él la respuesta no significa nada.
-  if (!fs.existsSync(path.join(root, 'BACKLOG.md'))) {
-    return fail(`${root} (ruta resuelta) no es un planning: falta BACKLOG.md.`, 2)
-  }
-  return null
-}
-
 // Contexto mínimo suficiente para ejecutar una tarea, en lugar de releer roadmap, BACKLOG y WIP enteros.
 function context(dir, cli) {
-  const root = path.resolve(dir || '.')
-  assertPlanning(root)
+  const root = planningRoot(dir)
   const state = ST.snapshot(root)
   // Acotar la cola a un hito es como un equipo se reparte trabajo sin coordinarse: dos personas en hitos
   // distintos casi nunca dependen entre sí ni tocan los mismos archivos. Lo que se acota es qué se
@@ -473,7 +453,7 @@ function context(dir, cli) {
 // `BACKLOG.md` es la cola de lo aprobado y la escribe una persona — ningún comando del motor la toca,
 // ni siquiera `integration promote`, que aterriza en el roadmap. Pegarla es el acto de promoción.
 function recurring(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const file = RC.read(root)
   if (!file.exists) return console.log(`= este planning no declara trabajo recurrente (${RC.FILE})`)
   const state = RC.status({ ...file, done: P.readDone(root), today: TODAY() })

package/engine/cli/worktree.js

@@ -15,7 +15,7 @@ const ST = require('../planning/state')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const O = require('../core/ownership')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 const git = (cwd, ...args) => spawnSync('git', args, { cwd, encoding: 'utf8' })
 
@@ -33,7 +33,7 @@ function existing(repo, branch) {
 }
 
 function worktree(dir, slug, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   if (!slug) return fail('Falta el slug. `ops worktree <planning-dir> <tarea>`', 2)
   const state = ST.snapshot(root)
   const task = state.milestones.flatMap((milestone) => milestone.tasks).find((one) => one.slug === slug)

package/engine/hooks/shell.js

@@ -442,17 +442,27 @@ function commitTree(dir) {
   // quien commitea; un proyecto con un gate así tiene que sacar esa escritura del gate.
   const started = run('git', ['init', '--quiet'], temp)
   if (started.ok) run('git', ['add', '--all'], temp)
-  // Un gate no sólo lee su entorno: escribe en él. Lo ignorado se enlaza al original —eso es a
-  // propósito y está arriba—, así que lo que el gate escriba cae en el árbol de quien commitea. Un
-  // gestor de paquetes que se sincroniza antes de correr un script lo lleva al extremo: pnpm 11 ve que
-  // el árbol enlazado no fue instalado acá y su reacción es reinstalar, que empieza borrando el
-  // `node_modules` **del proyecto**. Lo único que hoy lo detiene es que `run` lanza con `stdio: 'pipe'`
-  // y el hijo no ve una terminal (caso 068).
+  // Un gate no sólo lee su entorno: escribe en él. Lo ignorado se enlaza al original —eso es a propósito
+  // y está arriba—, así que lo que el gate escriba cae en el árbol de quien commitea. Un gestor que se
+  // sincroniza antes de correr un script lo lleva al extremo: ve que el árbol enlazado no coincide con
+  // el lockfile de la copia y reinstala, lo que **empieza borrando** el `node_modules` del proyecto.
   //
-  // `CI` es la variable que el propio pnpm nombra para no preguntar, y la que cualquier gate razonable
-  // ya espera. Va sólo acá: por el `return` de arriba los gates corren en el directorio del usuario, y
-  // ahí cambiarle el entorno no tiene ninguna razón.
-  return { root: temp, temp, env: { CI: 'true' } }
+  // Lo que se apaga es esa comprobación previa, que es el motivo por el que quiere tocar nada.
+  // `verify-deps-before-run` la gobierna y tiene tres valores: `install` reinstala solo —el que trae
+  // pnpm 11 y el que hace el daño—, `error` se niega y frena el gate cuando el lockfile de la copia
+  // difiere de lo instalado, que es justo lo que pasa al commitear un cambio de lockfile por partes, y
+  // `false` corre el script sin mirar. La copia no tiene que sincronizar nada: tiene que medir el
+  // código.
+  //
+  // Acá estuvo `CI: 'true'` y fue una regresión (caso 070). Resolvía el síntoma del 068 —pnpm dejaba de
+  // preguntar antes de purgar— desarmando la confirmación en vez de quitarle el motivo, y esa
+  // confirmación era lo único que protegía al `node_modules` del proyecto: sin ella la reinstalación
+  // avanza y borra por el enlace. Además encendía `frozen-lockfile`, que el propio pnpm anuncia al
+  // fallar, así que la variable armaba y desarmaba guardas distintas a la vez.
+  //
+  // La regla que queda: no se desarma la confirmación de una herramienta, se le quita el motivo de
+  // preguntar. Una confirmación que estorba casi siempre está cuidando algo.
+  return { root: temp, temp, env: { npm_config_verify_deps_before_run: 'false' } }
 }
 
 function verify(input) {

package/engine/planning/contracts.js

@@ -9,9 +9,26 @@ const TEST_TRACE = /^(?:n\/a\s*[—-]\s*.+|(?:A|C\d+)\s*(?:→|->)\s*\S.+)$/i
 const DECISION_TRACE = /\[(?:fuente|supuesto):\s*[^\]]+\]/i
 const COMMIT_TRACE = /^(?:n\/a\s*[—-]\s*.+|[0-9a-f]{7,40}\s+\S.*)$/i
 
+// Se corta en `;` sólo cuando detrás **empieza otra traza**. Es la misma decisión que `validCommitTrace`
+// toma unas líneas más abajo para el sha, y por el mismo motivo: el `;` es el separador que R8 fija y a
+// la vez el signo más común de la prosa española, y este campo pide las dos cosas — el contrato pide
+// `CN → prueba` y R9 pide decir cómo se vio fallar esa prueba.
+//
+// Con el corte a secas, una sola traza con prosa se partía en tres y el campo se rechazaba entero: el
+// mensaje mandaba a revisar la traza, que era lo único que estaba bien, y la salida fácil era acortar la
+// prosa hasta que pasara — o sea empobrecer justo la evidencia que R9 exige. Pasó dos veces en dos días
+// en una instancia real (caso 072).
+//
+// Lo comparten `validTestTrace` y `testedCriteria` porque «dónde termina una traza» es una sola decisión
+// y no dos. Con los datos de hoy las dos formas de partir dan el mismo resultado —un `;` que no abre
+// traza no produce un fragmento que empiece por `Cn →`, así que el rastreo no cambia—, y por eso ninguna
+// prueba lo distingue: comprobado con una mutación que hace partir distinto a cada uno y sobrevive. Se
+// comparte igual, para que no se separen el día que una de las dos cambie.
+const TRACE_SPLIT = /\s*;(?=\s*(?:(?:A|C\d+)\s*(?:→|->)|n\/a\s*[—-]))\s*/i
+const splitTraces = (value) => String(value || '').split(TRACE_SPLIT).map((one) => one.trim()).filter(Boolean)
+
 function validTestTrace(value) {
-  return String(value || '').split(/\s*;\s*/).filter(Boolean)
-    .every((item) => TEST_TRACE.test(item))
+  return splitTraces(value).every((item) => TEST_TRACE.test(item))
 }
 
 function validDecisionTrace(value) {
@@ -34,7 +51,7 @@ function validCommitTrace(value) {
 // Los criterios que la evidencia realmente rastrea. `n/a — razón` no rastrea ninguno a propósito: es
 // la salida explícita, y como lleva su razón escrita se lee en el propio DONE sin que nadie la cruce.
 function testedCriteria(value) {
-  return String(value || '').split(/\s*;\s*/).filter(Boolean)
+  return splitTraces(value)
     .map((item) => ((item.match(/^(C\d+)\s*(?:→|->)/i) || [])[1] || '').toUpperCase())
     .filter(Boolean)
 }
@@ -70,6 +87,12 @@ function validateDoneEntry(entry, cited = []) {
 //
 // Los criterios que la historia declaró cubrir los cita el roadmap y no la entrada, así que el cruce
 // sólo existe si la entrada dice de qué épica viene.
+// El vocabulario del carril tal como se escribe en una entrada de DONE: los cuatro de la línea del
+// BACKLOG más el que dice que la línea no lo declaraba. `sin clasificar` no es un hueco disimulado — es
+// el estado que `PROTOCOL.md` ya llama estado y no error, y escribirlo distingue «corrió sin carril» de
+// «nadie escribió el campo», que es justo lo que este campo vino a poder contestar.
+const LANE_VALUES = [...P.LANES, 'sin clasificar']
+
 function doneEntryErrors(entry, epics = []) {
   const at = `${entry.source} ${entry.slug}`
   const errors = []
@@ -80,11 +103,58 @@ function doneEntryErrors(entry, epics = []) {
   if (!entry.done) errors.push(`${at}: falta done:`)
   if (!entry.qa) errors.push(`${at}: falta qa:`)
   if (!entry.commit) errors.push(`${at}: falta commit:`)
+  // El carril con el que la tarea corrió. Ausente **avisa** y no frena, porque toda entrada escrita antes
+  // de que el campo existiera lo está y no hay de dónde sacárselo: exigirlo pondría en rojo el `check` de
+  // cada instancia que actualiza, por algo que nadie puede arreglar. Escrito mal sí frena, porque eso es
+  // un valor que alguien puso y de él depende leer si la ceremonia fue la que correspondía (OPS-006).
+  if (entry.lane && !LANE_VALUES.includes(entry.lane)) {
+    errors.push(`${at}: lane "${entry.lane}" no existe; usá ${LANE_VALUES.join(' | ')}`)
+  }
   const story = epics.find((epic) => epic.num === entry.epic)?.stories
     .find((candidate) => candidate.slug === entry.slug)
   return [...errors, ...validateDoneEntry(entry, story ? story.criteria : [])]
 }
 
+// Un carril declara **cuánta ceremonia** merecía la tarea; `n/a` en `review:` dice que la revisión no
+// corrió. `express` es el único que no convoca revisor, así que en los otros tres esa combinación es la
+// ADR incumplida, escrita en el propio registro.
+const CONVOCAN_REVISOR = ['directo', 'lite', 'full']
+const SIN_REVISION = /^n\/a\b/i
+
+// Lo que el registro puede decir sobre la ceremonia, y lo que todavía no. Los dos campos avisan en vez de
+// fallar por lo que dice `doneEntryErrors`, y cuentan en vez de listar porque al principio son todas: lo
+// que se lee es que el número baje. Cuando llegue a cero, exigirlos deja de costarle nada a nadie.
+//
+// El cruce sí nombra las tareas, porque son pocas y cada una es una pregunta concreta para una persona.
+// Y también avisa en vez de fallar, por una razón distinta de la de los campos: es un hecho del pasado
+// que no se arregla editando la entrada, así que el único camino al verde sería reescribir el registro.
+// Un gate que se apaga mintiendo es peor que no tenerlo.
+//
+// `sin clasificar` queda afuera del cruce a propósito: el recorrido corre esas tareas por el carril
+// completo, pero eso lo sabe el recorrido y no la entrada. Avisar sobre lo que hay que deducir es lo que
+// llena de ruido un aviso que después nadie mira.
+function doneCeremonyWarnings(done, adopted = new Set()) {
+  const propias = done.entries.filter((entry) => !adopted.has(entry.slug))
+  const warnings = []
+  const sinLane = propias.filter((entry) => !entry.lane)
+  if (sinLane.length) {
+    warnings.push(`planning/done: ${sinLane.length} entrada(s) sin lane:, así que no se puede comprobar `
+      + 'sobre el registro que la ceremonia que recibieron fue la que su superficie pedía (OPS-006)')
+  }
+  const sinReview = propias.filter((entry) => !entry.review)
+  if (sinReview.length) {
+    warnings.push(`planning/done: ${sinReview.length} entrada(s) sin review:, que es la dimensión con la `
+      + 'que OPS-006 dice que se mide si el carril elegido fue el correcto')
+  }
+  const saltadas = propias.filter((entry) => CONVOCAN_REVISOR.includes(entry.lane)
+    && entry.review && SIN_REVISION.test(entry.review))
+  if (saltadas.length) {
+    warnings.push(`planning/done: ${saltadas.map((entry) => entry.slug).join(', ')} declara(n) un carril `
+      + 'que convoca revisor y una revisión que no corrió: el carril reduce ceremonia, nunca evidencia')
+  }
+  return warnings
+}
+
 function duplicates(values) {
   return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))]
 }
@@ -291,6 +361,7 @@ function validateState({
 module.exports = {
   validateState,
   doneEntryErrors,
+  doneCeremonyWarnings,
   validCommitTrace,
   validDecisionTrace,
   validTestTrace,

package/engine/planning/parser.js

@@ -254,7 +254,7 @@ function doneFiles(dir) {
 
 // `fecha` entra al vocabulario porque un campo que no esté acá no corta al anterior: sin nombrarlo, el
 // `done:` de la entrada se lo tragaría entero como parte de su propio texto.
-const DONE_FIELDS = 'acept|fecha|done|qa|tests|decisions|commit'
+const DONE_FIELDS = 'acept|fecha|done|qa|tests|decisions|commit|lane|review'
 
 // Un campo vale hasta el próximo campo, una línea en blanco o el fin de la entrada. Mismo corte que ya
 // se arregló para los criterios y las historias, con el mismo síntoma: el valor es prosa y se envuelve a
@@ -287,7 +287,8 @@ function readDone(dir) {
         epic: ((match[2].match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
         acceptance: field('acept'), fecha: field('fecha'),
         done: field('done'), qa: field('qa'), tests: field('tests'),
-        decisions: field('decisions'), commit: field('commit'),
+        decisions: field('decisions'), commit: field('commit'), lane: field('lane'),
+        review: field('review'),
         source: path.relative(dir, file), raw: match[0].trimEnd(),
       })
     }
@@ -370,6 +371,10 @@ function parseWip(text, runner) {
   if (!task) return null
   return {
     task, runner, phase: field('phase') || '?', service: field('service'),
+    // El carril viaja en el WIP porque la línea del BACKLOG deja de existir al cerrar, y sin esto una
+    // corrida que se reanuda llega al cierre con el carril ya perdido: `currentTask` arma la tarea desde
+    // el WIP y le pone `tier` vacío. Medido — la tarea reanudada devolvía `""` (caso 074).
+    lane: field('lane'),
     complete: (text.match(/^\d+\.\s+\[[xX]\]/gm) || []).length,
     pending: (text.match(/^\d+\.\s+\[\s\]/gm) || []).length,
   }

package/engine/planning/state.js

@@ -50,7 +50,7 @@ function currentTask({ milestones, done, wips = [], claims = [] }, blockers = []
   if (wip) {
     const active = queue.find((task) => task.slug === wip.task)
       || {
-        slug: wip.task, hito: '', tier: '', cast: { build: '', review: [] },
+        slug: wip.task, hito: '', tier: wip.lane || '', cast: { build: '', review: [] },
         service: wip.service, acceptance: '', epic: '', criteria: [],
       }
     return { task: active, claimed: mine.has(wip.task), skipped: [], taken: [], waiting: [] }

package/package.json

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

package/template/planning/PROTOCOL.md

@@ -13,7 +13,14 @@ invariantes.
   opcionales: sin ellos la tarea está sin clasificar, que es un estado y no un error. Una tarea con
   dependencias no se ofrece ni se toma hasta que todas estén en DONE.
 - DONE: un archivo por tarea cerrada, `done/<slug>.md`, con su entrada `[x]` y los campos `acept:`,
-  `fecha:` en AAAA-MM-DD, `done:`, `qa:`, `tests:` y `commit:`. La fecha es la del cierre, y es lo que
+  `fecha:` en AAAA-MM-DD, `done:`, `qa:`, `tests:`, `commit:` y `lane:`. `lane:` repite el carril con el
+  que la tarea corrió —`express`, `directo`, `lite`, `full`— o `sin clasificar` si su línea no lo
+  declaraba, y existe porque el carril decide qué fases corren y su línea del BACKLOG se borra al cerrar:
+  sin él, si una tarea recibió la ceremonia que le tocaba sólo lo sabe quien estuvo en la sesión.
+  `check` avisa cuántas entradas no lo traen y falla si trae un valor que no existe. `review:` dice qué
+  pasó con la revisión —el veredicto y quién revisó— o `n/a — razón` cuando no corrió; es la dimensión con
+  la que OPS-006 dice que se mide si el carril elegido fue el correcto, y `check` cruza los dos: un carril
+  que convoca revisor con una revisión que no corrió es la ADR incumplida, escrita en el propio registro. La fecha es la del cierre, y es lo que
   ordena una evidencia que ya no depende de su posición dentro de un archivo. `tests:` enlaza cada criterio
   mediante `CN → prueba`; usa `A → prueba` cuando no hay épica o `n/a — razón` si no existe una
   superficie ejecutable. `decisions:` es opcional y, si aparece, cita `[fuente: ...]` o

package/template/planning/done/README.md

@@ -12,6 +12,8 @@ tarea entregó y con qué se comprueba.
   tests: C1 → nombre de prueba o comando; C2 → nombre de prueba o comando
   decisions: decisión no obvia [fuente: ruta/archivo] o [supuesto: motivo verificable]
   commit: abc1234 feat(scope): subject (repo@branch)
+  lane: full
+  review: aprobado por tech-lead, sobre api/alta.go
 ```
 
 El contrato completo de esos campos está en `../PROTOCOL.md`; acá va por qué el archivo es uno por tarea.
@@ -27,6 +29,27 @@ El nombre del archivo es una conveniencia; lo que identifica la tarea es el slug
 el archivo no cambia de qué tarea habla, y cerrar dos veces la misma sigue siendo un error que `check`
 rechaza, ahora entre archivos.
 
+## Por qué el carril
+
+El carril decide qué fases corre una tarea: `express` se saltea Ready, Plan y QA; `full` las corre
+todas. Ese dato vive en la línea del BACKLOG, y la línea **se borra al cerrar** — así que la pregunta
+«¿esta tarea recibió la ceremonia que su superficie pedía?» dejaba de tener dónde contestarse, y quedaba
+en la memoria de quien estuvo en la sesión. `lane:` la devuelve al registro.
+
+Se escribe aunque sea `sin clasificar`, que es distinto de no escribirlo: uno dice que la tarea corrió
+sin carril declarado y el otro, que nadie llenó el campo.
+
+## Por qué la revisión
+
+El carril dice cuánta ceremonia **merecía** la tarea; `review:` dice cuánta **recibió**. Con los dos, la
+pregunta que OPS-006 dejó pendiente —«¿el carril elegido fue el correcto?»— se contesta desde el registro
+en vez de desde la memoria de la sesión.
+
+`express` es el único carril que no convoca revisor, así que ahí `n/a — razón` es lo correcto. En
+`directo`, `lite` y `full` una revisión que no corrió es la ADR incumplida, y `check` lo avisa nombrando
+la tarea. Avisa y no falla: es un hecho del pasado que no se arregla editando la entrada, y el único
+camino al verde sería reescribir el registro.
+
 ## Por qué la fecha
 
 Mientras las entradas vivían en un archivo, «la última» era la última del archivo. Con archivos sueltos

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

@@ -36,6 +36,24 @@ nuevo no comprueba que desapareció lo viejo: los dos pueden convivir, y ahí el
 del cambio ocurrió. La aserción que hace falta es de ausencia —que la salida vieja ya no esté, que la
 rama vieja ya no corra—, y es la que no se escribe sola porque nadie la extraña.
 
+**Y lo más caro es que una quita casi nunca se ve como una quita.** Se escribe como un agregado: una
+bandera que se pone, una variable que se exporta, una condición que se añade. Lo que la delata es la
+frase que la justifica — «lo agrego **para que** deje de …». Ahí el sujeto es lo que entra y el objeto es
+lo que desaparece, y lo que desaparece es lo que hay que probar. Silenciar un aviso, saltear una rama,
+desarmar una confirmación: los tres se escriben sumando y los tres son quitas.
+
+Esto no admite excepción y por eso se dice acá y no en una guía: **una quita no se entrega sin su
+aserción de ausencia, y esa aserción se vio en rojo devolviendo lo quitado.** Sin ese rojo no está
+probado que la aserción mire lo que dice mirar — es el mismo rojo previo del párrafo de arriba, aplicado
+al revés.
+
+Y hay un caso particular que merece su renglón porque es el que más se disfraza: **una confirmación que
+estorba casi siempre está cuidando algo.** Antes de callarla se establece qué protege. Si la respuesta es
+«no sé», eso **es** el resultado de la medición y no un permiso para seguir: lo que corresponde es
+quitarle a la herramienta el motivo de preguntar, no la pregunta. Poner `CI=true` para que un gestor de
+paquetes dejara de confirmar antes de purgar borró el árbol de dependencias de un proyecto real, y el
+cambio se había probado —el gate arrancaba— midiendo sólo lo que aparecía.
+
 Lo que se quita, además, tiene dependientes, y no se anuncian. Una invariante que deja de valer se lleva
 puesto a quien la daba por cierta: el mensaje que la afirmaba, la condición que la deducía, el comentario
 que la explicaba. Suelen vivir en otro archivo, que es donde una premisa vieja se pudre sin que nada

package/template/planning/wip/README.md

@@ -12,6 +12,7 @@ phase: Build
 started: AAAA-MM-DD
 service: ruta
 acceptance: "criterio observable"
+lane: full
 ---
 
 ## Plan aprobado
@@ -24,6 +25,10 @@ acceptance: "criterio observable"
 - (ninguno)
 ```
 
+`lane:` viaja acá por la misma razón por la que existe en DONE: la línea del BACKLOG se borra al
+cerrar, y una corrida que se reanuda arma la tarea desde este archivo. Sin el campo, el cierre de una
+corrida reanudada escribe `sin clasificar` sobre una tarea que sí tenía carril.
+
 Sin archivo, el runner está en IDLE: un clon nuevo no trae ninguno y eso no es un error.
 
 ## Por qué uno por runner y no uno solo