@ingeniomaps/cauce 0.93.0 → 0.95.0

package/CHANGELOG.md

@@ -14,6 +14,317 @@ 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.95.0] - 2026-09-16
+
+### Corregido
+
+- **El bloqueo dice hasta dónde llega el «dale».** Ofrece dos salidas y sólo la del pegado decía su
+  alcance —«valen para ese conjunto y dejan de valer en cuanto cambie»—; la del chat, que es la que se
+  ofrece primero, decía sólo «reintentá el mismo cambio y pasa».
+
+  Faltaban **dos** cosas y no son la misma. Que el «dale» cubre lo que se frenó y nada más: por eso en una
+  carpeta donde se itera cada archivo nuevo vuelve a frenar, que desde afuera se lee como si el guard se
+  hubiera olvidado de que ya la aprobaste. Y que lo concedido **sigue valiendo en los mensajes
+  siguientes** hasta que lo niegues — la mitad permisiva, la que no se nota porque lo que no ocurre es un
+  bloqueo. `check` la muestra al final de la corrida; ahora también se dice al concederla.
+
+  No cambia ningún permiso: el diff es texto.
+
+- **Partir una tarea de una épica actualiza también sus historias, así que `check` no queda en rojo.** Una
+  tarea que viene de una épica es además una historia suya, y la partición reemplazaba sólo su línea del
+  BACKLOG. La lista de historias quedaba nombrando un slug que ya no existe en ninguna parte, y eso rompe
+  por los dos lados según qué escriba la partición: con las subtareas declarando la épica, `check` falla en
+  el acto con «BACKLOG \<sub\>: no existe en epic-NNN»; sin declararla pasa en verde y **la épica no puede
+  cerrar nunca**, porque `closed` exige evidencia de cada historia y la original jamás la va a tener.
+
+  Ahí es donde la unidad partida se cierra diciendo en qué se partió, que es lo que pide R25. **No va una
+  entrada en `done/`**: ese directorio es la evidencia de lo que una tarea entregó, y una partida no
+  entregó nada. Una tarea sin épica no necesita ningún cierre — deja de existir limpiamente y no hay
+  cruce que se rompa.
+
+  Si tenés una épica con una historia que ninguna tarea de la cola nombra y que nunca vas a poder cerrar,
+  viene de esto: reemplazá esa historia por las de las subtareas que la partición dejó en el BACKLOG.
+
+- **Un límite escrito en dos líneas ya viaja entero a los agentes.** Una viñeta bajo `### Límites` se
+  recorría línea por línea, así que de un límite que no entraba en el ancho del archivo —que es como se
+  escribe cualquiera de verdad— llegaba **sólo la primera línea**, cortada a mitad de frase. Y lo que se
+  pierde ahí suele ser lo que el límite decide: «…crear, editar o borrar productos, pedidos o» sin el «no
+  las hace un runner» que venía abajo.
+
+  La continuación, además, volvía por el otro lado: no coincidía con ninguna viñeta declarada y `check` la
+  reportaba como un párrafo «que no llega a los agentes», citando media frase tuya. O sea que el proyecto
+  hacía lo que el aviso pedía, el aviso seguía sonando, y el límite que sí viajaba era el mutilado.
+
+  Si escribiste tus límites en una sola línea para que el aviso bajara a cero, ya podés volver a partirlos
+  donde corresponda. Una línea en blanco cierra la viñeta, así que la prosa que venga después sigue sin
+  contar como límite — y sigue avisándose.
+
+- **Una notificación de tarea de fondo ya no borra del chat a la persona que está mirando.** Cuando un
+  guard frena algo, el bloqueo ofrece dos salidas: contestar «dale» —corto, y es lo que la persona ya está
+  haciendo— o pegar líneas a mano en `planning/.ops-approval`. La primera sólo se ofrecía si el registro
+  de la sesión decía que había alguien.
+
+  Una notificación de una tarea de fondo entra por el mismo hook que un mensaje, así que el registro
+  pasaba a decir que el último que habló no era una persona — y en el turno que esa notificación despierta
+  **la persona sigue ahí**. El bloqueo le ofrecía la salida cara y terminaba copiando y pegando un comando
+  que no hacía falta. Se disparaba solo en el patrón más común de una sesión larga: lanzar trabajo de
+  fondo y retomar cuando vuelve.
+
+  Que haya alguien a quien preguntarle pasa a ser de la sesión y no del mensaje. **No cambia ninguna
+  autorización**: preguntar no es conceder, y lo que decide si un «dale» viejo cubre algo nuevo quedó
+  intacto — un mensaje de hace tres turnos sigue sin autorizar lo que se frenó ahora. Y un recorrido de
+  Cauce sigue sin ofrecer el «dale», porque ahí no hay nadie leyendo.
+
+- **Una tarea que `autobuild` parte ya suelta su reserva, así que la corrida sigue.** El recorrido reclama
+  la tarea antes de estimarla, y cuando Decompose la partía el reclamo quedaba puesto sobre un slug que ya
+  no estaba ni en la cola ni en lo hecho. Con eso el runner quedaba ocupado por una tarea que no existe: el
+  Claim de la primera subtarea se negaba —«este runner ya tiene …»— y la corrida entera terminaba en
+  `claim-stuck` **sin construir nada**, dejando además `check` en rojo con un reclamo huérfano que soltaba
+  una persona a mano.
+
+  No dependía de una carrera ni de un id de runner compartido, que es a lo que el mensaje mandaba a mirar:
+  pasaba siempre que Decompose partiera, que es una fase que el propio protocolo manda correr. Si venís de
+  una versión anterior y tenés un reclamo huérfano de esto, se suelta con
+  `node tools/ops.js release planning <tarea>`.
+
+  La reserva se suelta **después** de comprobar que el reemplazo en el BACKLOG ocurrió: si no ocurrió, la
+  tarea sigue viva y su reserva tiene que seguir puesta.
+
+- **Un veredicto se lee de una sola forma, así que las dos cuentas de un registro coinciden.** El registro
+  de una evaluación transcribe la respuesta literal del cargo —es la evidencia de la corrida—, así que su
+  cuerpo puede traer cualquier cosa, incluida una línea con forma de veredicto. La cuenta de la última
+  corrida las tomaba todas y la cuenta compuesta sólo las que cuelgan de un `### <caso>`: dos números
+  distintos sobre el mismo archivo y ninguna forma de saber cuál valía.
+
+  Con un registro de dos casos cuya respuesta citaba un veredicto ajeno, la última corrida decía «2 de 3»
+  sobre una corrida que midió dos y pasó las dos. Ahora un veredicto es un caso con su línea —sin
+  encabezado no hay a qué atribuirlo— y las dos lecturas salen del mismo lugar.
+
+- **Un `agents fork` que se corta a la mitad se retira en vez de quedarse puesto.** Si el copiado fallaba
+  —un archivo ilegible, disco lleno— quedaba medio cargo en `agents/`, y lo caro no es perder la copia: es
+  dejarla. El catálogo pasa a resolver el slug contra esa copia, así que el intento siguiente ya no dice
+  que se cortó sino **«ya lo mantiene esta empresa»** — y lo que la empresa mantiene es un contrato
+  incompleto que ningún manifiesto registra, o sea que el aviso de deriva tampoco lo mira nunca.
+
+  Verificado provocando el corte con un archivo ilegible: antes el segundo intento contestaba «ya lo
+  mantiene esta empresa» con `.cauce` vacío; ahora no queda nada en `agents/` y arreglando lo que lo
+  cortó el fork sale entero. Sólo se borra lo que esa llamada creó, y la ruta se comprueba contra la raíz
+  de la instancia antes de tocarla.
+
+- **`automation uninstall` no borra nada si no puede leer la configuración de tu runner.** Borraba
+  primero y leía el `settings.json` al final, con un `JSON.parse` sin proteger. Con un archivo que alguien
+  dejó a medio fusionar, el comando moría con «Expected property name or '}' in JSON at position 13»
+  —que no nombra ni un archivo— **después** de haber borrado los workflows y los cargos: la instancia
+  quedaba a medio desinstalar, con la configuración registrando guards que ya no existen.
+
+  Verificado sobre un banco: el comando se para antes de tocar el disco, dice qué archivo no pudo leer, y
+  arreglando ese archivo vuelve a correr.
+
+- **Un adaptador propio que no trae `components` ya no rompe el borrador.** El README declara el contrato
+  de un adaptador por sus tres funciones y no dice qué campos trae un item, así que un adaptador de la
+  empresa —que es lo que ese README invita a escribir— puede no traerlo. Con `serviceFrom: "component"`,
+  que es lo que trae el molde, eso era un `TypeError` sobre `undefined` sin nada que lo atribuyera.
+
+  Sin el campo la respuesta es la que el borrador ya sabía dar: `service: ""` y «Debe definirse un
+  servicio único para la promoción». Lo que se toleró es la ausencia y no el caso de uso: con un
+  componente sigue resolviendo el servicio y con dos sigue sin resolverlo.
+
+- **`promotionEpic` se valida también cuando la promoción es una épica.** El campo se exigía `NNN` sólo
+  para una historia. Para una épica es opcional —sin él el número lo elige el motor—, y por eso nadie lo
+  miraba; pero cuando está se usa tal cual para armar el nombre del archivo. O sea que el único caso sin
+  validar era el único que escribe una ruta con lo que diga el campo.
+
+  `promotionEpic: 7` producía `epic-7-…`, que el roadmap no reconoce como épica: la promoción se anunciaba
+  bien y lo escrito quedaba invisible para la cola. Y con un `..` la épica salía de `roadmap/` entera.
+  Verificado sobre una instancia desechable: `integration check` daba exit 0 y `integration promote`
+  devolvía «✓ jira:DEMO-42 promovido como epic» dejando el archivo fuera del roadmap. Ahora `check` lo
+  rechaza con «promotionEpic debe ser NNN» y `promote`, que valida antes de escribir, no llega a tocar el
+  disco.
+
+- **El aviso de commits sin entrada de DONE vuelve a decir lo que ve.** El filtro por fecha leía la
+  columna del `git log` en una posición fija, y `%h` no mide siempre lo mismo: git sube el largo del hash
+  abreviado solo cuando el repositorio crece. En cuanto pasa de siete, la posición fija lee un espacio en
+  vez de la fecha y **ningún commit pasa el filtro**, así que el aviso quedaba mudo sin decir por qué —la
+  peor forma de que una puerta falle, porque se lee igual que «no hay nada que avisar»—. Ahora se parte
+  por espacios y se lee el campo.
+
+  Verificado en este repositorio, donde el abreviado mide ocho: el aviso pasó de cero a «66 commit(s)
+  desde 2026-09-15 que ninguna entrada de DONE nombra». La prueba nueva lo fija en 7, 8 y 12.
+
+- **El sello de un registro de evaluación se escribe en el frontmatter y no en el cuerpo.**
+  `markConsolidated` buscaba `status:` en el documento entero. Un registro nace sin `status` en su
+  frontmatter y su cuerpo transcribe la respuesta literal del cargo: si esa respuesta traía una línea
+  `status: <algo>` en la columna cero, el sello aterrizaba ahí y el frontmatter quedaba sin sellar.
+
+  Un registro sin sellar vuelve a entrar en la propuesta siguiente, o sea que el mismo hallazgo llega dos
+  veces — que es exactamente lo que sellar existe para evitar.
+
+- **`ops -h` pide la ayuda, y un nombre heredado de `Object` ya no pasa por comando.** Dos huecos de la
+  puerta de entrada del CLI, los dos de la misma forma: leer algo que no era ni un comando ni una bandera.
+
+  `-h` se anunciaba en el uso y no existía: el parser sólo reconoce lo que empieza con `--`, así que caía
+  de argumento posicional y `ops check -h` contestaba «no existe el planning en …/-h» **saliendo con 0**.
+  Pedir ayuda y recibir un error sobre un directorio inventado es la peor forma de contestar, porque
+  parece que el comando corrió.
+
+  Y la tabla de comandos se consultaba con `FLAGS[comando]`, que resuelve contra `Object.prototype`:
+  `ops constructor` salía con 0 sin hacer nada y `ops toString --json` moría con
+  «FLAGS[command].includes is not a function». No es un nombre exótico — es lo que sale de pasarle al CLI
+  una variable que vino vacía o mal leída desde un script.
+
+- **El tope de horas de una propuesta deja de desaparecer cuando la configuración no lo declara.** La
+  validación de propuestas lee `runner.maxTaskHours` de `ops.config.json` y tenía un default de cuatro
+  horas para cuando no se puede leer. Ese default sólo cubría el archivo ilegible: un `runner` sin el
+  campo no lanza nada, así que el tope quedaba en `undefined` y la comparación pasaba a ser falsa
+  siempre. O sea que el límite no se aflojaba: se iba entero, y en silencio.
+
+  Se nota poco a propósito de lo que es — lo que deja de pasar es un **rechazo**—, así que una propuesta
+  de cuarenta horas viajaba a Jira sin que nada la mirara. Verificado sobre una configuración con
+  `runner: {}`: antes no salía ni un error, ahora sale «supera 4h; debe dividirse o justificarlo».
+
+  Si tu `ops.config.json` declara `maxTaskHours`, nada cambia — `check` ya lo exigía mayor que cero.
+
+- **`rm -r` sobre la raíz o el home se frena también entrecomillado.** La regla reconocía el destino sólo
+  desnudo: `rm -rf /` bloqueaba y `rm -rf "/"`, `rm -rf "$HOME"`, `rm -rf ${HOME}`, `rm -rf $HOME/` y
+  `rm -rf -- /` pasaban. La comilla es lo que más importa — citar una variable es la forma *correcta* de
+  escribirlo en bash, así que el hueco premiaba al que tiene el hábito bueno.
+
+  Los borrados con destino concreto siguen pasando, también entrecomillados: se comprobó con
+  `rm -rf "$HOME/proyecto/dist"` entre otros cinco.
+
+- **Un commit escrito en dos líneas vuelve a pasar por los guards.** `isCommit` reconocía el commit
+  después de `;`, `&` o `|` y no después de un salto de línea ni dentro de un subshell — o sea que
+  `git add x` ⏎ `git commit -m x` en un solo Bash, que es como se escriben dos pasos, dejaba sin correr
+  `governance`, `dependencies` y `verify`, y también el bloqueo que impide stagear y commitear a la vez.
+
+  `bash -c "git commit …"` sigue sin reconocerse, a propósito: hacerlo exige desentrecomillar, y eso
+  choca con que el mensaje de un commit sea dato y no código.
+
+- **Redirigir con `>|` ya no evade el guard que mira a dónde escribe un comando.** `>|` es el override de
+  `noclobber` y escribe igual que `>`, pero el guard no veía su destino: el comando se partía en segmentos
+  por `|` antes de buscar destinos, así que la redirección quedaba separada de su ruta. Verificado sobre
+  un banco: `echo x > <fuera>` y `echo x >> <fuera>` bloqueaban y `echo x >| <fuera>` pasaba.
+
+  Importa porque una de las rutas que se escriben por ese hueco es `planning/.ops-approval` — la
+  aprobación que después habilita el push a la rama viva—, que es lo que cerraron el 098 y el 119.
+
+  Las tuberías corrientes siguen sin producir destino: se comprobó con `ls | wc -l` y `a || b`.
+
+## [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/automatization/workflows/autobuild.js

