@ingeniomaps/cauce 0.92.0 → 0.94.0

package/CHANGELOG.md

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

package/automatization/workflows/autobuild.js

@@ -36,7 +36,6 @@ const BACKLOG = `${P}/BACKLOG.md`
 const doneFile = (slug) => `${P}/done/${slug}.md`
 const HUMAN = `${P}/HUMAN_ACTIONS.md`
 const GATE = `${P}/AWAITING_REVIEW.md`
-const ROADMAP = `${P}/roadmap`
 
 // Estado de planning tal como lo emite `ops context --json`; ningún modelo parsea BACKLOG ni WIP.
 // De a pares, y sin regex: una comilla dentro de un literal de regex desincroniza a las dos puertas que

package/engine/agents/learning.js

@@ -352,8 +352,6 @@ function prepareProposal(root, agent, now = new Date(), period = '', kind = 'age
   const reportDir = path.join(target, 'learning', 'reports')
   const reports = pendingReports(target, sealing)
   const red = verdictFindings(root, target)
-  if (!reports.length && !red.findings.length) return { file: '', created: false, reports: 0 }
-
   const reportPaths = reports.map((name) => path.join(reportDir, name))
   // La misma regla que la rama de recorridos, por el mismo motivo: un documento que no puede decir qué
   // corregir no cambia ningún contrato y cuesta igual la firma humana que uno que sí. Un informe puede

package/engine/automation/check.js

@@ -0,0 +1,95 @@
+'use strict'
+
+// Qué le falta a la superficie de automatización de una instancia, y nada más. Se mira sin tocar: `check`
+// enumera y devuelve; quien decide qué hacer con esa lista es el CLI.
+//
+// Vive aparte de `index.js` porque no comparte nada con los otros tres verbos. Medido antes de partir:
+// `doctor`, `install` y `uninstall` se apoyan en los mismos ayudantes —`deliveryKey`, `deliveryState`,
+// `removeFile`, `probeBridge`—, y este par no toca ninguno. Lo único que comparte son los imports, que es
+// lo que comparte cualquier archivo del directorio.
+//
+// La partición estaba anotada como deuda desde que el archivo cruzó las 500 líneas con el aviso de
+// sidecar del caso 138, estando en 499.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const O = require('../core/ownership')
+const {
+  RUNNER_NAMES, packagedAutomation, runnerManifest, runnerPaths, resolveItem, runnerConfig,
+} = require('./runners')
+const { expectedHooks, staleHooks } = require('./hooks')
+const { hasHooks } = require('./config')
+
+function check(root) {
+  const errors = []
+  const hookDir = path.join(root, 'automatization', 'hooks')
+  if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
+    errors.push('falta automatization/AGENTS.md')
+  }
+  for (const name of expectedHooks()) {
+    const file = path.join(hookDir, name)
+    if (!fs.existsSync(file)) errors.push(`falta automatization/hooks/${name}`)
+    else if (!(fs.statSync(file).mode & 0o111)) {
+      errors.push(`automatization/hooks/${name} no es ejecutable`)
+    }
+  }
+  // El motor puede venir de la dependencia npm o del propio repositorio, y la cascada la resuelve
+  // `packagePath`. Eran tres: la copia vendorizada se retiró en 0.10.0 y esta línea la sobrevivió.
+  if (!O.engineAt(root, path.join('hooks', 'run.js'))) {
+    errors.push('falta engine/hooks/run.js: corré "npm install" en la raíz del repo ops')
+  }
+  const workflows = [
+    'autobuild.js',
+    'flow.js',
+    path.join('integrations', 'sync.js'),
+    path.join('integrations', 'promote.js'),
+  ]
+  const packaged = packagedAutomation(root)
+  for (const name of workflows) {
+    if (!packaged || !fs.existsSync(path.join(packaged, 'workflows', name))) {
+      errors.push(`falta automatization/workflows/${name}: corré "npm install" en la raíz del repo ops`)
+    }
+  }
+  // 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))
+  for (const { file, edited } of staleHooks(root)) {
+    if (choques.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
+    }
+    errors.push(edited
+      ? `automatization/hooks/${file}: lo editaste y es del toolkit; agregá un guard propio al lado `
+        + 'o descartá tu cambio con `cauce upgrade --force`'
+      : `automatization/hooks/${file}: quedó atrás del paquete y ya no protege lo que dice; `
+        + 'corré `cauce upgrade` antes de instalar el runner')
+  }
+  for (const name of RUNNER_NAMES) validateRunnerManifest(root, name, errors)
+  return errors
+}
+
+function validateRunnerManifest(root, name, errors) {
+  try {
+    const runner = runnerManifest(root, name)
+    if (runner.name !== name || runner.schemaVersion !== 1
+      || !runner.config || !runner.capabilities) {
+      errors.push(`${name}: manifest incompleto`)
+      return
+    }
+    const paths = runnerPaths(root, name, runner)
+    const config = runnerConfig(paths, root)
+    if (runner.capabilities.nativeHooks && !hasHooks(config)) {
+      errors.push(`${name}: declara hooks nativos pero no los configura`)
+    }
+    for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
+      const resolved = resolveItem(paths, root, name, item)
+      if (!fs.existsSync(resolved.source)) errors.push(`${name}: falta ${item.source}`)
+    }
+  } catch (error) {
+    errors.push(`${name}: configuración inválida (${error.message})`)
+  }
+}
+
+
+module.exports = { check }

