@ingeniomaps/cauce 0.88.0 → 0.89.0

package/CHANGELOG.md

@@ -14,6 +14,135 @@ 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.89.0] - 2026-09-14
+
+### Agregado
+
+- **`check` te avisa de una condición de aceptación que no se va a poder comprobar, antes de que el
+  recorrido la construya.** Verify corre antes que Commit y que Done, así que una condición que pide ver
+  el commit, el reclamo, `done/` o la evidencia registrada pide algo que todavía no existe cuando se la
+  mira. El recorrido ya lo frenaba —y hace bien—, pero recién en Verify: en la corrida que originó esto
+  fueron **1,2 M de tokens y once agentes** para terminar con el trabajo hecho, sin commit y sin poder
+  cerrar la tarea.
+
+  Ahora sale de `check`, cuesta un regex sobre la cola y corre en los cuatro carriles, incluidos los que
+  saltean Ready. Avisa y no falla.
+
+  El aviso dice qué hacer: esa cláusula va en `tests:`, `qa:` o `commit:` de la entrada de DONE, que ya la
+  exigen, así que repetirla en la aceptación no agrega garantía sino un bloqueo. **Y si de verdad va ahí,
+  se declara y deja de avisarse**: `(fuera de verify: <razón>)` dentro de la propia condición, la misma
+  salida explícita que `(sin partir: …)` y que `n/a — razón`. Se juzga condición por condición, así que
+  declarar una no exime a las demás.
+
+- **Una regla propia puede declarar sobre qué superficie rige, y entonces se nombra sin cargarse.** Todo
+  lo que `planning/rules/` contiene viaja en el contexto de arranque de **cada** agente —medido: sólo las
+  cuatro reglas que trae Cauce son 38,3 KB por agente—, así que una regla de dos páginas que importa en
+  una tarea de cada cien se leía cien veces.
+
+  Ahora una regla puede llevar `aplica: <superficie>` en su frontmatter. El bloque que escribe
+  `automation install` la lista —`- ruta (aplica: pagos)`— en lugar de importarla: pesa una línea en vez
+  de su archivo entero. **Sigue rigiendo igual**: `ops context` la devuelve entre las reglas del proyecto
+  y el recorrido se la nombra a cada agente que toca código, para que quien trabaje sobre esa superficie
+  la lea antes de planificar o construir.
+
+  **Sin el campo, la regla se carga como siempre, y por eso este cambio no te pide hacer nada.** El
+  default es ése a propósito: una regla que no se leyó no existe, así que apartarla del arranque es una
+  decisión del proyecto y nunca algo que se deduzca. El valor lo elegís vos —`pagos`,
+  `infraestructura`— y lo único que tiene que lograr es que quien lo lea sepa cuándo le toca. Conviene
+  para lo que es de un dominio acotado; lo que gobierna cómo se trabaja se paga y se carga.
+
+- **`automation install` te dice lo que ese bloque va a pesar, y `check` avisa cuando ya pesa demasiado.**
+  Escribir una regla propia encarece todas las corridas futuras de todos los agentes, y hasta acá no lo
+  decía nadie: había que sumar los tamaños a mano después de una corrida cara para enterarse.
+
+  Al instalar, una línea declara cuántos archivos carga el bloque, cuánto pesan y cuáles son los dos más
+  grandes —`el bloque de reglas carga 4 archivo(s), 38.3 KB en cada agente (las más grandes: conduct.md,
+  process.md)`—. Y `check` lo repite como advertencia cuando el total pasa de **64 KB**, que es el umbral
+  elegido para dejar unos 26 KB de reglas propias por encima del piso que trae Cauce: más abajo avisaría
+  en toda instancia recién creada y se apagaría por ruido el primer día.
+
+  **El número va en KB y no en tokens** a propósito. Los bytes los mide el motor y se pueden comprobar;
+  la equivalencia en tokens depende del modelo y del tokenizador, y una cifra estimada en una salida que
+  se cita para decidir vale menos que una exacta. Como referencia, en el repositorio de Cauce esos 38,3 KB
+  rondaron los 10 K tokens medidos una vez, pero eso es una observación y no un factor de conversión.
+
+  Una regla declarada con `aplica:` no suma en ninguno de los dos números: es justamente lo que se apartó
+  del arranque, y contarla haría que declararla no sirviera de nada.
+
+### Corregido
+
+- **El ciclo de aprendizaje ya no te pide una firma por una propuesta que no decide nada.** El documento
+  se compone en dos tiempos: `learn --proposal` lo arma desde los informes y los veredictos, y
+  `/agent-propose` escribe el cambio concreto. El ciclo automático corre el primero y abría el PR ahí
+  mismo, con «Cambio propuesto» todavía en el molde — así se gastaron siete firmas el 2026-09-14, y
+  ninguna de esas propuestas se pudo aplicar.
+
+  Ahora el paso que compone dice si el documento quedó sin decidir y el que publica lo lee. **La rama se
+  empuja igual**, porque lleva el sello de los informes que el ciclo consumió y perderlo haría entrar el
+  mismo material el mes siguiente; lo que se posterga es sólo el PR. La corrida lo deja anotado con el
+  nombre de la rama y qué falta para abrirlo.
+
+  Y `ops learn <cargo> --proposal` lo dice también cuando lo corrés a mano: «sin cambio decidido: falta
+  correr agent-propose antes de que esto se pueda firmar». Sin esa línea el archivo se ve terminado y no
+  lo está.
+
+- **En `mode: sidecar`, `ops context` ya no te esconde tu propio plan.** El id de un runner sale de
+  `CAUCE_RUNNER` y, sin ella, del repositorio git desde el que corrés el comando. Cuando la instancia es su
+  **propio repositorio** —lo habitual: `<empresa>/` y `<empresa>-ops/` al lado— hay dos raíces, y el mismo
+  agente recibe un id distinto según desde cuál invoque. El reclamo queda guardado con uno, el plan se
+  escribe bajo ese mismo, y la sesión que pregunta desde el otro recibe `WIP idle` y `TAKEN … vos, desde
+  otro runner`: el plan existe, con sus pasos ya tildados, y nadie lo nombra.
+
+  Ahora `context` lo nombra. Cuando una tarea tomada es tuya y hay un plan escrito bajo el otro id, agrega
+  una línea `PLAN` con el archivo y con el `export CAUCE_RUNNER` que lo recupera. Y **`ops claim` imprime
+  ese id al tomar la tarea**, que es el momento en que se conoce: hasta ahora sólo lo hacía `ops worktree`,
+  y en sidecar no se crea ningún worktree, así que el dato no quedaba escrito en ninguna parte.
+
+  El id sigue sin ser estable, y eso no cambia: derivarlo de quién sos en vez de dónde corrés le devolvería
+  a cada agente de la máquina la tarea del otro, que es peor que no encontrar la propia. Lo que cambia es
+  que dejó de ser mudo.
+
+- **`automation install` te dice dónde quedaron los recorridos cuando no es donde estás parado.** En
+  sidecar el adaptador se instala en la carpeta de la empresa y no en el repo ops desde el que corrés el
+  comando. Eso es correcto y no cambió —es donde el runner ve el código—; lo que engañaba era la salida.
+  Avisaba «el runner se abre en `<raíz>` — ahí queda su configuración» para un archivo, y a continuación
+  nombraba los recorridos en relativo, `.claude/workflows/autobuild.js`, que leído desde el repo ops apunta
+  a una carpeta vacía. Cerraba en «adaptador operativo (0 advertencia(s))», y todo era cierto.
+
+  Lo que cuesta es que un recorrido se invoca **por nombre**, y el nombre lo resuelve la sesión contra la
+  carpeta en la que se abrió: una sesión abierta en el repo ops no encuentra ninguno y recibe un «no
+  existe» que se lee como instalación fallida. Ahora la salida nombra ese directorio con su raíz puesta y
+  desde dónde hay que abrir la sesión para que los vea.
+
+- **Los recorridos dejan de depender de la carpeta desde la que se abrió la sesión.** La raíz que traen
+  escrita —la que usan para nombrar el planning, la configuración y el CLI en cada comando que le dictan a
+  un agente— era **relativa** a la carpeta donde se abre la herramienta. Eso vale mientras el agente esté
+  parado ahí, y nadie lo promete: una sesión abierta en el repo ops resolvía `<empresa>-ops/planning`
+  contra su propio directorio, el tramo se duplicaba, y el comando contestaba que el planning no existe.
+  En una corrida real de `autobuild` costó una vuelta entera de la fase Claim.
+
+  Ahora esa raíz es **absoluta** y la escribe `automation install`, que es quien la conoce. Ninguna
+  consigna depende ya de dónde arranque la sesión.
+
+  **Lo que tenés que saber**: un archivo que lleva la raíz escrita se rompe si movés el proyecto de
+  carpeta. Se repara con `automation install` del runner, que es lo que ya hacía falta cuando el wiring
+  quedaba apuntando a otro lado. Y como los recorridos vienen del paquete, esto llega con el `upgrade`:
+  después conviene reinstalar el adaptador para que la raíz nueva quede escrita.
+
+- **Agregar un archivo al motor ya no deja la cobertura en un callejón.** La puerta de pisos fallaba
+  diciendo «corré `npm run coverage:update`», y ese comando no podía completarse **mientras el piso
+  faltara**: corría la suite entera bajo `set -e`, la suite incluía la prueba que estaba en rojo por el
+  piso que faltaba, y el script moría antes de llegar a la línea que lo registra.
+
+  Ahora las corridas de medición no deciden por su código de salida —existen para producir el archivo de
+  cobertura— y en su lugar se exige que ese archivo traiga contenido, que es lo único que distingue una
+  suite que falló de una que no llegó a arrancar. Y al abortar ya no se borran las mediciones que sí se
+  completaron, así que se puede retomar desde donde quedó.
+
+  **Y medir cero dejó de anunciarse como éxito**: `coverage-files.js --update` con un archivo de
+  cobertura vacío imprimía «piso registrado» y salía en 0, dejando el registro vacío sin que nada lo
+  dijera. Ahora se niega y explica por qué.
+
 ## [0.88.0] - 2026-09-14
 
 ### Corregido

