@ingeniomaps/cauce 0.94.0 → 0.96.0

package/CHANGELOG.md

@@ -14,6 +14,244 @@ 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.96.0] - 2026-09-16
+
+### Corregido
+
+- **Tres errores que el CLI contestaba con exit 1 ahora contestan 2, que es lo que dice la convención.**
+  Son «no se llegó a la pregunta»: `integrations/config.json` ilegible, un proveedor que no está en ese
+  registro, y un `package.json` inválido al declarar el motor. Sus hermanos —un `ops.config.json`
+  ilegible, un proveedor que Cauce no trae— ya contestaban 2.
+
+  El corte, que hasta ahora estaba en la cabeza de quien escribía cada salida, está escrito y sale en
+  `ops --help`: **2** es que el comando no existe, falta un argumento, o la raíz que nombrás no es lo que
+  dice ser —lo arreglás cambiando la invocación—; **1** es que se llegó y la respuesta es que no —una
+  validación encontró problemas, el estado se niega, o una operación falló a mitad de camino—.
+
+  Si tenés un script que distingue los dos, revisá esos tres casos. Si sólo mira «distinto de cero», no
+  cambia nada.
+
+- **`ops flow list|check|show` acepta la raíz de la instancia, como el resto.** Todos los comandos que leen
+  una instancia la toman como posicional; `flow` la descartaba y resolvía por el directorio actual, así que
+  `ops flow list <raíz>` contestaba sobre otra cosa — y una lista de recorridos se lee igual de bien venga
+  de donde venga. Ahora es `ops flow list [ops-root]`, y con recorrido va después de él.
+
+- **Una lista de cargos o recorridos vacía dice si es porque no hay o porque no se pudo resolver el
+  paquete.** Eran dos hechos distintos con la misma respuesta, y las acciones son opuestas. El aviso sale
+  por `stderr` y sólo cuando la lista viene vacía; el código de salida y el `--json` no cambian, porque
+  ese JSON lo consume el cron del ciclo de aprendizaje.
+
+- **`automation check` nombra un `ops.config.json` ilegible en vez de culpar al motor.** La resolución del
+  paquete cuelga de esa configuración, así que un JSON roto se propagaba como archivos del motor que faltan
+  y el aviso mandaba a correr `npm install` sobre un motor instalado: la acción sugerida no arreglaba nada.
+
+- **El catálogo de cargos y recorridos se encuentra también cuando el paquete vive un nivel arriba.** Es el
+  layout que documenta el arranque —`npm install @ingeniomaps/cauce` en la carpeta de la empresa y la
+  instancia adentro—, y 0.92.0 lo arregló para el motor y dejó afuera el catálogo. En ese estado `check`
+  pasaba en verde y `agents list` contestaba **una lista vacía con exit 0**, indistinguible de «esta
+  instancia no tiene cargos»; `flow list` igual, y `evaluate` culpaba a un `SKILL.md` que falta, mandando
+  a mirar el cargo en vez del paquete.
+
+  Si te pasó, no hacía falta bajar una segunda copia: con esta versión los cargos aparecen donde ya estaban.
+  Verificado instalando el paquete publicado desde el registro y recorriendo la superficie del CLI: de 0
+  cargos y 0 recorridos a **53 y 7**, sobre la misma instancia.
+
+## [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

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

