@ingeniomaps/cauce 0.73.0 → 0.75.0

package/CHANGELOG.md

@@ -14,6 +14,107 @@ 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.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
+
+- **Un gate ya no pisa lo que vos construiste.** Al medir el índice, lo ignorado se enlazaba al árbol
+  real: el gate corría sobre lo staged y te dejaba la salida de build con **esa** versión, mientras tu
+  fuente en disco tenía otra y nada lo decía. Si corrías la app después de commitear, corrías algo que
+  no era lo que estabas mirando. Ahora lo que un gate puede fabricar —`dist`, `build`, `out`,
+  `coverage`, `.next`, `.nuxt`, `.svelte-kit`, `.turbo`, `.output`, `.parcel-cache`, `__pycache__`,
+  `.pytest_cache`— se construye adentro de la copia y se descarta con ella. Lo que no puede fabricar
+  —`node_modules`, un `.env`— se le sigue enlazando.
+
+  Arregla también algo del propio gate: construía sobre restos de tu corrida anterior, así que su
+  veredicto dependía de un estado que nadie declaró.
+
+  **Lo que te pide algo**: el build del gate deja de ser incremental, así que ese commit tarda más. Y si
+  tu proyecto genera en un directorio ignorado que no está en esa lista, seguí reportándolo: el nombre
+  se agrega.
+
+- **Los gates corren sobre una copia que se declara no interactiva, y un gate que falla dice qué dijo.**
+  `verify` mide el índice en un temporal y enlaza ahí lo ignorado, `node_modules` incluido, apuntando al
+  original. En un proyecto pnpm eso no corre: el gestor ve que el árbol enlazado no fue instalado ahí y
+  su reacción es reinstalar, que empieza borrando el `node_modules` **del proyecto**. Lo único que lo
+  detenía es que el hijo no ve una terminal. Ahora la copia lleva `CI=true`, que es la variable que el
+  propio pnpm nombra — y sólo la copia: si árbol e índice coinciden, los gates corren en tu directorio y
+  ahí no se te cambia nada.
+
+  Y el bloqueo dejaba de decir por qué: `test (exit 1)` era el mismo texto para una suite en rojo y para
+  un gestor que se negó a arrancar el script, así que empujaba a aprobar el commit como «rojo conocido»
+  sin que nada se hubiera medido. Ahora llega con la duración y con la primera línea de error de la
+  herramienta, y cuando todos los gates fallan por debajo de dos segundos lo dice — sin afirmar que no
+  corrieron, que es algo que no se puede saber desde acá.
+
+  **Lo que te pide algo**: si tenías un gate que se comportaba distinto bajo `CI`, ahora lo va a hacer
+  al commitear con algo sin stagear o sin trackear.
+
 ## [0.73.0] - 2026-09-09
 
 ### 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) {