package/automatization/shared/eval-measured.js

@@ -21,7 +21,7 @@ const unmeasuredNote = (unmeasured) => (unmeasured.length
 // —trabajaron ahí— y el repositorio las rechaza: una ruta bajo el `/home` de alguien no le sirve a nadie
 // más y ata el documento a un directorio que en otra máquina no existe.
 //
-// La raíz no siempre la trae `root`: `{{OPS_DIR}}` lo completa `automation install`, y en el repositorio
+// La raíz no siempre la trae `root`: `{{OPS_ROOT}}` lo completa `automation install`, y en el repositorio
 // del toolkit —que no se instala a sí mismo— queda vacío y `ROOT` vale `.`. Cuando falta, la revela el
 // propio texto: cualquier ruta del banco la lleva adelante. Con ella se recorta también la que apunta a la
 // raíz sin nada detrás, que es la que se escapó el 2026-08-31 después de dos arreglos que cubrían el caso

package/automatization/shared/workflow-root.js

@@ -1,4 +1,15 @@
-// El prefijo lo completa `automation install`. No puede venir del entorno: el runtime de workflows no
-// expone `process`, así que leerlo de ahí reventaba el archivo entero en su primera línea. Viaja
-// escrito, relativo a la carpeta donde se abre la herramienta, que es el cwd de los agentes.
-const ROOT = '{{OPS_DIR}}'.replace(/\/+$/, '') || '.'
+// La raíz la completa `automation install`. No puede venir del entorno: el runtime de workflows no
+// expone `process`, así que leerlo de ahí reventaba el archivo entero en su primera línea. Viaja escrita.
+//
+// Y viaja **absoluta**. Lo fue relativa hasta 0.89.0, anclada a la carpeta donde se abre la herramienta
+// «que es el cwd de los agentes» — y esa segunda mitad es la que no se cumple: cada consigna dicta «corré
+// X desde Y» con las dos rutas relativas, así que coinciden sólo si la sesión abrió exactamente donde el
+// instalador supuso. Abierta en la instancia, el tramo se duplica y el comando contesta que el planning
+// no existe (caso 139). Absoluta no hay dónde pararse mal.
+//
+// El costo de escribirla —y por qué se paga acá— lo declara `engine/automation/runners.js` junto al
+// marcador.
+//
+// Sin instalar queda vacía y vale `.`: el toolkit no se consume a sí mismo y sus recorridos se ejercitan
+// desde su propia carpeta.
+const ROOT = '{{OPS_ROOT}}'.replace(/\/+$/, '') || '.'

package/automatization/workflows/autobuild.js

@@ -252,10 +252,13 @@ const CONTRACT = {
   required: ['project', 'workspaceRoots', 'maxTaskHours', 'commitPerTask', 'humanCheckpoint', 'contracts',
     'rootOk'],
   properties: {
-    // `ROOT` viaja escrito en el workflow y es relativo al cwd de los agentes: si la sesión abrió en otra
-    // carpeta, todas las rutas resuelven a `<raíz>/<raíz>/…` y ninguna existe. Nada lo comprobaba, y el
-    // recorrido gastaba Triage entero sobre archivos ausentes antes de parar más abajo por otra causa,
-    // nombrando el planning en vez de la raíz de la que ese planning cuelga.
+    // `ROOT` viaja escrito en el workflow y lo completa el instalador. Nada comprobaba que esa raíz se
+    // pudiera leer, y el recorrido gastaba Triage entero sobre archivos ausentes antes de parar más abajo
+    // por otra causa, nombrando el planning en vez de la raíz de la que ese planning cuelga.
+    //
+    // Lo que rompía era que fuera relativa: abierta la sesión en otra carpeta, todo resolvía a
+    // `<raíz>/<raíz>/…` y nada existía. Desde 0.89.0 es absoluta y ese modo de fallo se fue, pero el campo
+    // sigue haciendo falta — una raíz absoluta se rompe si alguien mueve el proyecto sin reinstalar.
     //
     // Se pregunta acá porque acá ya se leen los cuatro archivos: cuesta un campo y ningún agente más.
     rootOk: { type: 'boolean' },
@@ -336,8 +339,8 @@ if (!contract) return stop('contract-unavailable', `no se pudo leer ${CONFIG} ni
 // Falla acá y nombrando la raíz, que es lo que hace falta para arreglarlo: parar más abajo mandaba a
 // revisar el planning, y el planning está bien — lo que no existe es la carpeta de la que cuelga.
 if (!contract.rootOk) {
-  return stop('root-unreadable', `${ROOT} no se pudo leer entero. Es una ruta relativa a la carpeta `
-    + `donde se abre la herramienta: comprobá desde dónde estás corriendo el recorrido.`)
+  return stop('root-unreadable', `${ROOT} no se pudo leer entero. Es la raíz absoluta que escribió `
+    + `"automation install": comprobá que exista y, si moviste el proyecto de carpeta, reinstalá el adaptador.`)
 }
 
 const bounds = contract.boundaries || []

package/engine/agents/learning-files.js

@@ -9,6 +9,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const catalog = require('./catalog')
 const ownership = require('../core/ownership')
+const { section } = require('../planning/parser')
 
 const REQUIRED_SECTIONS = [
   'Hallazgos',
@@ -53,6 +54,17 @@ const undecided = (value) => {
   return !text || /^(por definir|pendiente)\b/i.test(text) || text === LEGACY_REVISION
 }
 
+// Lo mismo preguntado sobre el documento, que es como lo necesita quien acaba de componerlo y todavía no
+// leyó su «Cambio propuesto». Vive acá y no en cada `return` de `prepareProposal` —son cinco y sólo uno
+// compone— porque la señal tiene que valer igual en todos: puesta en uno, vuelve `undefined` en los
+// demás y quien la lea creerá que el documento decide algo.
+function blankProposal(file) {
+  try {
+    const body = section(fs.readFileSync(file, 'utf8'), /Cambio propuesto/i)
+    return undecided(body.split('\n').slice(1).join('\n'))
+  } catch { return false }
+}
+
 // Un cargo del sistema vive dentro del paquete: escribir ahí perdería el informe en el próximo
 // `npm ci`, y además duplicaría en cada empresa una investigación sobre la profesión que se hace
 // mejor una sola vez. Lo que sí es de esta empresa es su contexto, y ese tiene otro lugar.
@@ -144,7 +156,7 @@ function reportFiles(dir) {
 }
 
 module.exports = {
-  REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME, undecided, SIGNED, CLOSED,
+  REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME, undecided, blankProposal, SIGNED, CLOSED,
   assertWritableTeam, assertWritable, isoDate, month,
   proposalOrder, proposalFiles, frontmatterState, proposalState, reportFiles, lastOfPeriod,
 }

package/engine/automation/index.js

@@ -423,9 +423,11 @@ function install(root, name, output = console, options = {}) {
   const ourHooks = deliveredHookCommands(live)
   if (ourHooks.length) deliveredPaths[deliveryKey(name, HOOKS_KEY)] = ourHooks
   else delete deliveredPaths[deliveryKey(name, HOOKS_KEY)]
+  const landed = new Set()
   for (const resolved of resolvedItems) {
     const status = state.get(resolved)
     const ownFile = runner.instructions.includes(resolved.item)
+    if (!ownFile) landed.add(path.dirname(resolved.target))
     if (ownFile && isSharedFile(root, resolved.target)) {
       const content = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
       if (blockUpToDate(resolved.target, name, content)) {
@@ -463,11 +465,25 @@ function install(root, name, output = console, options = {}) {
       deliveredPaths[deliveryKey(name, resolved.item.target)] = M.digest(resolved.target)
     }
   }
+  // Dónde quedaron, con la raíz puesta. Arriba ya se dice de la configuración, que es un archivo que nadie
+  // invoca; éstos se invocan **por nombre**, y el nombre lo resuelve la sesión contra la carpeta en la que
+  // se abrió. Nombrados en relativo se leen como si estuvieran acá, así que quien abre la sesión en el repo
+  // ops no encuentra ninguno mientras esta misma salida dice que están todos instalados.
+  if (paths.install !== root) {
+    for (const dir of landed) {
+      output.log(`  ${name}: ${dir} — los encuentra por nombre una sesión abierta en ${paths.install}`)
+    }
+  }
   installRoleSkills(root, runner, output)
   // Cómo se lo llama acá. El nombre del recorrido es el mismo en todos los runners —`onboard`, `flow`,
   // `autobuild`—; el prefijo lo pone cada uno según su espacio de nombres, y esa diferencia es la que
   // hace que alguien no encuentre en Gemini lo que usó en Claude. Decirlo al instalar cuesta una línea
   // y ahorra buscarlo en una lista tan larga como el catálogo.
+  // Lo que ese bloque va a costar, dicho donde se decide. Escribir una regla propia encarece todas las
+  // corridas futuras de todos los agentes, y hasta acá había que sumar los tamaños a mano después de una
+  // corrida cara para enterarse (caso 141). Se declara siempre, pase o no el umbral: `check` avisa cuando
+  // ya pesa, y esto informa mientras todavía se está eligiendo.
+  output.log(`  ${name}: ${RL.weightLine(root)}`)
   const invocation = runner.commands && runner.commands.invocation
   if (invocation && (runner.commands.names || []).length) {
     const listing = runner.commands.names.map((nombre) => invocation.replace('{name}', nombre))

package/engine/automation/rules.js

@@ -6,6 +6,7 @@
 // instalar. Y como `upgrade` no reinstala, `check` y `doctor` comparan lo instalado con lo vigente.
 
 const fs = require('node:fs')
+const path = require('node:path')
 const F = require('../core/files')
 const O = require('../core/ownership')
 
@@ -20,14 +21,100 @@ const START_AT = '<!-- cauce:reglas inicio'
 // Lo que un `CLAUDE.md` o un `GEMINI.md` instalado antes de 0.82.0 trae en el lugar del bloque.
 const LEGACY_IMPORT = /^@\S*planning\/rules\/\S+\.md\s*$/
 
+// Una regla que declara `aplica:` rige igual, y se carga sólo cuando se toca esa superficie. Lo que se
+// ahorra está medido: el contexto de arranque de **cada** agente son ~16 K tokens sólo de lo que Cauce
+// pone, y una regla que importa en una tarea de cada cien se leía cien veces (caso 141).
+//
+// El default es lo que vuelve seguro esto: sin el campo, la regla se carga como siempre. Al revés —pedir
+// que declare `siempre` para seguir cargándose— cada instancia habría perdido sus reglas propias en el
+// próximo `upgrade`, una por una y sin que nada lo dijera.
+//
+// `effectiveRules` no cambia: sigue devolviendo todo lo que rige, que es lo que `ops context` le entrega
+// al recorrido. Acá sólo se decide qué se **carga**, y por eso la partición vive de este lado.
+const SURFACE = /^aplica:[ \t]*(\S.*?)[ \t]*$/m
+function surfaceOf(root, file) {
+  try {
+    const text = fs.readFileSync(path.join(root, file), 'utf8')
+    // Sólo en el frontmatter: un `aplica:` en la prosa de una regla es una frase, no una declaración.
+    if (!text.startsWith('---')) return ''
+    const end = text.indexOf('\n---', 3)
+    return end === -1 ? '' : ((text.slice(0, end).match(SURFACE) || [])[1] || '')
+  } catch { return '' }
+}
+
+// Las que se cargan y las que sólo se nombran. Las dos listas salen de la misma lectura para que el
+// bloque que se escribe y el aviso que lo audita no puedan discrepar: con dos recorridos, `doctor`
+// reportaría como faltante la que a propósito no se carga, para siempre y sin forma de callarlo.
+function split(root) {
+  const loaded = []
+  const named = []
+  for (const file of O.effectiveRules(root)) {
+    const surface = surfaceOf(root, file)
+    if (surface) named.push({ file, surface })
+    else loaded.push(file)
+  }
+  return { loaded, named }
+}
+
+// Cuánto pesa lo que el bloque carga, en bytes. En bytes y no en tokens a propósito: los bytes los mide
+// el motor y se pueden comprobar, mientras que la equivalencia en tokens depende del modelo y del
+// tokenizador. Un número estimado en una salida que alguien cita para decidir vale menos que uno exacto.
+//
+// Sólo `loaded`: una regla declarada por superficie no viaja en el arranque, y contarla haría que
+// declararla no sirviera de nada. Vive acá —y no en quien lo imprime— porque lo miran dos, `install` al
+// instalar y `check` en cada corrida, y con dos cuentas separadas se contradicen el día que alguien toque
+// una sola.
+function weight(root) {
+  const { loaded } = split(root)
+  let bytes = 0
+  const files = []
+  for (const file of loaded) {
+    try {
+      const size = fs.statSync(path.join(root, file)).size
+      bytes += 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) }
+}
+
+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.
+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 top = files.slice(0, 2).map((one) => path.basename(one.file)).join(', ')
+  return `el bloque de reglas carga ${count} archivo(s), ${KB(bytes)} en cada agente`
+    + (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)] : []
+}
+
 // Sin raíz el marcador queda como está —así lo leen las pruebas que revisan el texto de un adaptador—: un
 // bloque vacío se leería igual que un proyecto sin reglas, y un marcador sin resolver se ve.
 function fill(text, root) {
   if (!root || !text.includes('{{RULES:')) return text
-  const rules = O.effectiveRules(root)
-  return text.replace(MARKER, (_, format) => [START, ...rules.map((file) => (format === 'imports'
-    ? `@{{OPS_DIR}}${file}`
-    : `- \`{{OPS_DIR}}${file}\``)), END].join('\n'))
+  const { loaded, named } = split(root)
+  return text.replace(MARKER, (_, format) => [
+    START,
+    ...loaded.map((file) => (format === 'imports' ? `@{{OPS_DIR}}${file}` : `- \`{{OPS_DIR}}${file}\``)),
+    // Nombrada y no cargada: pesa una línea en vez de su archivo entero, y quien la lea sabe qué la
+    // dispara. Va en el mismo bloque a propósito — fuera de él, una sesión que no corre un recorrido no
+    // se enteraría de que existe, y una regla que nadie sabe que existe es una que no rige.
+    ...named.map((one) => `- \`{{OPS_DIR}}${one.file}\` (aplica: ${one.surface})`),
+    END,
+  ].join('\n'))
 }
 
 function blockOf(text) {
@@ -69,6 +156,13 @@ function drift(root, name) {
   const { runnerManifest, runnerPaths, resolveItem } = require('./runners')
   const runner = runnerManifest(root, name)
   const paths = runnerPaths(root, name, runner)
+  // Contra todo lo que rige, y no contra la partición: una regla declarada por superficie igual aparece
+  // en el bloque —nombrada en vez de importada—, y `listed` extrae la ruta de las dos formas. Así que el
+  // audit la ve y no la extraña, sin que este lado tenga que saber que la partición existe.
+  //
+  // Se intentó filtrar acá por simetría con `fill` y no cambiaba nada: la mutación que lo revertía dejaba
+  // las pruebas en verde. Queda dicho porque la simetría es tentadora y el código que no altera ninguna
+  // conducta se lee como si sostuviera algo.
   const expected = O.effectiveRules(root)
   const found = []
   for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
@@ -119,4 +213,4 @@ function staleLines(root) {
   return lines
 }
 
-module.exports = { fill, refresh, drift, driftLine, staleLines }
+module.exports = { fill, refresh, drift, driftLine, staleLines, split, weightLine, heavyRules }

package/engine/automation/runners.js

@@ -122,9 +122,13 @@ function inline(text, automationRoot) {
   })
 }
 
