@ingeniomaps/cauce 0.93.0 → 0.94.0

package/CHANGELOG.md

@@ -14,6 +14,121 @@ 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.94.0] - 2026-09-16
+
+### Agregado
+
+- **Cinco reglas nuevas, traídas de una empresa que las pagó.** Salieron de revisar las reglas propias de
+  una instancia real: no son ideas, cada una tiene adentro la corrida que costó.
+
+  - **R24 — una premisa sobre el propio código se abre antes de usarla.** R14 ya exigía registro para lo
+    que se afirma de una herramienta o una norma, y dejaba afuera tu propio repositorio, que es donde
+    nadie te va a discutir. Cuatro corridas perdidas en un día, todas frenadas en la puerta y ninguna por
+    el código: la aceptación pedía algo que el sistema no hace. Y el ancla `archivo:línea` se abre, no se
+    copia — una función se movió de la 555 a la 733 en la misma sesión.
+  - **R25 — el identificador de una unidad de trabajo no cambia mientras está viva.** Renombrar un slug a
+    mitad de camino rompe el cruce entre la cola y lo hecho **sin que nada falle**: cada lado se lee
+    coherente por separado. Una tarea partida en cuatro y cerrada con otros nombres costó 594k tokens de
+    la corrida siguiente para descubrir que ya estaba construida. Si el nombre tiene que cambiar, va
+    `slug-nuevo (antes: slug-viejo)` hasta cerrar.
+  - **R26 — una puerta acota su propio costo y no escribe en el árbol que juzga.** Dos revisores lanzando
+    la misma suite fueron cuatro corridas en cuatro minutos: el sistema operativo mató la sesión entera
+    con un pico de 24,2 GB. Y un formateador con `--fix` o un build que limpia su salida editan el trabajo
+    de quien está commiteando. Una puerta que estorba se saltea, y desde ahí no protege de nada.
+  - **R27 — una defensa se aplica por defecto y cada excepción se declara sola.** Con lista de lo que
+    protege, todo lo que se agregue después nace afuera y nada lo compara. Incluye el caso que más se
+    disfraza: «esta comprobación no corre en desarrollo» es una quita escrita como agregado, y garantiza
+    que el camino de producción sea el único que nunca se ejercitó.
+  - **R28 — un estado lo dice el contenido de un archivo, nunca su presencia.** Un centinela cuya única
+    información es existir obliga a que borrarlo sea parte de la resolución, y eso alguien lo olvida: la
+    corrida arranca, lee todo el estado y recién ahí muere. Pasó dos veces el mismo día, a 42k tokens por
+    vez. Es lo que el WIP de Cauce ya hace bien con `status: IDLE`.
+
+- **R9 dice cuándo se puede quitar lo que está en uso.** Exigía probar la ausencia de lo quitado y nunca
+  decía cuándo se puede quitar. Ahora: 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.
+
+  Y lo que no llama nadie es otra cosa: se borra. Cortar de golpe rompe a un consumidor que nadie miró;
+  deprecar lo que nadie usa cuesta mantener dos caminos para nadie.
+
+- **R10 dice a dónde va lo que se publica, no sólo quién lo autoriza.** La autorización decía si se
+  publica y nunca dónde. Ahora: lo que se publica va al repositorio en el que estás trabajando, y si ese
+  remoto es un fork, va al fork — con la rama cortada de la suya, 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, ni lo son que el cambio «obviamente tenga que llegar ahí» ni que un PR anterior haya ido
+  a parar allá. Saltar al principal se pide con todas las letras y para ese caso concreto.
+
+  Es de las pocas sin vuelta atrás: un PR mal apuntado es trabajo publicado en el repositorio de otro
+  equipo — lo vieron, les llegó la notificación, y cerrarlo no deshace nada de eso.
+
+- **R8 dice que la prohibición de firmas de IA cubre todo lo que se 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 escribiste—, así que
+  cumplirla es revisar la salida antes de publicarla, no acordarse de no escribirla.
+
+- **R17 dice qué cuenta como una condición, que es lo que volvía incontable su umbral.** La barra son
+  cinco condiciones de aceptación y nunca decía qué es una. Ahora: una condición es un resultado que se
+  puede mirar por separado, no una viñeta. Cinco viñetas que describen el mismo invariante desde cinco
+  ángulos son **una**, y contarlas como cinco parte por la mitad lo que era una sola cosa.
+
+  La otra dirección es la cara y la 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 se lee igual que una unidad chica.
+
+  La prueba no pide criterio: si al tachar una condición las otras siguen valiendo, son distintas; si
+  tachar una deja a las demás sin sentido, era una sola dicha en partes.
+
+- **R9 ahora pide que la mutación quede escrita, no sólo que se corra.** R9 ya exigía romper, con el
+  código puesto, exactamente lo que el caso dice cuidar, y verlo ponerse rojo. Lo que faltaba es que eso
+  quedara en la aceptación: una línea con qué se rompe y qué prueba tiene que ponerse roja. Sin ella,
+  quien revisa no puede distinguir la mutación que se corrió de la que se pensó, y lo único que le queda
+  es volver a correrla — o sea rehacer el trabajo que delegarlo evitaba.
+
+  Y escribirla antes cambia 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.
+
+  **Lo que cuesta:** el bloque de reglas que cada agente carga al arrancar pasa de **39,1 a 49,1 KB**.
+  Está medido, no estimado, y el umbral del aviso de `check` **no se movió**: sigue en 64 KB, porque lo
+  que mide es cuánto agregaste vos, y subirlo para hacerle lugar al piso apagaría justamente eso. Quedan
+  ~18 KB de margen antes de que el aviso hable.
+
+### Corregido
+
+- **El aviso de peso mide lo que agregaste vos, no el total.** Comparaba el bloque entero contra el
+  umbral, así que el piso del toolkit y tus reglas salían del mismo bolsillo: decía «tu bloque pesa»
+  cuando la mitad la habíamos puesto nosotros, y cada regla que Cauce agregaba te achicaba el margen sin
+  que nadie lo decidiera. Ahora el umbral se compara contra tus reglas, y la línea dice las dos cosas —
+  `114.8 KB en cada agente (93.8 KB propias)`—: el total es lo que paga el agente y lo propio es lo único
+  sobre lo que podés hacer algo.
+
+  **Una instancia recién creada ya no puede cruzarlo**, por más que el piso crezca. Antes era una cuenta
+  que había que rehacer cada vez que agregábamos una regla.
+
+  El número **no se movió**: sigue en 64 KB, a propósito, porque cambiar qué se mide y cuánto a la vez
+  deja sin saber cuál de los dos movió el resultado. Lo que sí quedó medido es que 64 está por debajo de
+  lo que una empresa real usa — una instancia medida tiene 93,8 KB de reglas propias — así que elegirlo
+  con esa evidencia es lo que sigue.
+
+
+- **Escribir tu propio `process.md` ya no te deja sin las reglas que no ibas a reemplazar.** El override
+  es por nombre de archivo, así que reemplazar «pensar antes de editar» por tu versión se llevaba puesto
+  el archivo entero: R16, R17, R20, R21 y R22 dejaban de llegarle a todo agente. `check` te lo decía —lo
+  hace desde 0.57.0— y no había nada que hacer al respecto, porque conservarlas exigía copiar su texto y
+  una copia deja de recibir las mejoras del `upgrade`.
+
+  Ahora **R16, R20, R21 y R22 viven en `system/runs.md`** —lo que cuesta una corrida, cuándo una medición
+  vale, cómo se retoma lo interrumpido y qué no se toca mientras se mide—, un archivo que reemplazar tu
+  proceso no toca. `system/process.md` se queda con R1..R4 y R17.
+
+  **No tenés que hacer nada**: el archivo nuevo llega en tu próximo `upgrade`. Si ya sobrescribiste
+  `process.md`, esas cuatro reglas vuelven a regir solas, y el aviso de `check` se acorta a lo que de
+  verdad reemplazaste. El bloque de reglas pasa de cuatro archivos a cinco y pesa lo mismo: 39,1 KB.
+
 ## [0.93.0] - 2026-09-16
 
 ### Corregido