@@ -22,6 +22,12 @@ const { hasHooks } = require('./config')
 
 function check(root) {
   const errors = []
+  // La configuración se lee primero y se corta ahí. La resolución del paquete cuelga de ella —`declaredRoot`
+  // la parsea— así que un JSON roto se propagaba como archivos del motor que faltan, y el aviso mandaba a
+  // correr `npm install` sobre un motor que está instalado: la acción sugerida no arreglaba nada. Nombrar
+  // la causa y no seguir es lo que separa este aviso del ruido — enumerar ausencias que salen de una causa
+  // ya nombrada manda a arreglar lo que no está roto (caso 174).
+  try { O.mode(root) } catch (error) { return [error.message] }
   const hookDir = path.join(root, 'automatization', 'hooks')
   if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
     errors.push('falta automatization/AGENTS.md')
@@ -52,9 +58,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 = {

package/engine/automation/index.js

@@ -45,9 +45,9 @@ function probeBridge(paths, runner) {
   const problems = []
   // Desde la raíz y desde una carpeta de adentro: si el runner lanza el hook con otro cwd, la ruta
   // relativa de su configuración deja de resolver y eso hay que verlo acá, no en la primera sesión.
-  const sourceRoot = [paths.install, path.dirname(script)]
+  const launchDirs = [paths.install, path.dirname(script)]
   for (const event of hookEvents) {
-    for (const cwd of sourceRoot) {
+    for (const cwd of launchDirs) {
       const payload = JSON.stringify({ toolCall: { args: { CommandLine: 'ls', Cwd: paths.install } } })
       const result = spawnSync(process.execPath, [script, event], { cwd, input: payload, encoding: 'utf8' })
       let response = {}
@@ -75,11 +75,11 @@ function doctor(root, name, output = console) {
   const warnings = []
   try {
     const expected = runnerConfig(paths, root)
-    const actual = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8'))
-    if (!includesConfig(actual, expected)) {
+    const installed = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8'))
+    if (!includesConfig(installed, expected)) {
       errors.push(`${runner.config.target}: configuración instalada incompleta o divergente`)
     }
-    const legacy = legacyGuardWiring(actual)
+    const legacy = legacyGuardWiring(installed)
     if (legacy.length) {
       warnings.push(`${runner.config.target}: ${legacy.join(', ')} siguen registrados sueltos junto al grupo; `
         + 'cada uno se ejecuta dos veces. Borrá esas entradas del archivo para quedarte sólo con el grupo')
@@ -221,6 +221,18 @@ function uninstall(root, name, output = console) {
   }
   const runner = runnerManifest(root, name)
   const paths = runnerPaths(root, name, runner)
+  // La configuración se lee **antes** de borrar nada, aunque se use al final. Leyéndola al final, un
+  // `settings.json` a medio fusionar hacía morir el comando con el mensaje crudo del parser —que no
+  // nombra ni un archivo— con los workflows y los cargos ya borrados: la instancia quedaba a medio
+  // desinstalar, con la configuración registrando guards que no existen. Acá no hay nada que deshacer
+  // porque todavía no se tocó el disco, que es más barato que cualquier rollback.
+  const hasConfig = fs.existsSync(paths.configTarget)
+  let config
+  if (hasConfig) {
+    try { config = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8')) } catch (error) {
+      throw new Error(`${runner.config.target} contiene JSON inválido (${error.message})`)
+    }
+  }
   const prefix = opsPrefix(root)
   const recorded = M.readRunners(root)
   const kept = []
@@ -266,9 +278,8 @@ function uninstall(root, name, output = console) {
     }
   }
 
-  if (fs.existsSync(paths.configTarget)) {
-    const current = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8'))
-    const clean = unmergeConfig(unmergeConfig(current, runnerConfig(paths, root)), runner.config.retired || {})
+  if (hasConfig) {
+    const clean = unmergeConfig(unmergeConfig(config, runnerConfig(paths, root)), runner.config.retired || {})
     if (clean && Object.keys(clean).length) F.atomicWriteJson(paths.configTarget, clean)
     else { removeFile(paths.configTarget, paths.install); removed += 1 }
     output.log(`✓ ${name}: ${runner.config.target} sin las entradas de Cauce`)

package/engine/cli/archive.js

@@ -11,10 +11,7 @@ const P = require('../planning/parser')
 const PC = require('../planning/contracts')
 const AD = require('../planning/adoption')
 const F = require('../core/files')
-const { fail, planningRoot } = require('./io')
-
-// La fecha de hoy, la misma que usan los comandos que leen.
-const TODAY = () => new Date().toISOString().slice(0, 10)
+const { fail, planningRoot, TODAY, USAGE, REFUSED } = require('./io')
 
 // El historial de acciones humanas se acumula en un solo archivo y no por épica: una fila no pertenece
 // a ninguna, y esperar el cierre de una épica dejaría sin archivar las de un planning que todavía no
@@ -33,7 +30,7 @@ function adopt(dir) {
     const existing = fs.readFileSync(target, 'utf8')
     if (!AD.sealWarnings(root).some((one) => /sin huella/.test(one))) {
       fail(`${AD.BASELINE} ya existe: se genera una vez. Para retirar un renglón, ponele \`#~\` `
-        + 'delante; `check` marca los que ya cumplen.')
+        + 'delante; `check` marca los que ya cumplen.', REFUSED)
     }
     const slugs = AD.declared(existing)
     F.atomicWrite(target, existing.replace(/\n?$/, `\n# huella: ${slugs.length} entradas · `
@@ -81,7 +78,7 @@ function archiveHumanActions(root) {
 function archive(dir, rawNum) {
   if (String(rawNum || '') === 'human-actions') return archiveHumanActions(planningRoot(dir))
   return fail('Sólo se archiva `human-actions`. La evidencia de una tarea ya vive en su propio archivo '
-    + 'de `done/`, así que archivar una épica dejó de tener sentido.', 2)
+    + 'de `done/`, así que archivar una épica dejó de tener sentido.', USAGE)
 }
 
 module.exports = { archive, adopt }