-// `{{OPS_ROOT}}` es la raíz absoluta. La necesita quien no puede deducirla de dónde lo ejecutaron
-// —el puente de Antigravity—, y por eso no reemplaza a `{{OPS_DIR}}`: una ruta absoluta escrita en un
-// archivo se rompe si el proyecto se mueve, así que la lleva sólo el que se queda sin alternativa.
+// `{{OPS_ROOT}}` es la raíz absoluta, y la lleva quien no puede deducirla de dónde lo ejecutaron: el
+// puente de Antigravity, los hooks de Codex y —desde 0.89.0— los recorridos, que dictan comandos a un
+// agente cuyo directorio nadie promete (caso 139).
+//
+// No reemplaza a `{{OPS_DIR}}` en general, y el costo dice por qué: un archivo que lleva la raíz escrita
+// se rompe si el proyecto se mueve de carpeta, y se repara reinstalando el adaptador. Lo paga el que no
+// tiene alternativa; lo que se resuelve contra la carpeta donde se abre la herramienta sigue con el otro.
 const OPS_ROOT = '{{OPS_ROOT}}'
 
 // `{{RULES:…}}` va antes que `{{OPS_DIR}}` por lo mismo que el include: las rutas que escribe llevan el prefijo.

package/engine/cli/catalog.js