package/engine/automation/rules.js

@@ -67,38 +67,56 @@ function split(root) {
 function weight(root) {
   const { loaded } = split(root)
   let bytes = 0
+  let own = 0
   const files = []
   for (const file of loaded) {
     try {
       const size = fs.statSync(path.join(root, file)).size
       bytes += size
+      // Lo propio es lo que no vive en `rules/system/`, que es exactamente lo que el proyecto escribió:
+      // una regla del sistema que sobrescribió deja de cargarse y la suya ocupa su lugar, así que
+      // contarla como propia es correcto — la escribió él y la puede achicar.
+      if (!file.includes('/system/')) own += size
       files.push({ file, size })
     } catch { /* la que no está en disco ya la reporta `check` por su lado */ }
   }
-  return { count: loaded.length, bytes, files: files.sort((a, b) => b.size - a.size) }
+  return { count: loaded.length, bytes, own, files: files.sort((a, b) => b.size - a.size) }
 }
 
 const KB = (bytes) => `${(bytes / 1024).toFixed(1)} KB`
 
-// A partir de dónde el peso deja de ser el costo de arrancar y pasa a ser una decisión que conviene mirar.
-// El piso que Cauce impone —las cuatro reglas del sistema— son 38,3 KB, así que un umbral por debajo de
-// eso avisaría en toda instancia recién creada y se apagaría por ruido el primer día: eso descartó los
-// 60 KB que el caso 141 proponía. 64 KB deja ~26 KB para lo propio, que son varias reglas de tamaño
-// normal, antes de que el aviso hable.
+// A partir de dónde lo que el proyecto agregó deja de ser el costo de arrancar y pasa a ser una decisión
+// que conviene mirar. **Se compara contra lo propio y no contra el total**, y esa es la diferencia que
+// hace al número significar algo.
+//
+// Contra el total, el piso del toolkit y las reglas de la empresa salían del mismo bolsillo: el aviso
+// decía «tu bloque pesa» cuando la mitad la habíamos puesto nosotros, y cada regla que Cauce agregaba le
+// achicaba el margen sin que nadie lo decidiera. El 64 tampoco salió de un costo medido: salió de
+// esquivar nuestro propio piso —el caso 141 proponía 60 y se subió porque lo que Cauce ponía ya eran
+// 61,9 KB—, así que había que reelegirlo cada vez que el toolkit enseñaba algo. Medido sobre lo propio,
+// el número deja de depender de nosotros y no se toca cuando el piso crece.
+//
+// El valor sigue siendo el que había, y eso es a propósito: cambiar qué se mide y cuánto a la vez deja
+// sin saber cuál de los dos movió el resultado. Lo que se sabe hoy es que **64 está por debajo de lo que
+// una empresa real usa**: una instancia medida tiene 93,8 KB de reglas propias, así que el aviso le sale
+// desde el día que instaló. Elegir el número con esa evidencia es una decisión aparte, y la cuenta que la
+// habilita está en el 141: 61,9 KB ≈ 15,9 K tokens, o sea ~3,9 KB por 1K tokens en **cada** agente.
 const HEAVY = 64 * 1024
 
 // La línea que declara el peso, para que la digan igual `install` y `check`. Nombra las dos más grandes
 // porque es lo accionable: saber que el bloque pesa no dice cuál conviene declarar por superficie.
 function weightLine(root) {
-  const { count, bytes, files } = weight(root)
+  const { count, bytes, own, files } = weight(root)
   const top = files.slice(0, 2).map((one) => path.basename(one.file)).join(', ')
+  // El total es lo que paga el agente y lo propio es lo único sobre lo que el proyecto puede hacer algo,
+  // así que van los dos: con uno solo, o el número no es el costo real o no es accionable.
   return `el bloque de reglas carga ${count} archivo(s), ${KB(bytes)} en cada agente`
-    + (top ? ` (las más grandes: ${top})` : '')
+    + ` (${KB(own)} propias)${top ? ` (las más grandes: ${top})` : ''}`
 }
 
 // Sólo cuando pasó el umbral. Devuelve lista porque es lo que `check` empalma con el resto de avisos.
 function heavyRules(root) {
-  return weight(root).bytes > HEAVY ? [weightLine(root)] : []
+  return weight(root).own > HEAVY ? [weightLine(root)] : []
 }
 
 // Sin raíz el marcador queda como está —así lo leen las pruebas que revisan el texto de un adaptador—: un

package/package.json

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

package/template/planning/rules/README.md

@@ -2,12 +2,15 @@
 
 `system/` pertenece a Cauce y se reemplaza completo en cada actualización:
 
-- `system/process.md` — R1..R4, R16, R17, R20..R22: planificación, alcance, review, sincronización de
-  estado, medición y retomar lo interrumpido.
-- `system/code-shape.md` — R5..R7, R11, R18: simplicidad y forma del cambio.
+- `system/process.md` — R1..R4, R17, R25, R28: planificación, review, sincronización de estado, cómo se
+  parte una unidad de trabajo y cómo se nombra y se deja escrito su estado.
+- `system/runs.md` — R16, R20..R22, R26: lo que cuesta una corrida, cuándo una medición vale, cómo se
+  retoma lo interrumpido, qué no se toca mientras se mide y qué le cuesta una puerta a quien la corre.
+- `system/code-shape.md` — R5..R7, R11, R18, R27: simplicidad, forma del cambio y cómo se escribe una
+  defensa.
 - `system/commits.md` — R8..R10: historia versionada y entrega.
-- `system/conduct.md` — R12..R15, R19, R23: trato con sistemas externos, lo que llega de ellos, lo que
-  se destruye, y la obligación de entregar al negarse.
+- `system/conduct.md` — R12..R15, R19, R23, R24: trato con sistemas externos, lo que llega de ellos, lo
+  que se afirma del propio código, lo que se destruye, y la obligación de entregar al negarse.
 
 El número es el identificador: una regla se cita por él desde un cargo, un workflow o una entrada de
 DONE, y por eso no se reordena ni se reusa.

package/template/planning/rules/system/code-shape.md

@@ -75,3 +75,22 @@ quedar verde con el defecto adentro sin que sobre un solo doble — lo que falta
 escribió. Por eso se justifica y se reúsa en vez de prohibirse: un doble sin razón escrita se copia, y la
 copia deja de coincidir con lo que reemplaza sin que ninguna prueba lo note.
 
+
+## R27 — Una defensa se aplica por defecto y cada excepción se declara sola
+
+Una defensa escrita como lista de lo que protege deja abierto todo lo que venga después. El día que
+alguien agrega una ruta, un campo o un comando, nace afuera —y no falla nada, porque no hay nada que
+compare la lista con lo que existe—. La ausencia no deja rastro, que es la forma de R15 aplicada a un
+mecanismo en vez de a un entregable.
+
+Se escribe al revés: cerrado por defecto, y cada excepción declarada de a una, con su razón y en el
+mismo lugar. Así lo que se agrega nace protegido y lo que se abre deja constancia de quién lo abrió.
+
+No es una regla de seguridad aunque ahí sea donde más se note. Vale para un guard, para el alcance de un
+lint, para lo que un CI corre, para un permiso: cualquier mecanismo cuya lista alguien tiene que
+acordarse de ampliar.
+
+Y el caso que más se disfraza es la excepción por ambiente. «Esta comprobación no corre en desarrollo»
+es una quita escrita como agregado —R9—, y además garantiza que el camino de producción sea el único que
+nunca se ejercitó. Si hace falta que en desarrollo sea más fácil, se le da a desarrollo lo que necesita
+para pasar la comprobación, no una puerta trasera.

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.