@ingeniomaps/cauce 0.93.0 → 0.95.0

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

@@ -13,6 +13,11 @@ por separado, y quien revise tiene que volver a separarlos a mano.
 La unidad de aceptación y de evidencia sigue siendo la tarea: su entrada de DONE registra todos los
 commits que produjo, separados por `;`. Partir el diff no parte la aceptación.
 
+**La prohibición de firmas de IA cubre todo lo que este trabajo publica**, no sólo el mensaje del commit:
+el título y el cuerpo del pull request, y los comentarios que se dejen ahí. Y casi nunca es algo que
+alguien tipea — lo agrega la herramienta, sola, al final del texto que uno escribió—, así que cumplirla
+es revisar la salida antes de publicarla y no acordarse de no escribirla.
+
 ## R9 — El artefacto manda
 
 Tests verdes no reemplazan build, paquete, imagen o migración cuando son parte del artefacto entregable.
@@ -28,6 +33,15 @@ una implementación sutilmente equivocada de una correcta. Lo que sí la disting
 puesto, exactamente lo que el caso dice cuidar, y verlo ponerse rojo por eso. Si no se pone rojo, no lo cuida,
 y la cobertura no lo va a decir: mide qué líneas se ejecutan, no qué defectos se atrapan.
 
+**Y esa mutación se declara por escrito, en la aceptación que la pide.** Una línea alcanza: qué se rompe
+y qué prueba tiene que ponerse roja. Sin eso, quien revisa no puede distinguir la mutación que se corrió
+de la que se pensó, y la única salida que le queda es volver a correrla — que es rehacer el trabajo que
+delegarlo evitaba, igual que el contraste de lo consultado en R14.
+
+Escribirla antes cambia además lo que se escribe. Una aceptación que tiene que nombrar qué romper deja de
+poder pedir algo que ninguna mutación puede tocar: si no hay nada que romper, no había propiedad que
+cuidar, y eso se ve al redactarla en vez de al final de la vuelta.
+
 La precondición del caso también cuenta. Si el estado en que arranca no puede ocurrir por el camino de
 producción, lo que prueba tampoco: queda verde para siempre sobre algo que nadie va a vivir.
 
@@ -42,6 +56,14 @@ frase que la justifica — «lo agrego **para que** deje de …». Ahí el sujet
 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.
 
+**Y antes de probar cómo se quita hay que poder quitarlo.** Lo que está en uso no se corta: se depreca,
+y la marca dice las dos cosas que la vuelven una salida y no una etiqueta — qué lo reemplaza, y qué
+condición permite borrarlo. Sin la primera, quien lo usa no sabe a dónde ir; sin la segunda, el
+deprecado es código muerto con un cartel puesto, y se queda para siempre.
+
+Lo que no llama nadie es otra cosa y se borra. La diferencia no es de estilo: cortar de golpe rompe a un
+consumidor que nadie miró, y deprecar lo que nadie usa cuesta mantener dos caminos para nadie.
+
 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
@@ -76,3 +98,16 @@ Decirlo es parte de la regla y no una nota al pie. Una norma que se presenta com
 lo está enseña a no creerle al resto: quien descubre que puede mergear sin que nada lo frene concluye
 que la línea de arriba es decorativa, y esa conclusión se lleva puesto también lo que sí se comprueba.
 Que el límite lo sostenga una persona no lo hace más blando; lo hace visible.
+
+**Y la autorización dice si se publica, nunca a dónde.** Eso se decide aparte y se comprueba: lo que se
+publica va al repositorio en el que se está trabajando. Si ese remoto es un fork, va al fork —y la rama
+se corta de la suya, no de la del original—, porque una rama cortada del principal es la antesala de
+mandarle el PR.
+
+No se deduce del contexto. Que la herramienta resuelva sola el repositorio de origen no es una
+autorización, y tampoco lo son que el cambio «obviamente tenga que llegar ahí», que el fork tenga
+configurado el original por defecto, ni que un PR anterior haya ido a parar allá. Saltar al principal
+—abrir, aprobar, mergear, cerrar o comentar— se pide con todas las letras y para ese caso concreto.
+
+Es de las pocas que no tiene vuelta atrás. Un PR mal apuntado es trabajo publicado en el repositorio de
+otro equipo: lo ven, les llega la notificación, y cerrarlo no deshace nada de eso.

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