@@ -650,8 +650,23 @@ while (rounds++ < MAX_TASKS) {
       )
       if (!estimate) return stop('agent-unavailable', 'Decompose no devolvió resultado')
       if (estimate.needsSplit) {
+        // Una tarea que viene de una épica es además una historia suya, y la lista de historias no se
+        // actualizaba sola: quedaba nombrando un slug que ya no existe en ninguna parte. Medido sobre un
+        // banco, eso rompe por los dos lados según qué escriba el agente — con las subtareas declarando
+        // la épica, `check` se pone en rojo en el acto («BACKLOG <sub>: no existe en epic-NNN»); sin
+        // declararla pasa en verde y la épica **no puede cerrar nunca**, porque `closed` exige evidencia
+        // de cada historia y la original jamás la va a tener.
+        //
+        // Es lo que R25 pide al decir que la unidad partida se cierra diciendo en qué se partió, y el
+        // lugar donde eso se dice es la épica: ahí es donde la unidad vivía. En `done/` no va —su README
+        // declara que es la evidencia de lo que una tarea **entregó**, y una partida no entregó nada—
+        // (caso 169).
+        const historias = task.epic
+          ? ` ${task.id} es una historia de la épica ${task.epic}: reemplazá también ahí su historia por `
+            + 'las de las subtareas, con el mismo criterio y el mismo service que traía.'
+          : ''
         await write(`Reemplazá sólo ${task.id} en ${BACKLOG} por subtareas ordenadas y verificables de forma ` +
-          `independiente: ${JSON.stringify(estimate.subtasks)}.`, { label: 'split' })
+          `independiente: ${JSON.stringify(estimate.subtasks)}.${historias}`, { 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
@@ -661,6 +676,18 @@ while (rounds++ < MAX_TASKS) {
           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ó.')
         }
+        // La tarea partida ya no existe, así que su reclamo no reserva nada: lo único que hace es dejar
+        // al runner ocupado por un slug que no está ni en la cola ni en lo hecho. Ahí el Claim de la
+        // primera subtarea se niega —«este runner ya tiene …»— y la corrida entera para con
+        // `claim-stuck` sin construir nada. El reclamo lo puso esta corrida; soltarlo también le toca.
+        //
+        // Va **después** de la guarda de arriba y no antes de leer el contexto: si el reemplazo no
+        // ocurrió, la tarea sigue viva y su reclamo tiene que seguir puesto (caso 163).
+        await write(
+          `Corré "node tools/ops.js release ${P} ${task.id}" desde ${ROOT}: quedó partida y su reserva `
+          + 'ya no aplica. No escribas ningún archivo vos: lo escribe el comando.',
+          { label: `release:${task.id}` },
+        )
         log(`${task.id} quedó partida: la corrida sigue con ${nextUp(planning)}`)
         continue
       }

package/engine/agents/evaluations.js

@@ -186,6 +186,22 @@ function nextResult(root, agent, date, kind) {
   return `${date}-${run}.md`
 }
 
+// Qué veredictos trae un registro, leídos en un solo lugar porque `latest` y `composed` contestan sobre
+// el mismo archivo y contestaban distinto: `latest` contaba cualquier línea `- Veredicto:` y `composed`
+// sólo la que cuelga de un `### <caso>`. La diferencia no es teórica — el registro transcribe la
+// respuesta literal del cargo, así que una respuesta que cita un veredicto ajeno sumaba un caso que no
+// existe, y `latest` decía «2 de 3» sobre una corrida que midió dos y pasó las dos.
+//
+// Un veredicto es un caso con su línea, nunca una línea suelta: sin el encabezado no hay a qué atribuirlo.
+const VERDICT = /\n###\s+([^\n]+)\n\n-\s*Veredicto:\s*(pasa|no pasa)\s*$/gim
+
+function caseVerdicts(text) {
+  return [...text.matchAll(VERDICT)].map((hit) => ({
+    id: hit[1].trim(),
+    passed: hit[2].toLowerCase() === 'pasa',
+  }))
+}
+
 // El último resultado registrado, para que `evaluate` pueda decir si el cargo se corrió alguna vez y
 // cómo le fue. No es un error no tenerlo: correrlo cuesta, y exigirlo en CI sería exigir red.
 function latest(root, agent, kind) {
@@ -195,7 +211,7 @@ function latest(root, agent, kind) {
   const name = names[names.length - 1]
   const file = path.join(dir, name)
   const text = fs.readFileSync(file, 'utf8')
-  const verdicts = [...text.matchAll(/^-\s*Veredicto:\s*(pasa|no pasa)\s*$/gim)].map((hit) => hit[1].toLowerCase())
+  const verdicts = caseVerdicts(text)
   const [, date, run] = name.match(RESULT_NAME)
   return {
     file,
@@ -204,7 +220,7 @@ function latest(root, agent, kind) {
     date,
     run: Number(run || 1),
     total: verdicts.length,
-    passed: verdicts.filter((verdict) => verdict === 'pasa').length,
+    passed: verdicts.filter((verdict) => verdict.passed).length,
   }
 }
 
@@ -225,9 +241,8 @@ function composed(root, agent, kind) {
   for (const name of names) {
     const file = path.join(dir, name)
     const [, date] = name.match(RESULT_NAME)
-    const pattern = /\n###\s+([^\n]+)\n\n-\s*Veredicto:\s*(pasa|no pasa)\s*$/gim
-    for (const hit of fs.readFileSync(file, 'utf8').matchAll(pattern)) {
-      current.set(hit[1].trim(), { passed: hit[2].toLowerCase() === 'pasa', date, file })
+    for (const one of caseVerdicts(fs.readFileSync(file, 'utf8'))) {
+      current.set(one.id, { passed: one.passed, date, file })
     }
   }
   const entries = [...current.entries()]

package/engine/agents/fork.js

@@ -16,7 +16,7 @@ const path = require('node:path')
 const catalog = require('./catalog')
 const manifest = require('../core/manifest')
 const ownership = require('../core/ownership')
-const { atomicWrite } = require('../core/files')
+const { atomicWrite, assertWithin } = require('../core/files')
 
 // Informes, propuestas y veredictos no viajan: son lo que produjo nuestra versión del contrato, y el
 // fork nace para dejar de ser ese contrato. Heredar un veredicto le daría a la copia una garantía que
@@ -80,13 +80,26 @@ function fork(root, slug, date) {
   const fromPath = `agents/${type}/system/${slug}`
   const toPath = `agents/${type}/${slug}`
   const digests = {}
-  for (const relative of files) {
-    const from = path.join(found.dir, relative)
-    const to = path.join(target, relative)
-    fs.mkdirSync(path.dirname(to), { recursive: true })
-    if (TEXT.test(relative)) fs.writeFileSync(to, fs.readFileSync(from, 'utf8').split(fromPath).join(toPath))
-    else fs.copyFileSync(from, to)
-    digests[relative] = manifest.digest(from)
+  try {
+    for (const relative of files) {
+      const from = path.join(found.dir, relative)
+      const to = path.join(target, relative)
+      fs.mkdirSync(path.dirname(to), { recursive: true })
+      if (TEXT.test(relative)) fs.writeFileSync(to, fs.readFileSync(from, 'utf8').split(fromPath).join(toPath))
+      else fs.copyFileSync(from, to)
+      digests[relative] = manifest.digest(from)
+    }
+  } catch (error) {
+    // Lo caro de un copiado cortado no es perder la copia: es dejarla. Con medio cargo puesto el
+    // catálogo pasa a resolver el slug contra esa copia, así que el intento siguiente no dice «se
+    // cortó» sino «ya lo mantiene esta empresa» —y lo que la empresa mantiene es un contrato
+    // incompleto que ningún manifiesto registra, o sea que `drift` tampoco lo mira—.
+    //
+    // Se borra sólo lo que esta llamada creó: `target` se comprobó inexistente antes de empezar, y
+    // `assertWithin` lo nombra contra la raíz de la instancia antes de tocar nada —el slug entra por
+    // la línea de comandos y ésta es la única parte de este archivo que destruye—.
+    fs.rmSync(assertWithin(root, target, `el fork de ${slug}`), { recursive: true, force: true })
+    throw error
   }
 
   const version = packageVersion(root)

package/engine/agents/learning-sources.js

@@ -175,12 +175,12 @@ function pendingSources(text) {
       if (one) out.push(one)
       one = {}
       last = ''
-      const primero = line.match(/^\s{2}-\s*(name|url|why|since):\s*(.+?)\s*$/)
-      if (primero) { one[primero[1]] = quitar(primero[2]); last = primero[1] }
+      const first = line.match(/^\s{2}-\s*(name|url|why|since):\s*(.+?)\s*$/)
+      if (first) { one[first[1]] = quitar(first[2]); last = first[1] }
       continue
     }
-    const campo = line.match(PENDING_FIELD)
-    if (campo && one) { one[campo[1]] = quitar(campo[2]); last = campo[1]; continue }
+    const field = line.match(PENDING_FIELD)
+    if (field && one) { one[field[1]] = quitar(field[2]); last = field[1]; continue }
     const sigue = line.match(/^\s{6,}(\S.*?)\s*$/)
     if (sigue && one && last) one[last] += ` ${sigue[1]}`
   }
@@ -229,9 +229,9 @@ function evaluate(root, agent) {
     // Una pendiente sin razón es un enlace muerto con fecha, y sin fecha no se puede ver que lleva
     // meses ahí. Los dos campos son la mitad del valor de la lista: lo que la vuelve revisable.
     for (const one of pendingSources(fs.readFileSync(sourcesFile, 'utf8'))) {
-      const falta = ['name', 'why', 'since'].filter((campo) => !one[campo])
-      if (falta.length) {
-        errors.push(`sources.yaml: una pendiente no declara ${falta.join(' ni ')}`
+      const missing = ['name', 'why', 'since'].filter((key) => !one[key])
+      if (missing.length) {
+        errors.push(`sources.yaml: una pendiente no declara ${missing.join(' ni ')}`
           + `${one.name ? ` (${one.name})` : ''}`)
       }
       // Declarada y pendiente a la vez es una contradicción que el chequeo semanal no puede resolver:

package/engine/agents/learning.js

@@ -18,16 +18,25 @@ const { SOURCE_TIERS, cadence, evaluate, evaluateTeam } = require('./learning-so
 // consolidó y el que se escribió tarde —después de que la propuesta del período ya existía, y por eso
 // no entra a ninguna— se leían igual. El segundo no es un descuido de forma: es un hallazgo que no
 // llega al contrato y que nada delata. Marcar al primero es lo que deja ver al segundo.
+// El sello se busca **dentro del frontmatter** y no en el documento entero. Un registro de corrida nace
+// sin `status` ahí y su cuerpo lleva la respuesta verbatim del cargo: si esa respuesta traía una línea
+// `status: <palabra>` a columna cero, el sello caía en el cuerpo y el frontmatter quedaba sin marcar —o
+// sea el registro sin sellar, y el mismo hallazgo entrando a la propuesta siguiente, que es exactamente
+// lo que sellar existe para evitar (caso 168).
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/
+const STATUS_LINE = /^status:\s*\S+\s*$/m
+
 function markConsolidated(file) {
   const text = fs.readFileSync(file, 'utf8')
-  if (/^status:\s*\S+\s*$/m.test(text)) {
-    return atomicWrite(file, text.replace(/^status:\s*\S+\s*$/m, 'status: consolidated'))
+  const front = text.match(FRONTMATTER)
+  if (front && STATUS_LINE.test(front[1])) {
+    return atomicWrite(file, text.replace(front[0],
+      `---\n${front[1].replace(STATUS_LINE, 'status: consolidated')}\n---\n`))
   }
   // Un informe nace con `status`; un registro de corrida no, porque lo escribe el recorrido de
   // evaluación y ahí el dato no existía. Se agrega en vez de exigirle a quien lo escriba que se
   // acuerde: el sello es lo que evita que el mismo hallazgo entre dos veces, y depender de una
   // convención para eso es depender de que nadie la olvide.
-  const front = text.match(/^---\n([\s\S]*?)\n---\n/)
   if (!front) return
   atomicWrite(file, text.replace(front[0], `---\n${front[1]}\nstatus: consolidated\n---\n`))
 }
@@ -206,9 +215,9 @@ function verdictFindings(root, dir) {
   // encabezado, así que uno que escape puede hacer que se lea la sección equivocada.
   const nested = (detail) => detail.replace(/^(#{1,5}) /gm, '#$1 ')
   const findings = [...latest.values()].flatMap((item) => {
-    const corrida = `Corrida: \`${path.relative(root, item.file)}\``
+    const runLine = `Corrida: \`${path.relative(root, item.file)}\``
     if (!item.passed) {
-      return [`### ${item.id} — ${item.name.slice(0, -3)}\n\n${corrida}`
+      return [`### ${item.id} — ${item.name.slice(0, -3)}\n\n${runLine}`
         + `${item.failures > 1 ? ` — falló en ${item.failures} corridas de esta tanda` : ''}\n\n`
         + `${nested(item.detail)}`]
     }
@@ -222,7 +231,7 @@ function verdictFindings(root, dir) {
     // y ahí una línea con este prefijo sería una nota que el sujeto se escribe a sí mismo.
     const note = (item.detail.split('\n', 1)[0].match(CONTRACT_NOTE) || [])[1]
     return note
-      ? [`### ${item.id} — ${item.name.slice(0, -3)} · el caso pasa\n\n${corrida}\n\n`
+      ? [`### ${item.id} — ${item.name.slice(0, -3)} · el caso pasa\n\n${runLine}\n\n`
         + `Lo que el contrato no cubre: ${note.trim()}`]
       : []
   })

package/engine/automation/check.js

@@ -52,9 +52,9 @@ function check(root) {
   }
   // Un choque que `upgrade` conservó (caso 110) también queda distinto del paquete, y mandarlo a correr
   // `upgrade` era una vuelta sin salida: lo conservaría otra vez. Se dice qué es y qué hacer.
-  const choques = new Set(O.collisions(root))
+  const collisions = new Set(O.collisions(root))
   for (const { file, edited } of staleHooks(root)) {
-    if (choques.has(`automatization/hooks/${file}`)) {
+    if (collisions.has(`automatization/hooks/${file}`)) {
       errors.push(`automatization/hooks/${file}: es tuyo y se llama como uno que trae el paquete, así que el `
         + "del paquete no está instalado; renombrá el tuyo y corré `cauce upgrade`")
       continue

package/engine/automation/config.js

@@ -173,16 +173,16 @@ function isSharedFile(root, target) {
 }
 
 function withoutBlock(text, name) {
-  const sourceRoot = text.indexOf(blockStart(name))
-  if (sourceRoot === -1) return text
-  const until = text.indexOf(blockEnd(name), sourceRoot)
+  const from = text.indexOf(blockStart(name))
+  if (from === -1) return text
+  const until = text.indexOf(blockEnd(name), from)
   if (until === -1) return text
-  return `${text.slice(0, sourceRoot)}${text.slice(until + blockEnd(name).length)}`.trimEnd()
+  return `${text.slice(0, from)}${text.slice(until + blockEnd(name).length)}`.trimEnd()
 }
 
 function mergeInstruction(file, name, content) {
-  const actual = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
-  const instructionBody = withoutBlock(actual, name).trimEnd()
+  const current = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+  const instructionBody = withoutBlock(current, name).trimEnd()
   const block = `${blockStart(name)}\n\n${content.trim()}\n\n${blockEnd(name)}\n`
   F.atomicWrite(file, instructionBody ? `${instructionBody}\n\n${block}` : block)
 }
@@ -190,10 +190,10 @@ function mergeInstruction(file, name, content) {
 function blockUpToDate(file, name, content) {
   if (!fs.existsSync(file)) return false
   const body = fs.readFileSync(file, 'utf8')
-  const sourceRoot = body.indexOf(blockStart(name))
+  const from = body.indexOf(blockStart(name))
   const until = body.indexOf(blockEnd(name))
-  if (sourceRoot === -1 || until === -1) return false
-  return body.slice(sourceRoot + blockStart(name).length, until).trim() === content.trim()
+  if (from === -1 || until === -1) return false
+  return body.slice(from + blockStart(name).length, until).trim() === content.trim()
 }
 
 module.exports = {