@@ -7,6 +7,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const L = require('../agents/learning')
+const LF = require('../agents/learning-files')
 const AG = require('../agents/catalog')
 const EV = require('../agents/evaluations')
 const T = require('../flows/registry')
@@ -288,6 +289,13 @@ function learn(agent, cli) {
         ? `  ${result.reports} corrida(s) consolidada(s), ${result.findings} hallazgo(s)`
         : `  ${result.reports} informe(s) semanal(es) incluidos`)
     }
+    // Lo lee quien automatiza el ciclo para no pedir una firma por un documento que no decide nada, y
+    // también quien lo corre a mano: sin esta línea el archivo se ve terminado y no lo está. Se pregunta
+    // sobre el documento y no sobre lo que devolvió el motor, porque `prepareProposal` sale por cinco
+    // lugares y sólo uno compone: puesto en ése, el dato falta en los otros cuatro.
+    if (LF.blankProposal(result.file)) {
+      console.log('  sin cambio decidido: falta correr agent-propose antes de que esto se pueda firmar')
+    }
   } catch (error) { fail(error.message, 2) }
 }
 

package/engine/cli/claims.js

@@ -76,9 +76,15 @@ function claim(dir, slug, cli) {
       + `${CL.DIR}/${slug}.md a mano: soltar lo de otro es una decisión, no un comando.`)
   }
   console.log(`✓ ${slug} tomada por ${me}`)
-  // Un reclamo sin empujar no protege de nada: el otro runner lee lo que hay en su copia. Decirlo acá
-  // es lo único que separa «tomé la tarea» de «creí que la había tomado».
-  if (!cli.has('--json')) console.log(`  commiteá y empujá ${CL.DIR}/${slug}.md para que el equipo lo vea`)
+  if (!cli.has('--json')) {
+    // Un reclamo sin empujar no protege de nada: el otro runner lee lo que hay en su copia. Decirlo acá
+    // es lo único que separa «tomé la tarea» de «creí que la había tomado».
+    console.log(`  commiteá y empujá ${CL.DIR}/${slug}.md para que el equipo lo vea`)
+    // Y con qué id volver. Este dato lo imprimía `ops worktree` al crear el árbol; en sidecar no se crea
+    // ninguno, así que ese comando no corre nunca y el id no quedaba escrito en el único momento en que
+    // alguien lo tiene delante: ahora, que se acaba de guardar en el reclamo.
+    console.log(`  export CAUCE_RUNNER=${from}`)
+  }
 }
 
 function release(dir, slug) {

package/engine/cli/io.js

@@ -10,6 +10,12 @@ function fail(message, code = 1) {
   process.exit(code)
 }
 
+// La fecha de hoy, en un solo lugar: los comandos que la usan tienen que estar mirando el mismo día, y
+// el módulo que calcula vencimientos la recibe en vez de preguntarla. Vive acá desde que la puerta de
+// planning se separó de los comandos que la leen — quedaba en el archivo que se partió, y dejar una copia
+// a cada lado habría roto en silencio lo único que esta función promete.
+const TODAY = () => new Date().toISOString().slice(0, 10)
+
 // La raíz ops de un comando que no la recibe. El shim `tools/ops.js` la exporta porque sabe dónde
 // vive: sin eso, invocarlo desde otra carpeta —lo normal en sidecar— la resolvía contra el cwd.
 function opsRoot(dir) {
@@ -44,4 +50,4 @@ function planningRoot(dir) {
   return root
 }
 
-module.exports = { fail, opsRoot, planningRoot }
+module.exports = { fail, opsRoot, planningRoot, TODAY }

package/engine/cli/ops.js

@@ -9,6 +9,7 @@ const { FLAGS, parse } = require('./args')
 const { fail } = require('./io')
 const IN = require('./instance')
 const PL = require('./planning')
+const VA = require('./validate')
 const AR = require('./archive')
 const CLM = require('./claims')
 const WT = require('./worktree')
@@ -124,7 +125,7 @@ async function init(target, cli) {
     })
   } catch (error) { fail(error.message, 2) }
 
-  if (result.installed) PL.check(path.join(root, 'planning'), NO_FLAGS)
+  if (result.installed) VA.check(path.join(root, 'planning'), NO_FLAGS)
 
   // Una instancia recién instalada funciona y no sabe nada de este proyecto: `organization/` es el molde
   // y el roadmap está vacío. Llenarlo exige leer el repositorio y decidir qué es cada cosa, que es justo
@@ -204,7 +205,7 @@ async function run(cli) {
   if (command === 'init') await init(arg[1], cli)
   else if (command === 'scan') W.scan(arg[1], cli)
   else if (command === 'onboard') W.onboard(arg[1], cli)
-  else if (command === 'check') PL.check(arg[1], cli)
+  else if (command === 'check') VA.check(arg[1], cli)
   else if (command === 'tree') PL.tree(arg[1], cli)
   else if (command === 'context') PL.context(arg[1], cli)
   else if (command === 'recurring') PL.recurring(arg[1], cli)

package/engine/cli/planning.js

@@ -1,32 +1,20 @@
 'use strict'
 
-// Los comandos que leen y validan un planning: qué está mal, qué hay, qué toca ahora y qué se archiva.
-// Los cuatro trabajan sobre el mismo estado, que `planning/state.js` compone una vez.
+// Los comandos que leen un planning y contestan sobre él: qué hay, qué toca ahora, qué vence y con qué
+// se cerró una tarea. Todos trabajan sobre el mismo estado, que `planning/state.js` compone una vez.
+//
+// La puerta no está acá: vive en `validate.js` porque decide en vez de informar, y con ella se fueron
+// quince de los veintiún módulos que este archivo importaba.
 
 const fs = require('node:fs')
 const path = require('node:path')
 const P = require('../planning/parser')
-const B = require('../planning/business-rules')
-const PC = require('../planning/contracts')
-const SR = require('../planning/structure')
-const SZ = require('../planning/sizing')
 const RC = require('../planning/recurring')
-const IB = require('../planning/inbox')
 const CL = require('../planning/claims')
-const R = require('../core/repos')
 const ST = require('../planning/state')
-const AD = require('../planning/adoption')
-const AP = require('../hooks/approval')
-const I = require('../integrations/registry')
 const O = require('../core/ownership')
 const EV = require('../core/evidence')
-const TR = require('../core/trails')
-const OB = require('../core/onboarding')
-const C = require('../config/validate')
-const CP = require('../config/paths')
-const AG = require('../agents/catalog')
-const RL = require('../automation/rules')
-const { fail, planningRoot } = require('./io')
+const { fail, planningRoot, TODAY } = require('./io')
 
 // Qué dimensiones enumera el molde de `organization/` y cuáles dejaron de estar. Un agente que reescribe
 // esos archivos tiende a quedarse con el contenido y perder la estructura: el resultado se lee entero y
@@ -74,178 +62,6 @@ function evidence(dir, cli) {
     + 'que la prueba nombrada haya corrido: eso depende del runner, y varios no la nombran al pasar.')
 }
 