@@ -218,3 +218,26 @@ de dónde vino y quién lo autorizó.
 Cuando el contenido externo cambia lo que se iba a hacer, se dice de dónde salió y decide una persona:
 al INBOX si es una propuesta, a HUMAN_ACTIONS si necesita una autoridad que el cargo no tiene.
 
+
+## R24 — Una premisa sobre el propio código se abre antes de usarla
+
+R14 gobierna lo que se afirma de una herramienta, un motor, una norma o un sistema de terceros. Lo que
+queda afuera es el código que se está por cambiar, y ahí la afirmación falsa cuesta más: nadie la va a
+discutir, porque el que la escribe y el que la lee miran el mismo repositorio y suponen lo mismo.
+
+Toda premisa sobre el comportamiento del propio código —qué hace un endpoint, qué significa un estado,
+dónde vive un componente— se abre en el archivo, en la línea, antes de escribirla en una aceptación, un
+plan o un diagnóstico. No alcanza con recordarla ni con haberla leído la semana pasada.
+
+**Y el ancla se abre, no se copia.** Una referencia `archivo:línea` traída de otra tarea es una premisa
+más, no una comprobación: el archivo se movió. En la instancia que originó esta regla, una función pasó
+de la línea 555 a la 733 dentro de la misma sesión.
+
+Lo que esto evita es una clase entera de vuelta perdida, y se reconoce porque el trabajo frena en la
+puerta y no en el código: la aceptación pedía algo que el sistema no hace, así que ninguna
+implementación la cumple. Cuatro corridas seguidas se perdieron así en un solo día —una afirmaba que un
+webhook abría acceso sobre filas terminales, y hace lo contrario—, y las cuatro se veían como un
+problema de implementación.
+
+El contraste es el mismo que pide R14 y por eso no se repite acá: lo consultado se enumera, con la ruta
+leída y la línea. La diferencia es sólo el sujeto.

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

@@ -24,30 +24,22 @@ y se registra lo segundo.
 
 El estado se mueve de forma atómica entre contratos; nunca se copia para representar progreso.
 
-## R16 — El costo es el contexto, no las palabras
-
-Cada llamada reenvía el contexto entero, así que gasta más quien da más vueltas que quien escribe más.
-Los comandos independientes van en una sola invocación; el CLI antes que el archivo; el fragmento antes
-que el archivo entero; un subagente o un workflow sólo cuando el trabajo no entra en la corrida actual.
-
-Entre etapas viaja lo que la siguiente necesita para decidir, no todo lo que la anterior produjo. El
-análisis completo queda donde se escribió y lo lee una sola vez quien sintetiza al final; lo que se
-arrastra en el handoff se reenvía en cada etapa que sigue, así que lo que costó una vez pasa a costar
-una vez por etapa. Son requisitos opuestos y por eso no son el mismo texto: el resumen quiere ser corto
-porque viaja, y la síntesis quiere estar completa porque decide.
-
-Se lee para escribir, no para confirmar: un archivo se lee una vez y se escribe entero. Releerlo para
-comprobar que quedó no comprueba nada que un error no hubiera dicho.
-
-Verificar es la excepción, y no se negocia. Ahorrar una llamada nunca justifica afirmar sin haber
-comprobado —R14 no admite descuentos— ni dar por terminado lo que no se corrió.
-
 ## R17 — Una unidad de trabajo se parte por lo que acumula, y hay dos formas de acumular
 
 Dos barras, y cada una encuentra lo que la otra deja pasar: **cinco condiciones de aceptación** en una
 tarea, y **cuatro horas de esfuerzo humano**. Arriba de la tarea el conteo sigue: siete criterios en una
 épica, nueve tareas en un hito.
 
+**Una condición es un resultado que se puede mirar por separado, no una viñeta.** El número no sirve de
+nada sin esto: cinco viñetas que describen el mismo invariante desde cinco ángulos son **una** condición,
+y contarlas como cinco parte por la mitad lo que era una sola cosa. Al revés cuesta más caro y es el que
+nadie mira: una frase que promete dos resultados con vidas distintas —«valida el pago y manda el
+email»— son **dos**, y escrita como una el umbral no se entera nunca. Contar de menos no dispara nada, y
+eso se lee igual que una unidad chica.
+
+La prueba es si se pueden entregar por separado. Si al tachar una las otras siguen valiendo, son
+distintas; si tachar una deja a las demás sin sentido, era una sola dicha en partes.
+
 Y hay una tercera que no se mide antes sino después: **un plan que ninguna crítica aprueba**. Las dos
 primeras miran la unidad escrita; ésta mira lo que pasó al intentarla, y por eso es la evidencia más
 directa de las tres — y la única que no se puede tener de antemano. Cuando nadie pudo escribir un plan