@@ -568,7 +610,7 @@ while (rounds++ < MAX_TASKS) {
       `acceptance=${JSON.stringify(task.acceptance)}, 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 +635,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 +657,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 +681,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 +707,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 +730,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 +738,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 +770,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 +782,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)
@@ -753,6 +797,7 @@ while (rounds++ < MAX_TASKS) {
     `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 +812,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 +824,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/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/core/evidence.js

@@ -31,12 +31,16 @@ function logPath(root) {
 
 // Una línea por gate corrido. Nunca lanza: es un efecto de borde de un guard, y un registro que no se
 // puede escribir no puede impedir el commit que estaba juzgando.
-function record(root, gate, status) {
+// `ms` es cuánto tardó el gate, y se guarda porque es lo que separa una suite que falló de una que
+// nunca arrancó. Antes había que restar los `at` de dos líneas seguidas para estimarlo, y esa resta
+// incluye lo que pasó entre gate y gate; el número propio no. Fue lo que costó diagnosticar el caso 068:
+// tres gates «en rojo» a un segundo uno de otro, cuando la corrida real de ese proyecto tarda trece.
+function record(root, gate, status, ms) {
   if (!root) return
   try {
     const file = logPath(root)
     const previous = fs.existsSync(file) ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean) : []
-    const entry = JSON.stringify({ at: new Date().toISOString(), gate, status })
+    const entry = JSON.stringify({ at: new Date().toISOString(), gate, status, ...(ms >= 0 ? { ms } : {}) })
     fs.mkdirSync(path.dirname(file), { recursive: true })
     fs.writeFileSync(file, `${[...previous, entry].slice(-MAX_RUNS).join('\n')}\n`)
   } catch { /* el registro es evidencia, no una puerta */ }

package/engine/hooks/shell.js

@@ -355,14 +355,22 @@ function governance(input) {
 function run(program, args, cwd, extra = {}) {
   const env = { ...process.env, ...extra }
   delete env.NODE_TEST_CONTEXT
+  const started = Date.now()
   const result = spawnSync(program, args, { cwd, encoding: 'utf8', stdio: 'pipe', env })
   return {
     ok: result.status === 0,
     status: result.status,
+    ms: Date.now() - started,
     output: `${result.stdout || ''}${result.stderr || ''}`.trim(),
   }
 }
 
+// Salidas de build y cachés que cualquier gate rehace solo. Se comparan contra el nombre entero de la
+// entrada para que valga también anidado —`packages/app/dist`—, y con el separador de `git status`, que
+// siempre usa `/`.
+const RECREABLE = new RegExp('(^|/)(?:dist|build|out|coverage|__pycache__'
+  + '|\\.next|\\.nuxt|\\.svelte-kit|\\.turbo|\\.output|\\.parcel-cache|\\.pytest_cache)$')
+
 // Dónde tiene que correr un gate: sobre lo que el commit va a grabar, que es el índice y no el árbol.
 // El árbol se le parece casi siempre y por eso el error no se veía — puede tener encima otra versión de
 // un archivo staged, y puede tener uno sin trackear que el commit no lleva, que es el olvido de
@@ -399,6 +407,19 @@ function commitTree(dir) {
   for (const line of lines) {
     if (!line.startsWith('!! ')) continue
     const name = line.slice(3).trim().replace(/\/$/, '')
+    // Lo que el gate puede fabricar no se le enlaza: lo construye adentro de la copia y se descarta con
+    // ella. Enlazarlo hacía dos daños a la vez. Uno es del usuario: el gate corre sobre el índice, así
+    // que le dejaba la salida de build con la versión **staged** mientras su fuente en disco tenía otra,
+    // y nada lo decía —medido con un `dist/` que pasó de «lo-que-estoy-editando» a «staged» (caso 069)—.
+    // El otro es del propio gate: construía sobre restos de la corrida anterior del usuario, así que su
+    // veredicto dependía de un estado que nadie declaró.
+    //
+    // La lista envejece y eso pesa menos de lo que parece, porque sólo se aplica a rutas que git ya
+    // marcó como ignoradas: un `dist/` ignorado es generado por definición. Errarle por defecto —que
+    // falte un nombre— deja el comportamiento de antes; errarle por exceso hace que un gate reconstruya,
+    // que es más lento y no incorrecto. Lo que **sí** se enlaza es lo que un gate no puede fabricar:
+    // `node_modules`, un `.env`, las credenciales de una herramienta.
+    if (RECREABLE.test(name)) continue
     const link = path.join(temp, name)
     if (fs.existsSync(link)) continue
     fs.mkdirSync(path.dirname(link), { recursive: true })
@@ -421,7 +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)
-  return { root: temp, temp, env: {} }
+  // 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.
+  //
+  // 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) {
@@ -462,6 +503,41 @@ function verify(input) {
 // Cada gate deja su rastro en `ops`; para qué sirve ese registro lo dice `core/evidence.js`. Lo que se
 // decide acá es que el rojo se anota igual que el verde: un gate que falló y se commiteó con
 // aprobación es exactamente lo que alguien va a querer ver después.
+// Lo que se sabe de un gate que falló, en la forma en que se va a leer. El mensaje decía sólo
+// `test (exit 1)` y tiraba la salida de la herramienta: cualquier causa —una suite en rojo, un gestor
+// que se negó a arrancar el script, un binario que no está— llegaba con el mismo texto. Es la misma
+// forma de fallar que el caso 066 encontró en una prueba, acá en el mensaje que lee una persona.
+//
+// Se muestra **una** línea y acotada: la salida de un gate puede traer cualquier cosa del entorno, y lo
+// que hace falta para diagnosticar es la primera línea de error, no el volcado.
+const ERROR_LINE = /error|err[_!]|fail|abort|not found|cannot|no such/i
+const MAX_LINE = 160
+function fallo(gate, result) {
+  // La línea que empieza con `>` es el eco del script que npm y pnpm imprimen antes de correrlo, así
+  // que lleva el comando entero y no dice nada de qué falló. Descartarla es lo que hace que la primera
+  // coincidencia sea el error y no el comando — con el eco adentro, un script que **menciona** una
+  // palabra de error gana siempre.
+  const lines = (result.output || '').split('\n').map((one) => one.trim())
+    .filter((one) => one && !one.startsWith('>'))
+  const line = lines.find((one) => ERROR_LINE.test(one)) || lines[0] || ''
+  return { gate, status: result.status, ms: result.ms, line: line.slice(0, MAX_LINE) }
+}
+
+// Un gate que vuelve en menos de esto no corrió una suite. No se afirma que **no** haya corrido —un
+// lint puede fallar rápido y de verdad— y por eso lo que se agrega es el número, no un veredicto: los
+// tres gates del caso 068 volvieron a un segundo uno de otro contra los trece de la corrida real.
+const DEMASIADO_RAPIDO = 2000
+function comoSeLee(failures) {
+  const texto = failures
+    .map((one) => `${one.gate} (exit ${one.status}, ${(one.ms / 1000).toFixed(1)} s)`
+      + `${one.line ? `: ${one.line}` : ''}`)
+    .join('; ')
+  if (!failures.every((one) => one.ms < DEMASIADO_RAPIDO)) return texto
+  const cuantos = failures.length === 1 ? 'Volvió' : `Los ${failures.length} volvieron`
+  return `${texto}\n${cuantos} en menos de ${DEMASIADO_RAPIDO / 1000} s: eso no alcanza para correr `
+    + 'una suite, así que mirá si llegaron a ejecutarse antes de aprobar esto como un rojo conocido.'
+}
+
 function verifyGates(root, dir, aprobado, env, ops) {
   const failures = []
   if (fs.existsSync(path.join(root, 'package.json'))) {
@@ -472,28 +548,28 @@ function verifyGates(root, dir, aprobado, env, ops) {
     for (const script of ['test', 'lint', 'typecheck', 'build']) {
       if (!pkg.scripts || !pkg.scripts[script]) continue
       const result = run(pm, ['run', script], root, env)
-      EV.record(ops, script, result.status)
-      if (!result.ok) failures.push(`${script} (exit ${result.status})`)
+      EV.record(ops, script, result.status, result.ms)
+      if (!result.ok) failures.push(fallo(script, result))
     }
   } else if (fs.existsSync(path.join(root, 'go.mod'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^ci:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['ci'], root, env)
-      EV.record(ops, 'make ci', result.status)
-      if (!result.ok) failures.push(`make ci (exit ${result.status})`)
+      EV.record(ops, 'make ci', result.status, result.ms)
+      if (!result.ok) failures.push(fallo('make ci', result))
     } else {
       for (const args of [['test', './...'], ['build', './...']]) {
         const result = run('go', args, root, env)
-        EV.record(ops, `go ${args[0]}`, result.status)
-        if (!result.ok) failures.push(`go ${args[0]} (exit ${result.status})`)
+        EV.record(ops, `go ${args[0]}`, result.status, result.ms)
+        if (!result.ok) failures.push(fallo(`go ${args[0]}`, result))
       }
     }
   } else if (fs.existsSync(path.join(root, 'pyproject.toml')) || fs.existsSync(path.join(root, 'requirements.txt'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^test:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['test'], root, env)
-      EV.record(ops, 'make test', result.status)
-      if (!result.ok) failures.push(`make test (exit ${result.status})`)
+      EV.record(ops, 'make test', result.status, result.ms)
+      if (!result.ok) failures.push(fallo('make test', result))
     }
   }
   if (!failures.length || aprobado) return
@@ -501,7 +577,7 @@ function verifyGates(root, dir, aprobado, env, ops) {
   // comando a mano se lee como que el guard miente, y lo que pasó es que midió lo que se va a grabar.
   const donde = root === dir ? '' : '\nCorrió sobre el índice, que es lo que el commit graba: si en tu '
     + 'directorio pasa, es que en disco tenés algo que no está staged.'
-  block(`Verify falló en ${path.basename(dir)}: ${failures.join(', ')}. No se commitea en rojo.${donde}\n`
+  block(`Verify falló en ${path.basename(dir)}: ${comoSeLee(failures)}\nNo se commitea en rojo.${donde}\n`
     + AP.HOW('OPS_SKIP_VERIFY'))
 }
 

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)
 }

package/package.json

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

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