-// La fecha de hoy, en un solo lugar: los comandos que la usan tienen que estar mirando el mismo día, y
-// el módulo que calcula vencimientos la recibe en vez de preguntarla.
-const TODAY = () => new Date().toISOString().slice(0, 10)
-
-function check(dir, cli) {
-  const root = planningRoot(dir)
-  const errors = []
-  const warnings = []
-  // El plan no está: `wip/` es local y gitignoreado, así que un clon nuevo no lo trae y eso no es un
-  // error. Ausente se lee como IDLE, que es lo que significa.
-  const required = ['BACKLOG.md', 'INBOX.md', 'HUMAN_ACTIONS.md', 'PROTOCOL.md']
-  // `DONE.md` se retiró: la evidencia vive en un archivo por tarea. Un `DONE.md` que quede en disco
-  // ya no lo lee nadie, y eso no se nota — las épicas dejan de poder cerrar y sus historias figuran
-  // sin evidencia, que es lo mismo que se vería si nunca se hubieran hecho.
-  // `WIP.md` se retiró por lo mismo que `DONE.md`: era uno solo y lo escribían todos los que corren sobre
-  // una instancia sidecar. Uno que quede en disco ya no lo lee nadie, y su plan a medias se pierde sin
-  // que nada lo diga.
-  if (fs.existsSync(path.join(root, 'WIP.md'))) {
-    errors.push('WIP.md ya no se lee: el plan de cada runner vive en `wip/<runner>.md`; movelo y borralo')
-  }
-  if (fs.existsSync(path.join(root, 'DONE.md'))) {
-    errors.push('DONE.md ya no se lee: pasá cada entrada a su propio `done/<slug>.md` y borralo')
-  }
-  for (const file of required) if (!fs.existsSync(path.join(root, file))) errors.push(`falta ${file}`)
-
-  const configPath = path.join(root, '..', 'ops.config.json')
-  let config = null
-  if (fs.existsSync(configPath)) {
-    try {
-      const raw = fs.readFileSync(configPath, 'utf8')
-      config = JSON.parse(raw)
-      if (!raw.includes('{{')) {
-        errors.push(...C.validateOpsConfig(config))
-        warnings.push(...C.configWarnings(config))
-        if (Array.isArray(config.workspaceRoots)) {
-          for (const workspace of config.workspaceRoots) {
-            if (workspace && workspace.name && workspace.path
-              && !fs.existsSync(path.resolve(path.dirname(configPath), workspace.path))) {
-              errors.push(`ops.config.json: no existe la raíz ${workspace.name} (${workspace.path})`)
-            }
-          }
-        }
-        // Es la única parte de la configuración que le levanta el límite a un guard, y quien la escribió
-        // no es quien la lee dentro de seis meses: va como advertencia permanente, igual que un override.
-        // Y se muestra resuelta porque resuelta es como la compara el guard — un `~` escrito solo exenta
-        // la casa entera, y escrito no se nota.
-        for (const exempt of CP.writableOutsideRoots(path.dirname(configPath), config)) {
-          warnings.push(`ops.config.json: ${exempt.declared} está exenta del límite `
-            + `de raíces (${exempt.path})`)
-        }
-      }
-    } catch (error) {
-      errors.push(`ops.config.json: JSON inválido (${error.message})`)
-    }
-  } else {
-    warnings.push(`no existe ${path.relative(root, configPath)}`)
-  }
-
-  const epics = P.readEpics(root)
-  const milestones = P.readBacklog(root)
-  const done = P.readDone(root)
-  errors.push(...B.validate(path.join(root, 'business-rules')))
-  errors.push(...SR.validateRoadmapStructure(root))
-  errors.push(...SR.validateBacklogStructure(root))
-  errors.push(...SR.validateRules(root))
-  errors.push(...SR.validateAdr(root))
-  const backlog = milestones.flatMap((milestone) => milestone.tasks)
-  const backlogSlugs = new Set(backlog.map((task) => task.slug))
-  const epicNums = new Set()
-  const storySlugs = new Set()
-
-  const roles = new Set(AG.list(path.resolve(root, '..')).map((role) => role.slug))
-  const wips = P.readWips(root)
-  const adopted = AD.read(root)
-  errors.push(...SZ.oversizedUnits({ epics, milestones }))
-  errors.push(...PC.validateState({
-    epics, milestones, done, wips, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
-  }))
-  warnings.push(...AD.report({ done, epics, adopted }))
-  warnings.push(...PC.doneCeremonyWarnings(done, new Set(adopted)))
-  warnings.push(...R.coverageWarnings(path.resolve(root, '..'), done))
-  // Sin `RECURRING.md` no dice una palabra: una instancia que actualiza y no declara trabajo recurrente
-  // no tiene por qué enterarse de que el contrato existe. Vencida avisa y no frena — lo que frena vive
-  // en `HUMAN_ACTIONS.md`, y un aviso que salta siempre se termina apagando.
-  // Un reclamo que nombra una tarea que no existe bloquea la cola sin que nada lo explique, y uno viejo
-  // la bloquea para siempre. Lo primero es error; lo segundo avisa, porque abandonar no es un defecto.
-  const claims = CL.read(root)
-  errors.push(...CL.validate({ claims, milestones, done }))
-  // Si la rama de cada tarea tomada se movió, que es lo único barato que distingue una tarea larga de
-  // una abandonada. Sin repositorio resoluble el mapa queda vacío y el aviso vuelve a mirar sólo la
-  // fecha, que es lo que había antes: degrada, no rompe.
-  const activity = new Map()
-  for (const claim of claims.filter((one) => !done.set.has(one.slug))) {
-    const at = R.lastCommit(R.repoOf(path.join(root, '..'), claim.service), CL.branchOf(claim.slug))
-    if (at) activity.set(claim.slug, at)
-  }
-  warnings.push(...CL.warnings({ claims, done, today: TODAY(), activity }))
-  const recurring = RC.read(root)
-  errors.push(...RC.validate(recurring))
-  warnings.push(...RC.warnings(RC.status({ ...recurring, done, today: TODAY() })))
-  warnings.push(...IB.warnings(root, done, config))
-  warnings.push(...AD.sealWarnings(root))
-  warnings.push(...R.unrecordedHumanActions(path.resolve(root, '..'), P.readHumanActions(root)))
-  warnings.push(...AP.warnings(path.resolve(root, '..')))
-  warnings.push(...TR.warnings(path.resolve(root, '..')))
-
-  // Lo que `upgrade` conserva por estar editado deja de recibir mejoras, y eso es una deuda que no
-  // avisa sola: la instancia queda con medio molde viejo y todo se ve normal. Sale acá para que se vea
-  // en cada corrida y no sólo el día que alguien actualiza.
-  const congelados = O.localChanges(path.resolve(root, '..'))
-  if (congelados.length) {
-    warnings.push(`${congelados.length} archivo(s) del molde congelados por edición local; `
-      + '`upgrade` los conserva y no les trae mejoras')
-  }
-
-  // Y lo que `upgrade` no retiró porque no pudo demostrar que fuera suyo: queda ahí, sin colgar de
-  // ningún mecanismo, hasta que alguien lo mueva o lo borre. Se cuenta por lo mismo que los congelados
-  // — un resto que no se ve se vuelve permanente.
-  const restos = O.RETIRED_COMPARTIDO.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
-  if (restos.length) {
-    warnings.push(`${restos.length} ruta(s) retiradas siguen en disco con contenido tuyo `
-      + `(${restos.join(', ')}); Cauce ya no las distribuye ni las toca`)
-  }
-
-  const integration = I.validate(path.resolve(root, '..'))
-  errors.push(...integration.errors)
-  warnings.push(...integration.warnings)
-
-  warnings.push(...SR.competingSections(root))
-  // Sobrescribir una entrada de system/ es legítimo y esperado; lo que no puede pasar es que
-  // ocurra en silencio, porque esa entrada deja de recibir las mejoras del toolkit.
-  for (const override of O.overrides(path.resolve(root, '..'))) {
-    // Y con qué se queda el proyecto: un override sano redefine lo que reemplaza, y el que deja IDs
-    // afuera los retira sin decirlo. Nombrarlos es lo único que separa una decisión de un descuido.
-    const retired = override.collection === 'planning/rules'
-      ? SR.retiredByOverride(root, override.project)
-      : []
-    warnings.push(`${override.collection}/${override.project} sobrescribe ${override.system} `
-      + `(override explícito)${retired.length ? `; deja de regir ${retired.join(', ')}` : ''}`)
-  }
-  // Y lo que instaló cada runner, contra esas mismas reglas (caso 099).
-  warnings.push(...RL.staleLines(path.resolve(root, '..')))
-  // Misma regla para los cargos, que es donde más caro sale: un fork se hace una vez y se olvida.
-  const FK = require('../agents/fork')
-  for (const entry of FK.drift(path.resolve(root, '..'))) warnings.push(FK.driftLine(entry))
-
-  warnings.push(...OB.missingSections(path.resolve(root, '..')))
-  warnings.push(...OB.orphanCredentials(path.resolve(root, '..')))
-
-  if (cli.has('--json')) {
-    console.log(JSON.stringify({
-      ok: !errors.length,
-      epics: epics.length,
-      queued: backlog.length,
-      done: done.entries.length,
-      wips: wips.map((one) => one.task),
-      errors,
-      warnings,
-    }))
-    if (errors.length) process.exit(1)
-    return
-  }
-
-  for (const warning of warnings) console.warn(`⚠ ${warning}`)
-  for (const error of errors) console.error(`✗ ${error}`)
-  if (errors.length) fail(`\n${errors.length} error(es), ${warnings.length} advertencia(s)`)
-  console.log(
-    `✓ planning válido: ${epics.length} épica(s), ${backlog.length} tarea(s) en cola, ` +
-      `${done.entries.length} terminada(s)`,
-  )
-}
-
 // Estado observable de planning sin mutar nada; base común de `tree` y de sus salidas.
 function treeJson({ epics, milestones, done, wips, inbox, queued, claims }) {
   const state = (slug) => done.set.has(slug) ? 'done' : queued.has(slug) ? 'queued' : 'pending'
@@ -407,6 +223,18 @@ function context(dir, cli) {
   // Tu propio nombre en una tarea «ajena» es la señal de que sos vos desde otro runner, y sin decirlo se
   // lee como que alguien te ganó la tarea.
   const dueño = (one) => (one.owner === report.owner ? `${one.owner} — vos, desde otro runner` : one.owner)
+  // Que el reclamo sea tuyo desde otro id ya se decía; que además haya un **plan escrito** bajo ese id, no.
+  // Esa es la mitad que cuesta la sesión: los pasos ya hechos están en un archivo que nadie nombra, y el id
+  // que lo recupera es justo el que esta sesión no supo deducir. Los dos datos están en el reclamo.
+  const tomadas = () => {
+    for (const one of report.taken) {
+      console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+      if (one.owner === report.owner && one.wip) {
+        console.log(`PLAN   ${one.slug}: su plan está en wip/${one.wip} — retomalo con `
+          + `\`export CAUCE_RUNNER=${one.runner}\``)
+      }
+    }
+  }
   const espera = () => {
     for (const one of report.waiting) {
       console.log(`WAIT   ${one.slug}: espera a ${one.dep}${one.owner ? ` (${one.owner})` : ''}`)
@@ -424,7 +252,7 @@ function context(dir, cli) {
     if (next) console.log(`EPIC   ${next.num}: ${next.title} — sin promover`)
     // Mismo motivo que `blocked` arriba, con otra causa: acá la cola no la traba una persona, la tiene
     // el equipo, y lo que corresponde es hablar con quien la tiene.
-    for (const one of report.taken) console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+    tomadas()
     espera()
     for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
     due()
@@ -452,7 +280,7 @@ function context(dir, cli) {
   console.log(report.claimed
     ? `CLAIM  tuya desde el reclamo (${report.owner})`
     : `CLAIM  libre — tomala con \`ops claim <planning> ${report.task.slug}\``)
-  for (const one of report.taken) console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+  tomadas()
   espera()
   if (report.blockedTasks.length) console.log(`SKIP   ${report.blockedTasks.join(', ')} (acción humana abierta)`)
   for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
@@ -489,4 +317,4 @@ function recurring(dir, cli) {
   }
 }
 
-module.exports = { check, evidence, tree, context, recurring }
+module.exports = { evidence, tree, context, recurring }

package/engine/cli/validate.js

@@ -0,0 +1,205 @@
+'use strict'
+
+// La puerta de un planning: qué está mal y qué conviene mirar, en un solo comando que falla.
+//
+// Vive aparte de los que leen el mismo estado porque hace lo contrario que ellos. `tree`, `context` y
+// `recurring` contestan una pregunta y salen en cero; éste junta errores y advertencias de dieciocho
+// módulos —estructura, contratos, reclamos, integraciones, ownership, onboarding— y decide si la
+// instancia puede seguir. De ahí que casi todo lo que el CLI de planning importa entre por acá y no por
+// allá: lo que valida necesita conocer a todos, y lo que informa sólo necesita el estado ya compuesto.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const P = require('../planning/parser')
+const B = require('../planning/business-rules')
+const PC = require('../planning/contracts')
+const SR = require('../planning/structure')
+const SZ = require('../planning/sizing')
+const RC = require('../planning/recurring')
+const IB = require('../planning/inbox')
+const CL = require('../planning/claims')
+const R = require('../core/repos')
+const AD = require('../planning/adoption')
+const AP = require('../hooks/approval')
+const I = require('../integrations/registry')
+const O = require('../core/ownership')
+const TR = require('../core/trails')
+const OB = require('../core/onboarding')
+const C = require('../config/validate')
+const CP = require('../config/paths')
+const AG = require('../agents/catalog')
+const RL = require('../automation/rules')
+const { fail, planningRoot, TODAY } = require('./io')
+
+function check(dir, cli) {
+  const root = planningRoot(dir)
+  const errors = []
+  const warnings = []
+  // El plan no está: `wip/` es local y gitignoreado, así que un clon nuevo no lo trae y eso no es un
+  // error. Ausente se lee como IDLE, que es lo que significa.
+  const required = ['BACKLOG.md', 'INBOX.md', 'HUMAN_ACTIONS.md', 'PROTOCOL.md']
+  // `DONE.md` se retiró: la evidencia vive en un archivo por tarea. Un `DONE.md` que quede en disco
+  // ya no lo lee nadie, y eso no se nota — las épicas dejan de poder cerrar y sus historias figuran
+  // sin evidencia, que es lo mismo que se vería si nunca se hubieran hecho.
+  // `WIP.md` se retiró por lo mismo que `DONE.md`: era uno solo y lo escribían todos los que corren sobre
+  // una instancia sidecar. Uno que quede en disco ya no lo lee nadie, y su plan a medias se pierde sin
+  // que nada lo diga.
+  if (fs.existsSync(path.join(root, 'WIP.md'))) {
+    errors.push('WIP.md ya no se lee: el plan de cada runner vive en `wip/<runner>.md`; movelo y borralo')
+  }
+  if (fs.existsSync(path.join(root, 'DONE.md'))) {
+    errors.push('DONE.md ya no se lee: pasá cada entrada a su propio `done/<slug>.md` y borralo')
+  }
+  for (const file of required) if (!fs.existsSync(path.join(root, file))) errors.push(`falta ${file}`)
+
+  const configPath = path.join(root, '..', 'ops.config.json')
+  let config = null
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, 'utf8')
+      config = JSON.parse(raw)
+      if (!raw.includes('{{')) {
+        errors.push(...C.validateOpsConfig(config))
+        warnings.push(...C.configWarnings(config))
+        if (Array.isArray(config.workspaceRoots)) {
+          for (const workspace of config.workspaceRoots) {
+            if (workspace && workspace.name && workspace.path
+              && !fs.existsSync(path.resolve(path.dirname(configPath), workspace.path))) {
+              errors.push(`ops.config.json: no existe la raíz ${workspace.name} (${workspace.path})`)
+            }
+          }
+        }
+        // Es la única parte de la configuración que le levanta el límite a un guard, y quien la escribió
+        // no es quien la lee dentro de seis meses: va como advertencia permanente, igual que un override.
+        // Y se muestra resuelta porque resuelta es como la compara el guard — un `~` escrito solo exenta
+        // la casa entera, y escrito no se nota.
+        for (const exempt of CP.writableOutsideRoots(path.dirname(configPath), config)) {
+          warnings.push(`ops.config.json: ${exempt.declared} está exenta del límite `
+            + `de raíces (${exempt.path})`)
+        }
+      }
+    } catch (error) {
+      errors.push(`ops.config.json: JSON inválido (${error.message})`)
+    }
+  } else {
+    warnings.push(`no existe ${path.relative(root, configPath)}`)
+  }
+
+  const epics = P.readEpics(root)
+  const milestones = P.readBacklog(root)
+  const done = P.readDone(root)
+  errors.push(...B.validate(path.join(root, 'business-rules')))
+  errors.push(...SR.validateRoadmapStructure(root))
+  errors.push(...SR.validateBacklogStructure(root))
+  errors.push(...SR.validateRules(root))
+  errors.push(...SR.validateAdr(root))
+  const backlog = milestones.flatMap((milestone) => milestone.tasks)
+  const roles = new Set(AG.list(path.resolve(root, '..')).map((role) => role.slug))
+  const wips = P.readWips(root)
+  const adopted = AD.read(root)
+  errors.push(...SZ.oversizedUnits({ epics, milestones }))
+  errors.push(...PC.validateState({
+    epics, milestones, done, wips, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
+  }))
+  warnings.push(...AD.report({ done, epics, adopted }))
+  warnings.push(...PC.doneCeremonyWarnings(done, new Set(adopted)))
+  // Antes de que el recorrido pague Build para descubrirlo en Verify. Cuesta un regex sobre la cola y
+  // corre en los cuatro carriles, incluidos los que saltean Ready (caso 140).
+  warnings.push(...PC.unverifiableAcceptance(milestones))
+  warnings.push(...R.coverageWarnings(path.resolve(root, '..'), done))
+  // Sin `RECURRING.md` no dice una palabra: una instancia que actualiza y no declara trabajo recurrente
+  // no tiene por qué enterarse de que el contrato existe. Vencida avisa y no frena — lo que frena vive
+  // en `HUMAN_ACTIONS.md`, y un aviso que salta siempre se termina apagando.
+  // Un reclamo que nombra una tarea que no existe bloquea la cola sin que nada lo explique, y uno viejo
+  // la bloquea para siempre. Lo primero es error; lo segundo avisa, porque abandonar no es un defecto.
+  const claims = CL.read(root)
+  errors.push(...CL.validate({ claims, milestones, done }))
+  // Si la rama de cada tarea tomada se movió, que es lo único barato que distingue una tarea larga de
+  // una abandonada. Sin repositorio resoluble el mapa queda vacío y el aviso vuelve a mirar sólo la
+  // fecha, que es lo que había antes: degrada, no rompe.
+  const activity = new Map()
+  for (const claim of claims.filter((one) => !done.set.has(one.slug))) {
+    const at = R.lastCommit(R.repoOf(path.join(root, '..'), claim.service), CL.branchOf(claim.slug))
+    if (at) activity.set(claim.slug, at)
+  }
+  warnings.push(...CL.warnings({ claims, done, today: TODAY(), activity }))
+  const recurring = RC.read(root)
+  errors.push(...RC.validate(recurring))
+  warnings.push(...RC.warnings(RC.status({ ...recurring, done, today: TODAY() })))
+  warnings.push(...IB.warnings(root, done, config))
+  warnings.push(...AD.sealWarnings(root))
+  warnings.push(...R.unrecordedHumanActions(path.resolve(root, '..'), P.readHumanActions(root)))
+  warnings.push(...AP.warnings(path.resolve(root, '..')))
+  warnings.push(...TR.warnings(path.resolve(root, '..')))
+
+  // Lo que `upgrade` conserva por estar editado deja de recibir mejoras, y eso es una deuda que no
+  // avisa sola: la instancia queda con medio molde viejo y todo se ve normal. Sale acá para que se vea
+  // en cada corrida y no sólo el día que alguien actualiza.
+  const congelados = O.localChanges(path.resolve(root, '..'))
+  if (congelados.length) {
+    warnings.push(`${congelados.length} archivo(s) del molde congelados por edición local; `
+      + '`upgrade` los conserva y no les trae mejoras')
+  }
+
+  // Y lo que `upgrade` no retiró porque no pudo demostrar que fuera suyo: queda ahí, sin colgar de
+  // ningún mecanismo, hasta que alguien lo mueva o lo borre. Se cuenta por lo mismo que los congelados
+  // — un resto que no se ve se vuelve permanente.
+  const restos = O.RETIRED_COMPARTIDO.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
+  if (restos.length) {
+    warnings.push(`${restos.length} ruta(s) retiradas siguen en disco con contenido tuyo `
+      + `(${restos.join(', ')}); Cauce ya no las distribuye ni las toca`)
+  }
+
+  const integration = I.validate(path.resolve(root, '..'))
+  errors.push(...integration.errors)
+  warnings.push(...integration.warnings)
+
+  warnings.push(...SR.competingSections(root))
+  // Sobrescribir una entrada de system/ es legítimo y esperado; lo que no puede pasar es que
+  // ocurra en silencio, porque esa entrada deja de recibir las mejoras del toolkit.
+  for (const override of O.overrides(path.resolve(root, '..'))) {
+    // Y con qué se queda el proyecto: un override sano redefine lo que reemplaza, y el que deja IDs
+    // afuera los retira sin decirlo. Nombrarlos es lo único que separa una decisión de un descuido.
+    const retired = override.collection === 'planning/rules'
+      ? SR.retiredByOverride(root, override.project)
+      : []
+    warnings.push(`${override.collection}/${override.project} sobrescribe ${override.system} `
+      + `(override explícito)${retired.length ? `; deja de regir ${retired.join(', ')}` : ''}`)
+  }
+  // Y lo que instaló cada runner, contra esas mismas reglas (caso 099).
+  warnings.push(...RL.staleLines(path.resolve(root, '..')))
+  // Y cuánto pesa lo que ese bloque carga, cuando ya se pasó del umbral. Es la contracara de la línea que
+  // `install` imprime al elegir: una instancia suma reglas de a una, cada una razonable, y el total no lo
+  // mira nadie hasta que una corrida sale cara.
+  warnings.push(...RL.heavyRules(path.resolve(root, '..')))
+  // Misma regla para los cargos, que es donde más caro sale: un fork se hace una vez y se olvida.
+  const FK = require('../agents/fork')
+  for (const entry of FK.drift(path.resolve(root, '..'))) warnings.push(FK.driftLine(entry))
+
+  warnings.push(...OB.missingSections(path.resolve(root, '..')))
+  warnings.push(...OB.orphanCredentials(path.resolve(root, '..')))
+
+  if (cli.has('--json')) {
+    console.log(JSON.stringify({
+      ok: !errors.length,
+      epics: epics.length,
+      queued: backlog.length,
+      done: done.entries.length,
+      wips: wips.map((one) => one.task),
+      errors,
+      warnings,
+    }))
+    if (errors.length) process.exit(1)
+    return
+  }
+
+  for (const warning of warnings) console.warn(`⚠ ${warning}`)
+  for (const error of errors) console.error(`✗ ${error}`)
+  if (errors.length) fail(`\n${errors.length} error(es), ${warnings.length} advertencia(s)`)
+  console.log(
+    `✓ planning válido: ${epics.length} épica(s), ${backlog.length} tarea(s) en cola, ` +
+      `${done.entries.length} terminada(s)`,
+  )
+}
+
+module.exports = { check }

package/engine/planning/contracts.js

@@ -155,6 +155,59 @@ function doneCeremonyWarnings(done, adopted = new Set()) {
   return warnings
 }
 
+// Lo que sólo existe después de Verify: el registro de la tarea, no su producto. `done/<slug>.md` lo
+// escribe Done, el commit lo escribe Commit y el reclamo se libera al cerrar, así que una aceptación que
+// pida verlos pide algo que en Verify todavía no puede estar.
+const POST_VERIFY = [
+  [/\bplanning\/done\b|\bdone\/|\bentrada de DONE\b/i, 'planning/done/'],
+  [/\bla evidencia\b|\bevidencia registrada\b/i, 'la evidencia'],
+  [/\bel commit\b|\bcommitead[oa]\b/i, 'el commit'],
+  [/\bel reclamo\b|\bclaims\//i, 'el reclamo'],
+]
+
+// La salida explícita, con la forma que el repositorio ya usa dos veces: `(sin partir: …)` para el umbral
+// de R17 y `n/a — razón` para `tests:` y `commit:`. Acá vale lo mismo que allá —«como lleva su razón
+// escrita se lee en el propio artefacto sin que nadie la cruce»— y por eso no se intenta adivinar si la
+// prosa excluye a Verify. Adivinarlo es lo que no se puede: la única aceptación real que nombra el commit
+// lo hace justamente para decir que no es condición de Verify, y cualquier lista de frases que la
+// reconociera enseñaría a escribir esa frase exacta para silenciar el aviso.
+const OUT_OF_VERIFY = /\(fuera de verify:\s*[^)]+\)/i
+
+// Una condición de aceptación que nombra el registro en vez del producto no se puede cumplir nunca: se
+// comprueba en Verify, que corre antes que Commit y que Done. El recorrido lo detecta —y hace bien—, pero
+// recién ahí: en la corrida que originó esto fueron 1,2 M de tokens y once agentes para terminar con el
+// trabajo hecho, sin commit y sin poder cerrar (caso 140).
+//
+// Avisa y no falla, por lo mismo que el aviso de HUMAN_ACTIONS resueltas sin commit —que nació del 121,
+// el mismo daño y el mismo tamaño—: el patrón es de texto y una aceptación legítima puede mencionar la
+// palabra sin depender de ella. Un aviso que salta siempre se termina apagando.
+//
+// Se juzga condición por condición y no la aceptación entera, que es el grano con el que Verify contrasta
+// —su `uncovered` enumera criterios—: las aceptaciones reales traen varias y marcar el párrafo completo
+// señala a las que están bien por vecindad. Y la marca se busca en la condición, no en la tarea, para que
+// excluir una no exima a las demás.
+//
+// Lo que corresponde casi siempre no es borrar la cláusula sino moverla: `tests:`, `qa:` y `commit:` de
+// DONE ya exigen ese registro (PROTOCOL), así que repetirlo en la aceptación no agrega garantía — agrega
+// un bloqueo. Cuando sí corresponde dejarla, se declara y pasa en silencio.
+function unverifiableAcceptance(milestones = []) {
+  const warnings = []
+  for (const milestone of milestones) {
+    for (const task of milestone.tasks || []) {
+      for (const condition of String(task.acceptance || '').split(';').map((one) => one.trim())) {
+        if (!condition || OUT_OF_VERIFY.test(condition)) continue
+        const nombra = POST_VERIFY.filter(([pattern]) => pattern.test(condition))
+        if (!nombra.length) continue
+        warnings.push(`BACKLOG ${task.slug}: una condición nombra ${nombra.map(([, what]) => what).join(', ')}`
+          + ', que existe después de Verify, así que no se puede comprobar cuando se la comprueba. Eso va '
+          + 'en tests:, qa: o commit: de su entrada de DONE, que ya lo exigen; si de verdad va acá, '
+          + 'declaralo con "(fuera de verify: <razón>)"')
+      }
+    }
+  }
+  return warnings
+}
+
 function duplicates(values) {
   return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))]
 }