@@ -90,103 +82,41 @@ Las dos barras juntas, y en los dos sentidos: una tarea de tres horas con quince
 el tope de esfuerzo y no se construye nunca; una tarea de una condición y tres días lo pasa por el otro
 lado. Medir una sola deja pasar la mitad de los casos.
 
-## R20 — Una medición se lanza contra lo que podría refutarla
-
-Antes de una tanda cara —evaluaciones, corridas, barridos— se escribe qué se espera encontrar y **qué
-resultado lo desmentiría**. Sin esa segunda mitad no hay medición: hay recolección, y recolectar
-confirma siempre.
-
-El tamaño sale de ahí y no de la lista: se corre el mínimo que pueda refutar, no lo que cubra todo.
-Y se relee la hipótesis en la primera tanda, porque cuando ya está contestada, seguir cuesta lo mismo
-que la primera vez y no agrega nada.
-
-La exhaustividad tiene su lugar y es otro: cuando cada elemento puede fallar por su cuenta —medir
-cincuenta cargos que nunca se midieron—, no hay señal común que una muestra revele. Lo que no
-corresponde es tratar una pregunta de sí o no como si fuera un censo.
-
-El costo de equivocarse acá no se ve mientras pasa: cada corrida termina bien, entrega su resultado y
-parece trabajo. Lo que se gasta es la vuelta que no se dio en otra cosa, y eso no aparece en ninguna
-salida.
-
-Repetir una medición que falló pide lo mismo. Una re-corrida sirve para dos cosas y conviene decir cuál:
-comprobar un cambio, y entonces ese cambio tiene que poder mover **ese** veredicto —tocar lo que el caso
-mide, no cualquier parte del contrato—; o estimar cuánto varía el resultado sin que nada cambie, y
-entonces se declara así y se repite varias veces, porque una sola no estima nada. Volver a correr
-esperando que esta vez salga distinto no es ninguna de las dos: es comprar un número nuevo con la misma
-información.
-
-Un cambio que no toca lo que el caso mide no compra una re-corrida. La medición vuelve a costar entera y
-lo que devuelve es la varianza que ya estaba ahí — y esa varianza existe: en la sesión que originó esta
-regla, cargos que habían pasado todos sus casos fallaron uno al día siguiente sin que el motivo tocara
-nada de lo que se había cambiado.
-
-Y lo que se repite es el caso que falló, no la batería. Un sujeto que falla uno de seis vuelve a correr
-ese uno: los otros cinco veredictos ya se tienen, y volver a mirarlos cuesta lo mismo que obtenerlos la
-primera vez. El registro parcial que sale de ahí no vale solo —cubre menos casos de los que existen— y
-se compone con los veredictos que no se volvieron a medir, diciendo de qué corrida viene cada uno.
-
-## R21 — Retomar empieza por establecer qué quedó hecho
-
-Un trabajo caro que se corta —por un límite, una caída, una interrupción— deja trabajo hecho. Antes de
-volver a lanzarlo se establece cuál es: qué artefactos hay en disco, qué resultados se escribieron, qué
-elementos ya tienen veredicto. Recién con esa lista se decide, y lo que se corre es la diferencia.
-
-«Continuá» no autoriza a relanzar. Pide exactamente lo contrario: seguir desde donde se quedó, que es
-imposible sin haber mirado antes dónde fue. Relanzar entero cobra de nuevo lo que ya se pagó, y quien
-lo pide no tiene cómo saber que eso está pasando —la corrida se ve igual empiece donde empiece—.
-
-Y cuando el pedido sí es relanzar —«de nuevo», «desde cero», «reiniciá»— tampoco se ejecuta derecho:
-primero se entrega el veredicto de lo avanzado y se pregunta si aun así quiere la corrida entera. Puede
-quererla, y hay razones legítimas: el sujeto cambió, lo anterior quedó sospechoso, se busca medir
-varianza. Lo que no puede es tirarse trabajo sin que nadie lo haya decidido.
-
-El veredicto existe para que se pueda decidir, así que tiene que traer con qué. Cuatro cosas:
-
-- **Qué ya tiene resultado**, elemento por elemento, y cuál es.
-- **Qué quedó a medias y si sirve.** Son dos preguntas distintas y la segunda no se contesta viendo que
-  el archivo está.
-- **Cuánto cuesta rehacer cada parte**, con el número de lo que ya se gastó al lado.
-- **Cómo se puede partir.** Casi nunca es todo o nada: si un pedazo cuesta la mitad del total, va
-  separado para que se pueda correr uno y decidir el otro después, con el primero a la vista.
-
-**Lo hecho no es lo aprovechable, y la diferencia sólo se ve mirando.** Un trabajo interrumpido deja
-artefactos que parecen completos: la etapa que escribió su análisis y murió antes de devolverlo se ve
-igual que la que cerró, y los archivos de dos corridas distintas conviven en el mismo directorio sin
-que nada los distinga salvo la fecha. Comprobar cuál es cuál cuesta minutos; suponerlo cuesta la
-corrida entera y encima produce una medición contaminada — un resultado calculado sobre insumos que ya
-fueron sobrescritos, que es peor que no tenerlo porque se lee igual que uno bueno.
-
-Por eso el veredicto puede terminar en «desde cero», y eso no lo invalida. Establecer que no había nada
-rescatable **es** el trabajo de la regla: lo que R21 impide no es relanzar, es relanzar sin saber.
-
-Un elemento que ya tiene veredicto no se vuelve a medir por venir en la misma tanda: cuesta lo mismo que
-la primera vez y su resultado no puede cambiar, que es lo que R20 nombra. Si existe un filtro para correr
-sólo lo que falta, usarlo no es una optimización: es la forma correcta de la corrida.
-
-Un mecanismo de reanudación se comprueba, nunca se supone —R14 no hace excepción con las herramientas
-propias—. Después de reanudar se mira si efectivamente reutilizó: cuántas unidades de trabajo nuevas
-aparecieron, cuánto se gastó. La sesión que originó esta regla creyó estar reanudando desde caché y
-volvió a correr entero dos veces: siete millones de tokens para un solo veredicto, con los archivos de
-las etapas ya cumplidas a la vista en el directorio de trabajo, y con el filtro que lo evitaba escrito
-por quien reanudaba tres horas antes.
-
-## R22 — Lo que se mide no se toca mientras se mide
-
-Mientras una medición corre, el sujeto y todo aquello contra lo que resuelve se quedan quietos. No se
-edita el contrato que se está midiendo, ni el motor que la corrida usa, ni el entorno del que lee.
-
-Lo que lo vuelve difícil de ver es que no avisa. La corrida termina, entrega su resultado y **ese
-resultado se lee exactamente igual que uno limpio**: no hay señal que diga «esto midió dos versiones».
-Quien lo reciba va a decidir sobre él sin saber que se movió el piso.
-
-Y el camino por el que entra casi nunca es el archivo obvio. Un banco desechable puede resolver la
-herramienta por un enlace al repositorio vivo, así que editar ahí cambia lo que la corrida lee sin que
-nada del banco se haya tocado. La pregunta no es «¿toqué el sujeto?» sino «¿toqué algo que el sujeto
-alcanza?».
-
-Si hace falta trabajar igual, se trabaja donde la medición no mira: otra copia, otra rama sin
-materializar, o se espera. Esperar es más barato que descubrir que la tanda no vale.
-
-Y si ya pasó, se dice: qué medición, qué cambió y cuándo. Un resultado cuyo entorno se movió es una
-hipótesis, no un veredicto —lo mismo que R21 nombra para lo que quedó a medias—, y guardarlo sin esa
-marca es la forma cara del error, porque el número sobrevive a la sesión que sabía.
+
+## R25 — El identificador de una unidad de trabajo no cambia mientras está viva
+
+El slug con el que una tarea se escribe es el mismo con el que se cierra. Renombrarlo a mitad de camino
+—porque se entendió mejor el alcance, porque se partió en dos, porque el nombre viejo quedó feo— rompe
+lo único que ata la cola con lo entregado.
+
+Y rompe **sin que nada falle**, que es lo que lo vuelve caro. El estado de una unidad no está escrito en
+ningún lado: se deriva cruzando el identificador entre la cola, lo reclamado y lo hecho. Con el nombre
+cambiado, las dos mitades dejan de cruzarse y cada lado se lee coherente por separado: la cola muestra
+una tarea pendiente que ya está construida, y lo hecho muestra una entrega que nadie pidió. La puerta
+pasa en verde. En la instancia que originó esta regla, una tarea partida en cuatro se cerró con dos
+nombres nuevos y la corrida siguiente gastó 594k tokens para descubrir que tres de ellas ya estaban
+hechas.
+
+Cuando el nombre de verdad tiene que cambiar, la salida es barata y hay que escribirla: el nuevo lleva
+el viejo al lado —`slug-nuevo (antes: slug-viejo)`— hasta que la unidad se cierra. Ahí el cruce vuelve a
+existir y lo puede hacer una persona leyendo.
+
+Partir una unidad es otra cosa y no la toca: las partes son unidades nuevas, con identificadores nuevos,
+y la original se cierra diciendo en qué se partió. Lo que R25 prohíbe es que la misma unidad viva con
+dos nombres.
+
+## R28 — Un estado lo dice el contenido de un archivo, nunca su presencia
+
+Un bloqueo, una pausa o un trabajo en curso que se representan con «el archivo está» tienen un modo de
+fallo que no se ve: resolverlos exige acordarse de borrar, y el que revisa lee lo que el archivo dice
+—que ya está resuelto— mientras el mecanismo sigue leyendo que existe.
+
+Se paga entero y en la puerta de entrada: la corrida arranca, lee el estado completo, y recién ahí
+descubre que lo que la frena es un archivo que alguien dejó puesto. En la instancia que originó esta
+regla pasó dos veces el mismo día —la segunda después de haber dicho que no se repetiría— a 42k tokens
+por vez.
+
+El archivo se queda y su contenido dice en qué estado está. Es lo que ya hace el WIP de este toolkit:
+`status: IDLE` es un estado escrito, no un archivo ausente, así que quien lo lee y quien lo comprueba
+leen lo mismo. Un centinela cuya única información es existir obliga a que el borrado sea parte de la
+resolución, y eso es una convención que alguien va a olvidar.

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