package/engine/automation/index.js

@@ -9,89 +9,22 @@ const O = require('../core/ownership')
 const M = require('../core/manifest')
 const RL = require('./rules')
 const {
-  RUNNER_NAMES, OPS_DIR, OPS_ROOT, packagedAutomation, runnerManifest, installRoot, opsPrefix,
+  RUNNER_NAMES, OPS_DIR, OPS_ROOT, runnerManifest, installRoot, opsPrefix,
   runnerPaths, resolveItem, inline, render, runnerConfig, activated,
 } = require('./runners')
 const { roleCatalog, roleSkill, installRoleSkills } = require('./roles')
 const {
-  GUARD_NAMES, groupWrappers, expectedHooks, supersededGuards,
-  legacyGuardWiring, staleHooks, listHooks,
+  GUARD_NAMES, groupWrappers, supersededGuards,
+  legacyGuardWiring, listHooks,
 } = require('./hooks')
 const {
-  blockStart, mergeConfig, withoutDeliveredHooks, deliveredHookCommands, reportRemoved, includesConfig, hasHooks,
+  blockStart, mergeConfig, withoutDeliveredHooks, deliveredHookCommands, reportRemoved, includesConfig,
   unmergeConfig, isSharedFile, withoutBlock, mergeInstruction, blockUpToDate,
 } = require('./config')
 
-function check(root) {
-  const errors = []
-  const hookDir = path.join(root, 'automatization', 'hooks')
-  if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
-    errors.push('falta automatization/AGENTS.md')
-  }
-  for (const name of expectedHooks()) {
-    const file = path.join(hookDir, name)
-    if (!fs.existsSync(file)) errors.push(`falta automatization/hooks/${name}`)
-    else if (!(fs.statSync(file).mode & 0o111)) {
-      errors.push(`automatization/hooks/${name} no es ejecutable`)
-    }
-  }
-  // El motor puede venir de la dependencia npm o del propio repositorio, y la cascada la resuelve
-  // `packagePath`. Eran tres: la copia vendorizada se retiró en 0.10.0 y esta línea la sobrevivió.
-  if (!O.engineAt(root, path.join('hooks', 'run.js'))) {
-    errors.push('falta engine/hooks/run.js: corré "npm install" en la raíz del repo ops')
-  }
-  const workflows = [
-    'autobuild.js',
-    'flow.js',
-    path.join('integrations', 'sync.js'),
-    path.join('integrations', 'promote.js'),
-  ]
-  const packaged = packagedAutomation(root)
-  for (const name of workflows) {
-    if (!packaged || !fs.existsSync(path.join(packaged, 'workflows', name))) {
-      errors.push(`falta automatization/workflows/${name}: corré "npm install" en la raíz del repo ops`)
-    }
-  }
-  // 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))
-  for (const { file, edited } of staleHooks(root)) {
-    if (choques.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
-    }
-    errors.push(edited
-      ? `automatization/hooks/${file}: lo editaste y es del toolkit; agregá un guard propio al lado `
-        + 'o descartá tu cambio con `cauce upgrade --force`'
-      : `automatization/hooks/${file}: quedó atrás del paquete y ya no protege lo que dice; `
-        + 'corré `cauce upgrade` antes de instalar el runner')
-  }
-  for (const name of RUNNER_NAMES) validateRunnerManifest(root, name, errors)
-  return errors
-}
-
-function validateRunnerManifest(root, name, errors) {
-  try {
-    const runner = runnerManifest(root, name)
-    if (runner.name !== name || runner.schemaVersion !== 1
-      || !runner.config || !runner.capabilities) {
-      errors.push(`${name}: manifest incompleto`)
-      return
-    }
-    const paths = runnerPaths(root, name, runner)
-    const config = runnerConfig(paths, root)
-    if (runner.capabilities.nativeHooks && !hasHooks(config)) {
-      errors.push(`${name}: declara hooks nativos pero no los configura`)
-    }
-    for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
-      const resolved = resolveItem(paths, root, name, item)
-      if (!fs.existsSync(resolved.source)) errors.push(`${name}: falta ${item.source}`)
-    }
-  } catch (error) {
-    errors.push(`${name}: configuración inválida (${error.message})`)
-  }
-}
+// Qué le falta a la superficie de automatización, que no comparte ayudantes con los tres verbos que
+// escriben. Se reexporta para que sus consumidores sigan pidiéndoselo a este módulo.
+const { check } = require('./check')
 
 // Ejecuta el puente del runner tal como él lo invoca, y desde otra carpeta. Instalado no es lo mismo que
 // operativo: un bridge que el runner no puede lanzar —porque su ruta es relativa y el cwd es otro, o

package/engine/automation/rules.js

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

package/engine/cli/contract.js