@@ -362,6 +415,7 @@ module.exports = {
   validateState,
   doneEntryErrors,
   doneCeremonyWarnings,
+  unverifiableAcceptance,
   validCommitTrace,
   validDecisionTrace,
   validTestTrace,

package/engine/planning/state.js

@@ -46,7 +46,9 @@ function currentTask({ milestones, done, wips = [], claims = [] }, blockers = []
   const wip = wips.find((one) => one.runner === P.wipName(runner)) || null
   const queue = milestones.flatMap((milestone) => milestone.tasks.map((task) => ({ ...task, hito: milestone.slug })))
   const mine = new Set(claims.filter((one) => runner && one.runner === runner).map((one) => one.slug))
-  const others = new Map(claims.filter((one) => !mine.has(one.slug)).map((one) => [one.slug, one.owner]))
+  // El reclamo entero y no sólo su dueño: quién lo tomó alcanza para decir que la tarea está ocupada, y
+  // no para decir cómo volver a ella. Eso lo dice el id desde el que se tomó, que vive en el mismo archivo.
+  const others = new Map(claims.filter((one) => !mine.has(one.slug)).map((one) => [one.slug, one]))
   if (wip) {
     const active = queue.find((task) => task.slug === wip.task)
       || {
@@ -69,15 +71,23 @@ function currentTask({ milestones, done, wips = [], claims = [] }, blockers = []
     claimed: Boolean(claimed),
     skipped: queue.filter((task) => !done.set.has(task.slug) && blocked.has(task.slug))
       .map((task) => task.slug),
-    taken: pending.filter((task) => others.has(task.slug))
-      .map((task) => ({ slug: task.slug, owner: others.get(task.slug) })),
+    // Un reclamo hecho desde otro id no siempre es de otro agente: puede ser el mismo, con el id resuelto
+    // distinto porque `runner()` lo deduce del árbol donde corre el proceso y en sidecar hay dos árboles
+    // plausibles. Ahí el plan existe, está escrito y queda invisible para quien lo escribió. Por eso viajan
+    // los dos: el id crudo, que es lo que se exporta para volver, y el plan que ese id dejó, si lo dejó.
+    taken: pending.filter((task) => others.has(task.slug)).map((task) => {
+      const claim = others.get(task.slug)
+      const plan = wips.find((one) => one.task === task.slug && one.runner === P.wipName(claim.runner))
+      return { slug: task.slug, owner: claim.owner, runner: claim.runner, wip: plan ? `${plan.runner}.md` : '' }
+    }),
     // Lo que espera a otra tarea, con cuál y quién la tiene: la tercera causa por la que una cola puede
     // no ofrecer nada, y `context` las distingue por la misma razón que distingue las otras dos.
     // El filtro garantiza que hay dependencias y que al menos una no está cerrada —sin eso la tarea
     // estaría lista y no acá—, así que buscarla no puede fallar y no lleva defensa.
     waiting: pending.filter((task) => !others.has(task.slug) && !ready(task)).map((task) => {
       const dep = task.depends.find((one) => !done.set.has(one))
-      return { slug: task.slug, dep, owner: others.get(dep) || (mine.has(dep) ? 'vos' : '') }
+      const otro = others.get(dep)
+      return { slug: task.slug, dep, owner: otro ? otro.owner : (mine.has(dep) ? 'vos' : '') }
     }),
   }
 }

package/package.json

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

package/template/planning/PROTOCOL.md

@@ -12,6 +12,11 @@ invariantes.
   puede heredar aceptación usando `(→ CN) (epic: NNN)` y declarar `(depende: slug, otro)`. Lane y cast son
   opcionales: sin ellos la tarea está sin clasificar, que es un estado y no un error. Una tarea con
   dependencias no se ofrece ni se toma hasta que todas estén en DONE.
+  Una condición se comprueba en Verify, que corre antes que Commit y que Done: la que nombre el commit, el
+  reclamo, `done/` o la evidencia registrada pide algo que todavía no existe cuando se la mira, y su lugar
+  son los campos `tests:`, `qa:` y `commit:` de DONE, que ya lo exigen. `check` lo avisa sobre la cola. Si
+  aun así corresponde dejarla ahí, se declara en la propia condición con `(fuera de verify: <razón>)` —la
+  misma salida explícita que `(sin partir: …)` y que `n/a — razón`— y deja de avisarse.
 - DONE: un archivo por tarea cerrada, `done/<slug>.md`, con su entrada `[x]` y los campos `acept:`,
   `fecha:` en AAAA-MM-DD, `done:`, `qa:`, `tests:`, `commit:` y `lane:`. `lane:` repite el carril con el
   que la tarea corrió —`express`, `directo`, `lite`, `full`— o `sin clasificar` si su línea no lo

package/template/planning/rules/README.md

@@ -26,3 +26,34 @@ lo hace—, y ahí queda exigida sin estar escrita en ningún lado. Por eso `che
 una regla nueva: si lo era, va acá al lado como `P1..Pn` y no se lleva nada puesto.
 
 Las convenciones específicas de lenguaje viven junto al servicio que usa ese lenguaje.
+
+## Una regla que sólo rige sobre una superficie
+
+Toda regla de este directorio se carga en el contexto de arranque de **cada** agente, y eso cuesta: sólo
+lo que trae Cauce son ~16 K tokens por agente, medido. Una regla propia de dos páginas que importa en una
+tarea de cada cien se lee cien veces.
+
+Una regla puede declarar a qué superficie pertenece, y entonces se **nombra** sin cargarse:
+
+```markdown
+---
+aplica: pagos
+---
+
+# Pagos
+
+## P3 — Conciliar antes de cerrar
+```
+
+Qué cambia: el bloque que `automation install` escribe la lista —`- ruta (aplica: pagos)`— en vez de
+importarla, así que pesa una línea y no su archivo entero. Sigue rigiendo igual: `ops context` la devuelve
+entre las reglas del proyecto, el recorrido se la nombra a cada agente que toca código, y quien trabaje
+sobre esa superficie la lee antes de planificar o construir.
+
+**Sin el campo, la regla se carga siempre.** Es el default a propósito: una regla que no se leyó no existe,
+así que apartarla del arranque es una decisión del proyecto y nunca algo que se deduzca. Por lo mismo el
+valor es libre y lo elige quien escribe la regla —`pagos`, `infraestructura`, `el front`—: lo que tiene que
+hacer es que quien lo lea sepa cuándo le toca.
+
+Conviene para lo que es de un dominio acotado —un proveedor, un stack, una integración— y no para lo que
+gobierna cómo se trabaja: esas se pagan y se cargan.