@@ -0,0 +1,153 @@
+# Cómo se gasta una corrida
+
+Lo que cuesta una vuelta de trabajo y qué la vuelve aprovechable: dónde se va el contexto, cuándo una
+medición vale, cómo se retoma lo que se cortó y qué no se toca mientras se mide.
+
+Viven acá y no en `process.md` por una razón medida. El override de una regla es por nombre de archivo,
+así que una empresa que escribe su propio `process.md` —reemplazar «pensar antes de editar» por su
+versión es lo primero que hace cualquiera— se llevaba puestas también éstas, que nadie reemplaza y que
+`effectiveRules` dejaba de entregarle a todo agente. Una instancia real lo vivió: las declaró «adoptadas
+por referencia» en una tabla de prosa que el motor no lee, y aun así dos de ellas no estaban rigiendo el
+día que le costaron una sesión entera (caso 160).
+
+## R16 — El costo es el contexto, no las palabras
+
+Cada llamada reenvía el contexto entero, así que gasta más quien da más vueltas que quien escribe más.
+Los comandos independientes van en una sola invocación; el CLI antes que el archivo; el fragmento antes
+que el archivo entero; un subagente o un workflow sólo cuando el trabajo no entra en la corrida actual.
+
+Entre etapas viaja lo que la siguiente necesita para decidir, no todo lo que la anterior produjo. El
+análisis completo queda donde se escribió y lo lee una sola vez quien sintetiza al final; lo que se
+arrastra en el handoff se reenvía en cada etapa que sigue, así que lo que costó una vez pasa a costar
+una vez por etapa. Son requisitos opuestos y por eso no son el mismo texto: el resumen quiere ser corto
+porque viaja, y la síntesis quiere estar completa porque decide.
+
+Se lee para escribir, no para confirmar: un archivo se lee una vez y se escribe entero. Releerlo para
+comprobar que quedó no comprueba nada que un error no hubiera dicho.
+
+Verificar es la excepción, y no se negocia. Ahorrar una llamada nunca justifica afirmar sin haber
+comprobado —R14 no admite descuentos— ni dar por terminado lo que no se corrió.
+
+## R20 — Una medición se lanza contra lo que podría refutarla
+
+Antes de una tanda cara —evaluaciones, corridas, barridos— se escribe qué se espera encontrar y **qué
+resultado lo desmentiría**. Sin esa segunda mitad no hay medición: hay recolección, y recolectar
+confirma siempre.
+
+El tamaño sale de ahí y no de la lista: se corre el mínimo que pueda refutar, no lo que cubra todo.
+Y se relee la hipótesis en la primera tanda, porque cuando ya está contestada, seguir cuesta lo mismo
+que la primera vez y no agrega nada.
+
+La exhaustividad tiene su lugar y es otro: cuando cada elemento puede fallar por su cuenta —medir
+cincuenta cargos que nunca se midieron—, no hay señal común que una muestra revele. Lo que no
+corresponde es tratar una pregunta de sí o no como si fuera un censo.
+
+El costo de equivocarse acá no se ve mientras pasa: cada corrida termina bien, entrega su resultado y
+parece trabajo. Lo que se gasta es la vuelta que no se dio en otra cosa, y eso no aparece en ninguna
+salida.
+
+Repetir una medición que falló pide lo mismo. Una re-corrida sirve para dos cosas y conviene decir cuál:
+comprobar un cambio, y entonces ese cambio tiene que poder mover **ese** veredicto —tocar lo que el caso
+mide, no cualquier parte del contrato—; o estimar cuánto varía el resultado sin que nada cambie, y
+entonces se declara así y se repite varias veces, porque una sola no estima nada. Volver a correr
+esperando que esta vez salga distinto no es ninguna de las dos: es comprar un número nuevo con la misma
+información.
+
+Un cambio que no toca lo que el caso mide no compra una re-corrida. La medición vuelve a costar entera y
+lo que devuelve es la varianza que ya estaba ahí — y esa varianza existe: en la sesión que originó esta
+regla, cargos que habían pasado todos sus casos fallaron uno al día siguiente sin que el motivo tocara
+nada de lo que se había cambiado.
+
+Y lo que se repite es el caso que falló, no la batería. Un sujeto que falla uno de seis vuelve a correr
+ese uno: los otros cinco veredictos ya se tienen, y volver a mirarlos cuesta lo mismo que obtenerlos la
+primera vez. El registro parcial que sale de ahí no vale solo —cubre menos casos de los que existen— y
+se compone con los veredictos que no se volvieron a medir, diciendo de qué corrida viene cada uno.
+
+## R21 — Retomar empieza por establecer qué quedó hecho
+
+Un trabajo caro que se corta —por un límite, una caída, una interrupción— deja trabajo hecho. Antes de
+volver a lanzarlo se establece cuál es: qué artefactos hay en disco, qué resultados se escribieron, qué
+elementos ya tienen veredicto. Recién con esa lista se decide, y lo que se corre es la diferencia.
+
+«Continuá» no autoriza a relanzar. Pide exactamente lo contrario: seguir desde donde se quedó, que es
+imposible sin haber mirado antes dónde fue. Relanzar entero cobra de nuevo lo que ya se pagó, y quien
+lo pide no tiene cómo saber que eso está pasando —la corrida se ve igual empiece donde empiece—.
+
+Y cuando el pedido sí es relanzar —«de nuevo», «desde cero», «reiniciá»— tampoco se ejecuta derecho:
+primero se entrega el veredicto de lo avanzado y se pregunta si aun así quiere la corrida entera. Puede
+quererla, y hay razones legítimas: el sujeto cambió, lo anterior quedó sospechoso, se busca medir
+varianza. Lo que no puede es tirarse trabajo sin que nadie lo haya decidido.
+
+El veredicto existe para que se pueda decidir, así que tiene que traer con qué. Cuatro cosas:
+
+- **Qué ya tiene resultado**, elemento por elemento, y cuál es.
+- **Qué quedó a medias y si sirve.** Son dos preguntas distintas y la segunda no se contesta viendo que
+  el archivo está.
+- **Cuánto cuesta rehacer cada parte**, con el número de lo que ya se gastó al lado.
+- **Cómo se puede partir.** Casi nunca es todo o nada: si un pedazo cuesta la mitad del total, va
+  separado para que se pueda correr uno y decidir el otro después, con el primero a la vista.
+
+**Lo hecho no es lo aprovechable, y la diferencia sólo se ve mirando.** Un trabajo interrumpido deja
+artefactos que parecen completos: la etapa que escribió su análisis y murió antes de devolverlo se ve
+igual que la que cerró, y los archivos de dos corridas distintas conviven en el mismo directorio sin
+que nada los distinga salvo la fecha. Comprobar cuál es cuál cuesta minutos; suponerlo cuesta la
+corrida entera y encima produce una medición contaminada — un resultado calculado sobre insumos que ya
+fueron sobrescritos, que es peor que no tenerlo porque se lee igual que uno bueno.
+
+Por eso el veredicto puede terminar en «desde cero», y eso no lo invalida. Establecer que no había nada
+rescatable **es** el trabajo de la regla: lo que R21 impide no es relanzar, es relanzar sin saber.
+
+Un elemento que ya tiene veredicto no se vuelve a medir por venir en la misma tanda: cuesta lo mismo que
+la primera vez y su resultado no puede cambiar, que es lo que R20 nombra. Si existe un filtro para correr
+sólo lo que falta, usarlo no es una optimización: es la forma correcta de la corrida.
+
+Un mecanismo de reanudación se comprueba, nunca se supone —R14 no hace excepción con las herramientas
+propias—. Después de reanudar se mira si efectivamente reutilizó: cuántas unidades de trabajo nuevas
+aparecieron, cuánto se gastó. La sesión que originó esta regla creyó estar reanudando desde caché y
+volvió a correr entero dos veces: siete millones de tokens para un solo veredicto, con los archivos de
+las etapas ya cumplidas a la vista en el directorio de trabajo, y con el filtro que lo evitaba escrito
+por quien reanudaba tres horas antes.
+
+## R22 — Lo que se mide no se toca mientras se mide
+
+Mientras una medición corre, el sujeto y todo aquello contra lo que resuelve se quedan quietos. No se
+edita el contrato que se está midiendo, ni el motor que la corrida usa, ni el entorno del que lee.
+
+Lo que lo vuelve difícil de ver es que no avisa. La corrida termina, entrega su resultado y **ese
+resultado se lee exactamente igual que uno limpio**: no hay señal que diga «esto midió dos versiones».
+Quien lo reciba va a decidir sobre él sin saber que se movió el piso.
+
+Y el camino por el que entra casi nunca es el archivo obvio. Un banco desechable puede resolver la
+herramienta por un enlace al repositorio vivo, así que editar ahí cambia lo que la corrida lee sin que
+nada del banco se haya tocado. La pregunta no es «¿toqué el sujeto?» sino «¿toqué algo que el sujeto
+alcanza?».
+
+Si hace falta trabajar igual, se trabaja donde la medición no mira: otra copia, otra rama sin
+materializar, o se espera. Esperar es más barato que descubrir que la tanda no vale.
+
+Y si ya pasó, se dice: qué medición, qué cambió y cuándo. Un resultado cuyo entorno se movió es una
+hipótesis, no un veredicto —lo mismo que R21 nombra para lo que quedó a medias—, y guardarlo sin esa
+marca es la forma cara del error, porque el número sobrevive a la sesión que sabía.
+
+## R26 — Una puerta acota su propio costo y no escribe en el árbol que juzga
+
+Una puerta existe para medir, y una que se lleva la máquina no mide nada: se apaga. Tres límites, y los
+tres se ganaron con una corrida perdida.
+
+**Acota su alcance.** Una puerta opina sobre el repositorio que la declara y no sobre sus vecinos. La
+que juzga a otro frena trabajo que no pidió juzgar y lo hace con reglas que ese equipo no escribió.
+
+**Acota su costo, con un tope y con un candado.** Dos revisores lanzando la misma suite son dos corridas
+simultáneas, y ninguna de las dos lo sabe. En la instancia que originó esta regla fueron cuatro en cuatro
+minutos: el sistema operativo mató la sesión entera con un pico de 24,2 GB y se llevó puesta la corrida
+que estaba a punto de terminar. Y lo que ya se midió no se vuelve a medir: si el build dejó su
+resultado, la puerta lo lee en vez de rehacerlo.
+
+**No escribe en el árbol que juzga.** Un formateador con `--fix`, un build que limpia su salida, un
+gestor que sincroniza antes de arrancar: los tres parecen inocuos y los tres editan el trabajo de quien
+está commiteando, a veces a mitad de camino. La puerta corre sobre una copia, o corre sin la bandera que
+escribe. Este toolkit lo aprendió así —`verify` materializa el índice en un temporal justamente por
+esto— y la regla existe para que la puerta que escribe **la empresa** no lo vuelva a aprender sola.
+
+El remate es la razón de las tres: una puerta que estorba se saltea con la variable de escape, y desde
+ahí no protege de nada. Lo que se negocia es el costo, nunca la exigencia.