@@ -72,22 +72,38 @@ const MARKED = /^###\s+Límites\s*$/m
 // No filtra comentarios y no hace falta: una viñeta comentada arranca con `<!--`, así que el filtro de
 // viñetas ya la descarta. Sacar `withoutComments` de acá fue el resultado de una mutación que sobrevivió
 // —apagarlo no ponía nada en rojo—, que es como se ve una defensa que no defiende de nada.
-function declared(raw) {
-  const out = []
+// Un solo recorrido de los bloques: las viñetas, que son los límites declarados, y la prosa que las
+// presenta. Las dos salen de acá porque dónde empieza y dónde termina un bloque se decide una vez; con
+// dos recorridos, el que delimita para `limits` y el que delimita para `warnings` se despegan y nada
+// falla.
+//
+// El intro se corta en la primera viñeta y no al final del bloque, y eso es lo único que separa este
+// arreglo de un silenciador. A un bloque no lo cierra nada más que el próximo encabezado, así que el del
+// molde se extiende hasta donde alguien escriba el suyo: medido sobre un banco, el primer bloque se
+// llevaba adentro los cuatro párrafos que la persona había agregado al final de la sección. Descontar el
+// bloque entero —que es lo que parecía el arreglo— apagaba justo lo que el aviso existe para encontrar.
+const BULLET = /^\s*[-*]\s+/
+function marked(raw) {
+  const bullets = []
+  const intros = []
   let rest = raw
   for (let start = rest.search(MARKED); start >= 0; start = rest.search(MARKED)) {
     const after = rest.slice(start).split('\n').slice(1)
     const end = after.findIndex((line) => /^#{1,3}\s/.test(line))
     const block = end < 0 ? after : after.slice(0, end)
-    out.push(...block
-      .filter((line) => /^\s*[-*]\s+/.test(line))
-      .map((line) => line.replace(/^\s*[-*]\s+/, '').trim())
+    const first = block.findIndex((line) => BULLET.test(line))
+    if (first > 0) intros.push(...block.slice(0, first).map((line) => line.trim()).filter(Boolean))
+    bullets.push(...block
+      .filter((line) => BULLET.test(line))
+      .map((line) => line.replace(BULLET, '').trim())
       .filter(Boolean))
     rest = (end < 0 ? '' : after.slice(end).join('\n'))
   }
-  return out
+  return { bullets, intros }
 }
 
+const declared = (raw) => marked(raw).bullets
+
 function limits(text) {
   const prose = text.split(/\n\s*\n/)
     .map((block) => block.split('\n')
@@ -128,12 +144,23 @@ function warnings(root) {
   const fromTemplate = new Set(paragraphs(
     P.withoutComments(P.section(readIfAny(TEMPLATE_WORKSPACE), /Excepciones de autonom/)),
   ))
-  const declaredHere = new Set(declared(mine))
-  const lost = paragraphs(P.withoutComments(mine))
-    .filter((one) => !fromTemplate.has(one) && !ENUNCIA.test(one) && !declaredHere.has(one))
+  // Se descuenta por línea y no por párrafo, que es donde estaba el defecto: `paragraphs` saca el `- ` y
+  // une las viñetas seguidas en un párrafo solo, así que una lista declarada no era igual a ninguna
+  // entrada de `declared()` y se contaba entera como un límite perdido (caso 159).
+  const { bullets, intros } = marked(mine)
+  const suyo = new Set([...bullets, ...intros])
+  const outside = P.withoutComments(mine).split('\n')
+    .filter((line) => !suyo.has(line.replace(BULLET, '').trim()))
+    .join('\n')
+  const lost = paragraphs(outside)
+    .filter((one) => !fromTemplate.has(one) && !ENUNCIA.test(one))
   if (!lost.length) return []
+  // El aviso nombra el camino declarado y no la gramática, aunque los dos sigan valiendo: desde 0.92.0
+  // hay una forma de arreglar esto que no pide imitar nada, y mandar a la otra es mandar al camino que
+  // el 157 existe para no tener que usar. Quien ya escribió «El runner…» no necesita el aviso — no le
+  // sale.
   return [`organization/workspace.md: ${lost.length} párrafo(s) de "## Excepciones de autonomía" no llegan `
-    + 'a los agentes porque no arrancan con «El runner», «Debe» o «Nunca»: '
+    + 'a los agentes. El que sea un límite va como viñeta bajo `### Límites`: '
     + `${lost.map((one) => `"${one.slice(0, 60)}…"`).join(', ')}`]
 }
 

package/engine/hooks/run.js

@@ -11,6 +11,7 @@ const os = require('node:os')
 const path = require('node:path')
 const { readInput, cwdOf, block, findOpsRoot } = require('./input')
 const shell = require('./shell')
+const { verify } = require('./verify')
 const files = require('./files')
 const chat = require('./chat')
 const { secretsShell } = require('./secrets-shell')
@@ -40,7 +41,7 @@ const guards = {
   'git-add': shell.gitAdd,
   dependencies: shell.dependencies,
   governance: shell.governance,
-  verify: shell.verify,
+  verify,
   'shell-boundary': shell.shellBoundary,
   'secrets-shell': secretsShell,
   'ops-config-shell': opsConfigShell,