@ingeniomaps/cauce 0.81.0 → 0.82.0

package/CHANGELOG.md

@@ -14,6 +14,134 @@ 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.82.0] - 2026-09-11
+
+### Cambiado
+
+- **`allowPush: true` ya no publica en la rama viva ni desde un subagente.** La llave dejaba pasar cualquier
+  push, `main` incluido, y el de un subagente igual que el tuyo. Ahora no alcanza a `main`, `master` ni a la
+  rama por defecto del remoto, y un subagente no publica con ningún permiso. Tampoco la alcanza una orden en
+  el chat.
+
+  **Qué cambia para vos**: si publicabas en la rama viva con `allowPush: true`, agregá
+  `"pushToLiveBranches": ["main"]` en `runner` de `ops.config.json`, o pegá `push origin main` en
+  `planning/.ops-approval` para un push puntual.
+
+- **R10 y el párrafo de publicación de `AGENTS.md` se reescribieron.** Los dos decían que el push se
+  comprueba contra `runner.allowPush` y nada más; ahora dicen lo que de verdad comprueba el motor: esa llave
+  —que no llega a la rama viva sin `runner.pushToLiveBranches`, ni a un subagente— o la orden que la persona
+  da en el chat nombrando el remoto y la rama. Los dos archivos los mantiene Cauce, así que `upgrade` los
+  reemplaza enteros.
+
+  **Qué cambia para vos**: nada que hacer. Si tu equipo cita R10 en algún documento propio, el texto que
+  baja ahora es más largo y dice qué sostiene un guard y qué sostiene una persona.
+
+### Corregido
+
+- **Nombrar algo en el chat ya no lo autoriza: hay que pedirlo.** Desde 0.81.0, lo que nombrabas en el chat
+  pasaba los guards aunque no lo pidieras: «¿para qué sirven las credentials?» dejaba leer `credentials`, y
+  «el .env tiene algo raro?» dejaba leer el `.env`. Ahora la frase que lo nombra tiene que pedir una acción
+  —«leé», «abrime», «borrá», «read»…—, y la negación sigue frenando como antes.
+
+  **Qué cambia para vos**: si pedís algo sin un verbo que Cauce reconozca, el agente te dice qué se frenó y
+  con un «dale» pasa.
+
+- **`upgrade` ya no pisa un guard tuyo que se llama como uno nuevo del paquete.** Cuando una versión empezaba
+  a traer un nombre que ya usabas en `automatization/hooks/`, lo reemplazaba sin decir nada: 0.81.0 lo hizo
+  con `guard-chat.sh`. Ahora lo conserva y lo avisa; `--check` lo cuenta, y `--force` lo reemplaza diciéndolo.
+
+  **Qué cambia para vos**: si ves «ya existía y Cauce no lo entregó», renombrá tu guard y repetí `upgrade`;
+  mientras tanto, el guard del paquete con ese nombre no está instalado.
+
+- **Un guard propio ya no aparece como «editado localmente».** `upgrade` registraba todo lo que había en
+  `automatization/hooks/`, así que editar un guard tuyo lo volvía una edición del molde: `upgrade --check`
+  salía con 1, `check` lo contaba como congelado, y `--force` anunciaba que lo descartaba sin tocarlo. Ahora
+  sólo registra lo que trae el paquete, y el primer `upgrade` suelta lo que una versión anterior registró de
+  más.
+
+  **Qué cambia para vos**: nada que hacer; tus guards dejan de aparecer en esos avisos.
+
+- **El aviso de credenciales sin dueño avisa sólo credenciales.** `check` listaba toda variable que el
+  proyecto declaraba y ningún contrato nombraba: en un proyecto real fueron ciento ocho nombres de build, y
+  la única credencial quedó en «y 1 más». Ahora cuenta las que tienen nombre de secreto —`…_PASSWORD`,
+  `…_TOKEN`, `…_KEY`, `…_DSN`…—, dice en qué servicio está cada una y dónde se escribe su dueño, y avisa
+  aparte cuando un servicio pasó el tope de variables que se revisan.
+
+  **Qué cambia para vos**: la declaración de secretos y la configuración de una integración ahora también
+  rechazan una clave que termine en `_key`, `dsn` o `credentials`, igual que ya rechazaban `…token`. Si
+  tenés una, cambiala por la referencia a una variable de entorno. Y una credencial con nombre de
+  configuración —`STRIPE_LIVE`— no aparece en el aviso: el criterio es el nombre.
+
+- **Una variable ya no se da por cargada porque otra la contiene en su nombre.** Con `API_SECRET_ROTATION`
+  escrita en `organization/workspace.md`, `API_SECRET` dejaba de avisarse aunque nadie la nombrara. Ahora
+  cuenta sólo el nombre entero.
+
+  **Qué cambia para vos**: puede aparecer en el aviso una credencial que antes quedaba tapada; escribí su
+  dueño y se va.
+
+- **Un push que pedís en el chat ya no se frena.** Con `allowPush: false`, `git push` se frenaba aunque lo
+  hubieras pedido con todas las letras. Ahora pasa si tu mensaje nombra el remoto y la rama —«subí feat/x a
+  origin», `git push origin feat/x`—, y si no los nombra, el agente te dice qué se frenó y con un «dale»
+  pasa ese push y ningún otro. `planning/.ops-approval` también acepta la línea `push <remoto> <rama>`, tal
+  cual y sin patrones. Un `git push origin +rama` ahora se frena como el `--force` que es.
+
+  **Qué cambia para vos**: para publicar una rama de trabajo alcanza con pedirlo nombrando remoto y rama, o
+  con contestar «dale».
+
+- **La sesión carga las reglas que rigen tu proyecto, no las cuatro de `system/` fijas.** El archivo de
+  instrucciones de cada runner importaba siempre `planning/rules/system/`: cargaba la regla que tu proyecto
+  había sobrescrito y ninguna de las tuyas. Ahora `automation install` pone las vigentes —las tuyas y las de
+  `system/` que no sobrescribiste— en Claude, Gemini, Codex y Antigravity, y un `CLAUDE.md` que editaste
+  recibe el bloque nuevo sin perder lo tuyo. Como `upgrade` no reinstala, `check` y `automation doctor`
+  avisan cuando lo instalado quedó atrás. `AGENTS.md` dice ahora que, donde una regla tuya y una del
+  sistema chocan, rige la tuya.
+
+  **Qué cambia para vos**: después de actualizar, o cada vez que escribas o sobrescribas una regla,
+  reinstalá el adaptador (`make install-claude`, o el de tu runner); `check` te dice cuándo hace falta. Si
+  tu `CLAUDE.md` es tuyo y no tiene nada de Cauce, poné las marcas `<!-- cauce:reglas inicio -->` y
+  `<!-- cauce:reglas fin -->` donde quieras el bloque y reinstalá.
+
+- **`autobuild` trabaja con las reglas de tu proyecto y ya no cita una que retiraste.** Los subagentes
+  planificaban, construían y revisaban sin conocer tus reglas, y la fila que pedía partir una tarea citaba
+  R17 aunque la hubieras retirado. Ahora `context` dice qué reglas rigen —línea `RULES`, campo `rules` en
+  `--json`—, cada fase recibe esa lista, y Review tiene que nombrar contra cuáles revisó o la corrida para
+  con `review-unbacked`. Ningún prompt cita una regla por número.
+
+  **Qué cambia para vos**: nada que hacer.
+
+- **Los recorridos ya no llenan el INBOX sin medida.** `autobuild` volcaba en Propuestas todo lo que Review
+  anotaba sin frenar, entero, y `flow` y `onboard` escribían sin tope ni forma. Ahora cada recorrido escribe
+  como mucho tres entradas por tarea o por corrida, de una línea, con la forma del molde y sin repetir un
+  nombre que ya está. Lo que pasa del tope no se pierde: `autobuild` lo cuenta en el `done/` de la tarea,
+  `flow` lo deja en el informe y `onboard` lo nombra al cerrar. Y `check` avisa, sin fallar, cuando
+  `INBOX.md` pasa de 300 líneas.
+
+  **Qué cambia para vos**: nada que hacer. Si querés otro umbral para el aviso, poné
+  `"inbox": { "warnLines": N }` en `ops.config.json`. El molde de `INBOX.md` ya no pide la evidencia dentro
+  de una propuesta; tu `INBOX.md` no se toca.
+
+- **La recurrencia que recorre el INBOX viene activa, y descomentar los ejemplos de `RECURRING.md` ya no
+  rompe `check`.** Una instancia nueva trae la fila `inbox`, trimestral, que vence por primera vez tres meses
+  después de `init`. Las filas de ejemplo declaran el `(service: …)` que `check` exige. Y `check` avisa una
+  entrada del INBOX que se llama como una tarea de `done/`: probablemente se promovió y quedó ahí.
+
+  **Qué cambia para vos**: `RECURRING.md` es tuyo y `upgrade` no lo toca. Para tener la recurrencia en una
+  instancia que ya existe, agregá debajo de la tabla
+  `| inbox | trimestral | AAAA-MM-DD | Recorrer el INBOX entero. _Aceptación: ninguna viñeta queda sin decisión de promover, dejar o borrar._ (service: planning) |`
+  con una fecha futura: `Desde` es cuándo vence por primera vez, no el día en que escribís la fila.
+
+- **Dos repositorios que terminan en una carpeta con el mismo nombre ya no salen con el mismo nombre.** Con
+  varias raíces declaradas, el inventario nombraba cada servicio por la **carpeta** de su raíz, así que
+  `../gouduet/keycloak` y `../hypixo/keycloak` salían los dos `keycloak` en `check`, en `onboard` y en
+  `scan`, y no había con qué saber de qué repositorio era cada credencial. Ahora los nombra el `name` que
+  cada raíz declara en `ops.config.json`, y `check` avisa cuando dos raíces se llaman igual, diciendo
+  cuáles son las dos.
+
+  **Qué cambia para vos**: si dos raíces de tu `ops.config.json` comparten `name`, `check` te lo avisa y
+  sigue pasando —renombrá una cuando puedas—. Y donde el `name` y la carpeta difieren, los servicios pasan
+  a listarse con el `name` —el que escribiste vos— en vez de con la carpeta; `onboard --json` sigue
+  emitiendo `roots` como lista de rutas.
+
 ## [0.81.0] - 2026-09-11
 
 ### Cambiado

package/automatization/hooks/README.md

@@ -72,8 +72,8 @@ pidió con todas las letras y lo que el agente decidió solo. `chat` corre sobre
 runner lo dispara cuando ella manda algo, nunca por el resultado de una herramienta— y lo deja donde los
 guards lo leen:
 
-- lo que la persona **nombró** en su mensaje pasa: «leé el `.env`» autoriza leer el `.env`, y «no toques
-  el `.env`» no;
+- lo que la persona **pidió nombrándolo** pasa: «leé el `.env`» autoriza leer el `.env`; «no toques el
+  `.env`» no, y tampoco una pregunta o un comentario que sólo lo nombra —«¿qué tiene el `.env`?»—;
 - lo que se frenó sin que lo nombrara queda anotado, y un «dale» en el mensaje siguiente aprueba
   exactamente eso;
 - `plan-first` no aplica: el plan es del trabajo que va por tareas.

package/automatization/runners/antigravity/rules/cauce.md

@@ -1,7 +1,12 @@
 # Cauce
 
-Lee y cumple `{{OPS_DIR}}AGENTS.md`, `{{OPS_DIR}}planning/PROTOCOL.md` y `{{OPS_DIR}}planning/rules/system/` antes
-de ejecutar trabajo. `{{OPS_DIR}}planning/wip/<runner>.md` es el mutex de
+Lee y cumple `{{OPS_DIR}}AGENTS.md`, `{{OPS_DIR}}planning/PROTOCOL.md` y las reglas que rigen este proyecto
+antes de ejecutar trabajo: las propias y las de `system/` que el proyecto no sobrescribió. Donde una propia
+contradice a una del sistema, rige la propia.
+
+{{RULES:list}}
+
+`{{OPS_DIR}}planning/wip/<runner>.md` es el mutex de
 ejecución y `{{OPS_DIR}}planning/AWAITING_REVIEW.md` bloquea una corrida nueva. No promociones ideas desde INBOX, no
 inventes aprobaciones o credenciales y no hagas push ni deploy. Cierra cada tarea con verificación real y
 evidencia en DONE.

package/automatization/runners/claude/CLAUDE.md

@@ -2,10 +2,7 @@
 
 @{{OPS_DIR}}AGENTS.md
 @{{OPS_DIR}}planning/PROTOCOL.md
-@{{OPS_DIR}}planning/rules/system/process.md
-@{{OPS_DIR}}planning/rules/system/code-shape.md
-@{{OPS_DIR}}planning/rules/system/commits.md
-@{{OPS_DIR}}planning/rules/system/conduct.md
+{{RULES:imports}}
 
 Los hooks de `.claude/settings.json` son obligatorios. En una instancia recién creada, empezá corriendo
 `node {{OPS_DIR}}tools/ops.js onboard`: es instantáneo, y lo primero que imprime es la pregunta con la que

package/automatization/runners/codex/AGENTS.md

@@ -1,8 +1,12 @@
 # Cauce para Codex
 
-`{{OPS_DIR}}AGENTS.md` tiene las reglas del sistema, `{{OPS_DIR}}planning/PROTOCOL.md` es la fuente de
-verdad del proceso y `{{OPS_DIR}}planning/rules/system/` son las reglas que rigen cada tarea. Leelos
-antes de trabajar —los tres, no cuando algo sale mal—: acá sólo está lo específico de este runner.
+`{{OPS_DIR}}AGENTS.md` tiene las reglas del sistema y `{{OPS_DIR}}planning/PROTOCOL.md` es la fuente de
+verdad del proceso. Las reglas que rigen cada tarea en este proyecto son éstas —las propias y las de
+`system/` que el proyecto no sobrescribió—, y donde una propia contradice a una del sistema, rige la propia:
+
+{{RULES:list}}
+
+Leé todo eso antes de trabajar, no cuando algo sale mal: acá sólo está lo específico de este runner.
 
 > Codex lee el `AGENTS.md` de la raíz, que es un nombre compartido entre herramientas. Cuando el repo
 > ops **es** la raíz, este archivo no se instala: el `AGENTS.md` de la empresa ya está ahí y manda.

package/automatization/runners/gemini/GEMINI.md

@@ -2,10 +2,7 @@
 
 @{{OPS_DIR}}AGENTS.md
 @{{OPS_DIR}}planning/PROTOCOL.md
-@{{OPS_DIR}}planning/rules/system/process.md
-@{{OPS_DIR}}planning/rules/system/code-shape.md
-@{{OPS_DIR}}planning/rules/system/commits.md
-@{{OPS_DIR}}planning/rules/system/conduct.md
+{{RULES:imports}}
 
 `{{OPS_DIR}}planning/PROTOCOL.md` es la fuente de verdad. Ejecuta `/cauce:autobuild` fase por fase; los
 workflows JS de Claude son referencia, no un runtime compatible. `{{OPS_DIR}}planning/wip/<runner>.md` es el mutex

package/automatization/shared/inbox.js

@@ -0,0 +1,28 @@
+// Lo que un recorrido le pide a un agente cuando escribe en el INBOX (caso 101). El tope lo aplica el
+// recorrido sobre lo que le pasa al agente, no el agente: pedirle que se limite no es un tope. Lo que no
+// entra se cuenta donde cada recorrido lo deja, y ninguno lo tira en silencio.
+const INBOX_CAP = 3
+// La forma de una entrada, igual a la que declara el molde de `INBOX.md`: quien escribe no tiene que
+// abrir el archivo para saberla. Una prueba ata las dos.
+const INBOX_ENTRY = '- **slug-del-item** — Qué es, y qué se decide o se resuelve con esto.'
+// Los nombres que ya hay, por sección, tal como los imprime `ops context --json` en su campo inbox.
+const INBOX_HEADS = { type: 'object', additionalProperties: false, properties: Object.fromEntries(
+  ['deuda', 'ideas', 'propuestas', 'lecciones'].map((key) => [key, { type: 'array', items: { type: 'string' } }]),
+) }
+// Una entrada es una línea. Un hallazgo de largo libre se recorta antes de llegar a quien lo escribe,
+// porque lo que llega entero es lo que termina copiado entero.
+const oneLine = (text) => {
+  const first = String(text || '').split('\n')[0].trim()
+  return first.length > 240 ? `${first.slice(0, 239)}…` : first
+}
+// La forma y los nombres que ya hay en las secciones donde se va a escribir. Van los nombres y no el
+// archivo: con ellos alcanza para no repetir una entrada, y el archivo entero pesaría lo que el INBOX.
+function inboxAsk(sections, heads) {
+  const known = sections.map((name) => {
+    const names = (heads || {})[name.toLowerCase()] || []
+    return names.length ? `en ${name} ya están ${names.join(', ')}` : `${name} no tiene entradas`
+  }).join('; ')
+  return `Cada entrada con la forma del molde —${INBOX_ENTRY}—: un nombre y una línea, y la evidencia se ` +
+    `cita donde ya vive, no se copia. Por nombre, ${known}: lo que ya esté con uno de esos nombres no se ` +
+    `vuelve a escribir.`
+}

package/automatization/workflows/agent-eval.js

@@ -225,7 +225,7 @@ const verdicts = await pipeline(
     `normas o sistemas de terceros. Enumeralas con el registro que cada una lleva —verificado, ` +
     `documentado, hipótesis, o ninguno— y comprobá las que se puedan comprobar barato: abrí el archivo ` +
     `que cita y leé si dice eso, reproducí la invocación inocua que declara (\`--help\`, \`--version\`, ` +
-    `un comando de sólo lectura), consultá la fuente pública que nombra. Llegá hasta donde R12 permite: ` +
+    `un comando de sólo lectura), consultá la fuente pública que nombra. Sin salirte de la lectura: ` +
     `nunca conectarte a un sistema real ni ejecutar la operación cuyo efecto se describe.\n\n` +
     `Empezá por la afirmación de la que depende la recomendación del cargo, no por la que parezca más ` +
     `discutible: son distintas, y la segunda suele estar bien rotulada porque el cargo esperaba que se la ` +

package/automatization/workflows/autobuild.js

@@ -27,6 +27,7 @@ export const meta = {
 }
 
 {{INCLUDE:shared/workflow-root.js}}
+{{INCLUDE:shared/inbox.js}}
 const CONFIG = `${ROOT}/ops.config.json`
 const P = `${ROOT}/planning`
 const ORG = `${ROOT}/organization`
@@ -82,6 +83,10 @@ const CONTEXT = {
     // Dónde va el plan de este runner. El nombre sale de su id y el recorrido no lo deriva: lo
     // pregunta, igual que la fecha.
     wipFile: { type: 'string' },
+    // Con los nombres que ya hay en el INBOX, Review no vuelve a anotar uno.
+    inbox: { ...INBOX_HEADS },
+    // Las reglas que rigen el proyecto, con los overrides ya resueltos por el motor (caso 105).
+    rules: { type: 'array', items: { type: 'string' } },
   },
 }
 const CLAIM = {
@@ -132,6 +137,10 @@ const DECISION = {
     consulted: { type: 'array', items: { type: 'string' } },
   },
 }
+// Review nombra contra qué reglas revisó (caso 105): recibir las rutas no garantiza abrirlas, y esto es lo único
+// que deja rastro de que se hizo. Critique no lo lleva porque no recibe la lista.
+const REVIEWED = { ...DECISION, required: [...DECISION.required, 'rules'],
+  properties: { ...DECISION.properties, rules: { type: 'array', items: { type: 'string' } } } }
 // Un exit code dice que el test corrió, no que pruebe lo que la tarea prometió: un test que asercia de
 // menos —o que ni existe— sale verde igual, y el guard de verify tampoco lo ve porque también mira exit
 // codes. Por eso `uncovered` se contrasta contra la aceptación leyendo el fuente, no la salida (R9).
@@ -274,6 +283,8 @@ const VERDICT = ' Cerrá con verdict=aprobado si no queda nada por corregir ante
   'si algo no se resuelve acá —el diseño no lo cubre, falta una decisión ajena, o la corrección excede el ' +
   'alcance—. Marcá blocking=true sólo en el hallazgo que impide entregar: el resto queda registrado y no ' +
   'manda a tocar código.'
+// Acompaña a todo prompt con schema REVIEWED.
+const RULED = ' En rules nombrá, por su ruta, cada una de las reglas que rigen contra la que revisaste el diff.'
 // Lo que hay que corregir antes de entregar. El resto de los hallazgos no desaparece: se registra.
 const blockers = (verdict) => verdict.concerns.filter((one) => one.blocking).map((one) => one.detail)
 // Atajo para reconocer un gate que corrió pruebas sin preguntarle a nadie. No alcanza solo y no
@@ -331,12 +342,19 @@ if (!contract.rootOk) {
 
 const bounds = contract.boundaries || []
 const limits = bounds.length ? ` Límites del proyecto: ${bounds.join('; ')}.` : ''
+// Las reglas que rigen el proyecto (caso 105). Las lista `context`, que se lee después del contrato, así que
+// entran al preámbulo cuando esa lectura vuelve. Viajan las rutas y no el texto: el preámbulo se reenvía a cada
+// subagente que toca código, y el texto de las reglas multiplicaría su tamaño por cada uno.
+let governing = []
 // Alcance de escritura: para subagentes que tocan código o ejecutan gates del producto.
-const SCOPE = `${BASE}\n\nProyecto ${contract.project}. workspaceRoots es el límite completo de escritura del ` +
-  `producto: ${contract.workspaceRoots.join('; ')}.${limits} Este preámbulo ya trae el contrato; no vuelvas a leer ` +
-  `${ROOT}/AGENTS.md, ${ORG}/workspace.md, ${CONFIG} ni ${P}/PROTOCOL.md.`
+const SCOPE = () => `${BASE}\n\nProyecto ${contract.project}. workspaceRoots es el límite completo de escritura ` +
+  `del producto: ${contract.workspaceRoots.join('; ')}.${limits} Este preámbulo ya trae el contrato; ` +
+  `no vuelvas a leer ${ROOT}/AGENTS.md, ${ORG}/workspace.md, ${CONFIG} ni ${P}/PROTOCOL.md.` +
+  (governing.length ? ` Las reglas que rigen este proyecto son éstas, relativas a ${ROOT}: ${governing.join(', ')}. ` +
+    'Leé las que toquen tu fase antes de planificar, construir o revisar; donde una propia contradice a una del ' +
+    'sistema, rige la propia.' : '')
 // Formatos de planning: sólo para subagentes que escriben roadmap, BACKLOG, WIP, DONE o gates.
-const LEDGER = `${SCOPE}\n\nContratos de planning, textuales de ${P}/PROTOCOL.md:\n${contract.contracts}`
+const LEDGER = () => `${SCOPE()}\n\nContratos de planning, textuales de ${P}/PROTOCOL.md:\n${contract.contracts}`
 
 // Un subagente puede morir —error terminal tras reintentos, o alguien que lo saltea— y entonces el
 // runtime devuelve `null`. Sin comprobarlo, la primera propiedad que se le pide revienta el recorrido
@@ -352,8 +370,8 @@ const LEDGER = `${SCOPE}\n\nContratos de planning, textuales de ${P}/PROTOCOL.md
 // justo la distinción que hace falta. Lo que evita el olvido es el arnés, que rechaza la llamada sin
 // etiqueta en las cuatro suites del recorrido.
 const read = (prompt, options = {}) => agent(`${BASE}\n\n${prompt}`, options)
-const run = (prompt, options = {}) => agent(`${SCOPE}\n\n${prompt}`, options)
-const write = (prompt, options = {}) => agent(`${LEDGER}\n\n${prompt}`, options)
+const run = (prompt, options = {}) => agent(`${SCOPE()}\n\n${prompt}`, options)
+const write = (prompt, options = {}) => agent(`${LEDGER()}\n\n${prompt}`, options)
 
 // Las tres paradas que dejan una fila en HUMAN_ACTIONS delegan esa escritura a un agente, y esa fila es
 // el único rastro de la parada: sin ella el recorrido informa un estado que el disco no tiene. Por eso
@@ -368,10 +386,11 @@ const registerHuman = async (prompt, label) => (await write(prompt, { label })
 const readContext = () => read(
   `Corré "node tools/ops.js context ${P} --json" desde ${ROOT} y reportá sólo lo que imprimió. Derivá hasTask ` +
   `de si task es null, wipActive de si wip es null, claimed del campo claimed, today y wipFile de sus ` +
-  `campos, y lane ` +
+  `campos, rules del campo rules tal cual, y lane ` +
   `de task.tier; copiá slug, ` +
   `hito, service, acceptance, ` +
-  `epic y cast de task, y epicContext de epic.context —vacío si no hay épica—. El comando es la fuente de ` +
+  `epic y cast de task, epicContext de epic.context —vacío si no hay épica— e inbox tal cual. El comando es ` +
+  `la fuente de ` +
   `verdad: no abras archivos de planning para completarlo. Poné readOk en true sólo si el comando salió ` +
   `con código 0 y devolvió JSON; si falló, readOk en false y el resto en sus valores vacíos, sin ` +
   `deducir el estado de ninguna otra fuente.`,
@@ -405,6 +424,7 @@ if (blocker === 'blocked-on-human') {
 }
 if (blocker) return stop('context-unavailable', `${P} contestó blocked=${JSON.stringify(planning.blocked)}, `
   + 'que no es del vocabulario. No se sabe si hay bloqueo, así que no se sigue como si no lo hubiera.')
+governing = planning.rules || []
 
 let currentMilestone = planning.wipActive ? planning.hito : ''
 const completed = []
@@ -565,7 +585,7 @@ while (rounds++ < MAX_TASKS) {
     const nota = await registerHuman(
       `Registrá ${unit.id} en ${HUMAN}: nadie pudo escribir un plan que sobreviva a la crítica. `
       + `Motivo: ${detail}. La acción humana es revisar si la unidad son dos resultados con vidas `
-      + `distintas y partirla —R17—, o dejarla entera con la razón escrita.`, 'plan-human')
+      + `distintas y partirla, o dejarla entera con la razón escrita.`, 'plan-human')
     return stop(reason, `${detail}${nota}`)
   }
 
@@ -746,8 +766,8 @@ while (rounds++ < MAX_TASKS) {
     let review = await run(
       `${asRole(cast.review)}Revisá el diff real por aceptación, regresiones, seguridad, arquitectura, código ` +
       `generado, migraciones y alcance accidental. Cada cargo revisa su dominio, no el ajeno.${MANIFEST}` +
-      `${VERDICT}`,
-      { schema: DECISION, label: 'review' },
+      `${VERDICT}${RULED}`,
+      { schema: REVIEWED, label: 'review' },
     )
     if (!review) return stop('agent-unavailable', 'Review no devolvió resultado')
     if (review.verdict === 'bloqueado') {
@@ -756,24 +776,38 @@ while (rounds++ < MAX_TASKS) {
     if (blockers(review).length) {
       await write(`Corregí sólo estos hallazgos con evidencia y actualizá el WIP: ${blockers(review).join('; ')}`,
         { label: 'review-fix' })
-      review = await run(`Volvé a revisar el diff corregido de ${task.id}.${MANIFEST}${VERDICT}`,
-        { schema: DECISION, label: 'review' })
+      review = await run(`Volvé a revisar el diff corregido de ${task.id}.${MANIFEST}${VERDICT}${RULED}`,
+        { schema: REVIEWED, label: 'review' })
       if (!review) return stop('agent-unavailable', 'la re-revisión no devolvió resultado')
       if (review.verdict === 'bloqueado' || blockers(review).length) {
         return stop('review-failed', blockers(review).join('; ') || 'sin condiciones nombradas')
       }
     }
+    // Con reglas que rigen, aprobar sin nombrar contra cuáles es la misma falla que la de abajo en otro eje.
+    if (governing.length && !(review.rules || []).length) {
+      return stop('review-unbacked', 'aprobó el diff sin nombrar contra qué reglas revisó')
+    }
+    if (governing.length) log(`Review contra: ${review.rules.join(', ')}`)
     // Aprobar sin declarar qué se abrió no se arregla mandando a tocar código: falló quien revisó.
     if (!review.consulted.length) return stop('review-unbacked', 'aprobó el diff sin declarar qué inspeccionó')
     reviewFact = `${review.verdict} por ${cast.review}, sobre ${review.consulted.join(', ')}`
     // Lo que no impide entregar no manda a tocar código, y tampoco desaparece: la mejora opinable que se
     // corrige a las apuradas cuesta una vuelta y un riesgo que nadie pidió. Va a Propuestas y no a
-    // Lecciones porque lo que la revisión anotó es un cambio del producto con su evidencia; Lecciones es
-    // sobre cómo trabajamos, y ahí el hallazgo queda esperando una promoción que nadie va a hacer.
-    const noted = review.concerns.filter((one) => !one.blocking).map((one) => one.detail)
-    if (noted.length) {
+    // Lecciones porque lo que la revisión anotó es un cambio del producto —su evidencia es la de la
+    // tarea, que queda en `done/`—; Lecciones es sobre cómo trabajamos, y ahí el hallazgo queda
+    // esperando una promoción que nadie va a hacer.
+    const noted = review.concerns.filter((one) => !one.blocking).map((one) => oneLine(one.detail))
+    const kept = noted.slice(0, INBOX_CAP)
+    // Lo que pasa del tope no se escribe y tampoco desaparece: queda contado en el hecho de revisión, que
+    // viaja a `done/`. Una revisión que anota treinta y seis cosas no está priorizando, y el INBOX no las
+    // iba a leer (caso 101).
+    if (noted.length > kept.length) {
+      reviewFact += ` · ${noted.length - kept.length} anotado(s) sin volcar al INBOX`
+    }
+    if (kept.length) {
       await write(`Registrá en la sección Propuestas de ${P}/INBOX.md lo que la revisión de ${task.id} dejó ` +
-        `anotado sin frenar la entrega, sin promover ninguna: ${JSON.stringify(noted)}`, { label: 'review-noted' })
+        `anotado sin frenar la entrega, sin promover ninguna. ${inboxAsk(['Propuestas'], planning.inbox)} ` +
+        `Lo anotado: ${JSON.stringify(kept)}`, { label: 'review-noted' })
     }
   }
 

package/automatization/workflows/flow.js

@@ -16,6 +16,7 @@ export const meta = {
 }
 
 {{INCLUDE:shared/workflow-root.js}}
+{{INCLUDE:shared/inbox.js}}
 
 // Dónde trabaja el recorrido. Normalmente es la raíz donde se lo invocó; `args.root` existe para
 // correrlo sobre otra instancia —el banco desechable con el que `flow-eval` lo mide—, porque un
@@ -58,6 +59,8 @@ const MANIFEST = {
     // `dependsOn`, que se arregló mirando sólo las claves de las etapas.
     completion: { type: 'array', items: { type: 'string' } },
     conditionalAgents: { type: 'array', items: { type: 'string' } },
+    // Con los nombres que ya hay en el INBOX, lo que el recorrido escribe al final no repite uno.
+    inbox: INBOX_HEADS,
     owners: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
       domain: { type: 'string' }, agent: { type: 'string' },
     } } },
@@ -161,6 +164,7 @@ const contract = await agent(
   `only ran on failure the destination came out of memory.\n` +
   `   If command 1 failed, set exists=false, report flows, and stop.\n` +
   `3. "node tools/ops.js agents list --json", which gives each role its resolved path.\n` +
+  `4. "node tools/ops.js context planning --json" — copy only its inbox field into inbox, verbatim.\n` +
   `Report exists=true and these manifest fields: name, purpose, outcome, entryAgent, facilitator, ` +
   `guardrails, decisionOwners flattened into owners as domain/agent pairs, and stages with id, phase, ` +
   `agent, produces, dependsOn and exitGate. Drop every other field the command printed — the schema ` +
@@ -398,17 +402,38 @@ if (contract.outcome === 'report') {
     `sólo llevaba lo que la siguiente necesitaba para decidir.\n\n` +
     `Escribí el informe en ${REPORTS} como ` +
     `<AAAA-MM-DD>-<slug>.md: qué pasó, qué se sabe con evidencia, qué se supone, qué se decidió y qué ` +
-    `queda abierto. Separá causa de síntoma y no atribuyas responsabilidad a personas. Registrá cada ` +
-    `seguimiento en ${INBOX} sin promoverlo, en la sección que le toca por su sujeto: un cambio del ` +
-    `producto con su evidencia va a Propuestas, lo aprendido sobre cómo trabajamos va a Lecciones. ` +
+    `queda abierto. Separá causa de síntoma y no atribuyas responsabilidad a personas. Cada seguimiento ` +
+    `va en lo que queda abierto del informe y además en followUps, del más al menos importante, con la ` +
+    `sección que le toca por su sujeto: un cambio del producto va a Propuestas, lo aprendido sobre cómo ` +
+    `trabajamos va a Lecciones. No escribas en ${INBOX}: eso lo hace el paso siguiente. ` +
     `Toda acción que requiera una persona, en ${HUMAN}.`,
     { schema: { type: 'object', required: ['file', 'followUps'], properties: {
-      file: { type: 'string' }, followUps: { type: 'integer' }, summary: { type: 'string' },
+      file: { type: 'string' }, summary: { type: 'string' },
+      followUps: { type: 'array', items: { type: 'object', additionalProperties: false,
+        required: ['section', 'entry'], properties: {
+          section: { type: 'string', enum: ['Propuestas', 'Lecciones'] }, entry: { type: 'string' },
+        } } },
     } }, label: 'report-write' },
   )
   if (!report) return stop('report-unavailable', 'el informe no devolvió resultado')
-  log(`Informe en ${report.file}. ${report.followUps} seguimiento(s) en el INBOX, sin promover.`)
-  return finish({ flow: FLOW, stages: handoffs.length, report: report.file, promoted: false })
+  // El tope lo aplica el recorrido y no quien escribe, y lo que pasa de él ya está en el informe: al
+  // INBOX va lo que alguien tiene que decidir, no todo lo que el informe dejó abierto (caso 101).
+  const followUps = report.followUps || []
+  const listed = followUps.slice(0, INBOX_CAP).map((one) => ({ section: one.section, entry: oneLine(one.entry) }))
+  if (listed.length) {
+    await agent(
+      `${RULES}\n\nRegistrá en ${INBOX} estos seguimientos del informe ${report.file}, cada uno en su ` +
+      `sección y sin promover ninguno. ${inboxAsk(['Propuestas', 'Lecciones'], contract.inbox)} ` +
+      `Seguimientos: ${JSON.stringify(listed)}`,
+      { label: 'report-inbox' },
+    )
+  }
+  const unlisted = followUps.length - listed.length
+  log(`Informe en ${report.file}. ${listed.length} seguimiento(s) en el INBOX, sin promover` +
+    `${unlisted ? `; ${unlisted} más quedan sólo en el informe, por el tope de ${INBOX_CAP} por corrida` : ''}.`)
+  return finish({
+    flow: FLOW, stages: handoffs.length, report: report.file, followUps: listed.length, unlisted, promoted: false,
+  })
 }
 
 const epic = await agent(
@@ -431,7 +456,7 @@ if (!epic) return stop('draft-unavailable', 'la propuesta de épica no devolvió
 if (epic.outcome === 'no-hacer') {
   await agent(
     `${RULES}\n\nRegistrá la conclusión en la sección Lecciones de ${INBOX}: por qué esta intención no ` +
-    `es viable hoy y qué la haría viable. Motivo: ${epic.reason}`,
+    `es viable hoy y qué la haría viable. ${inboxAsk(['Lecciones'], contract.inbox)} Motivo: ${epic.reason}`,
     { label: 'inbox-lesson' },
   )
   return stop('no-viable', epic.reason)
@@ -442,7 +467,7 @@ if (epic.outcome === 'investigar') {
   await agent(
     `${RULES}\n\nRegistrá en ${HUMAN} qué hay que averiguar antes de poder decidir esta intención y quién ` +
     `puede hacerlo, sin inventar responsables ni fechas, y dejá la conclusión en la sección Ideas de ` +
-    `${INBOX} sin promoverla. Qué falta averiguar: ${epic.reason}`,
+    `${INBOX} sin promoverla. ${inboxAsk(['Ideas'], contract.inbox)} Qué falta averiguar: ${epic.reason}`,
     { label: 'investigar' },
   )
   return finish({ flow: FLOW, stages: handoffs.length, investigate: epic.reason, promoted: false })

package/automatization/workflows/onboard.js

@@ -59,6 +59,7 @@ const BASE = `Nunca inventes clientes, métricas, ingresos, plazos ni responsabl
   `retrasa el único momento en que la herramienta todavía no sirve para nada.`
 
 {{INCLUDE:shared/workflow-finish.js}}
+{{INCLUDE:shared/inbox.js}}
 
 const SCAN = {
   type: 'object', additionalProperties: false, required: ['fresh', 'services'],
@@ -86,6 +87,8 @@ const SCAN = {
       } } },
     externals: { type: 'array', items: { type: 'string' } },
     secrets: { type: 'array', items: { type: 'string' } },
+    // Los nombres que ya hay en Ideas: con `force` el arranque reescribe una instancia que ya tiene INBOX.
+    inboxIdeas: { type: 'array', items: { type: 'string' } },
   },
 }
 
@@ -104,13 +107,14 @@ phase('Scan')
 // Una sola llamada, y todo lo que hace es correr dos comandos y mirar dos archivos. Lo que sigue depende
 // de lo que devuelva, así que gastar más antes de saberlo es gastar a ciegas.
 const state = await agent(
-  `${BASE}\n\nFrom ${ROOT}, run exactly these two commands and report what they printed. Explore nothing ` +
+  `${BASE}\n\nFrom ${ROOT}, run exactly these three commands and report what they printed. Explore nothing ` +
   `else and open no file other than .env.example at the workspace root.\n` +
   `1. "node tools/ops.js onboard --json": the instance state, the workspace inventory, the opening ` +
   `question and the dimensions still uncovered. Copy fresh, opening, followUps, the "need" of each ` +
   `dimension, and every service with its path, its runtimes, its declared commands keeping the source ` +
   `file each command came from, and the variable names its "env" carries. Add nothing it did not print.\n` +
   `2. "node tools/ops.js check planning".\n` +
+  `3. "node tools/ops.js context planning --json": copy its inbox.ideas into inboxIdeas, verbatim.\n` +
   `The inventory already names every credential each service expects: never open a .env file to look for ` +
   `more. Report those names in secrets and the services they point at in externals. A name the inventory ` +
   `carries is declared, and saying otherwise is a claim the repository contradicts.`,
@@ -180,16 +184,28 @@ const drafted = await agent(
   `que no pidas declararlo de nuevo: lo que falta es dónde se carga el valor y quién lo hace, y ningún ` +
   `valor se propone acá. Además, una por cada sistema externo o MCP a conectar, y una por la autoridad ` +
   `del runner, que hoy declara runner.allowPush=false.\n` +
-  `5. Las preguntas que queden abiertas, en la sección Ideas de ${INBOX}, sin promover.\n` +
-  `Devolvé en files cada archivo que tocaste y en assumptions cada supuesto que dejaste marcado.`,
+  `Devolvé en files cada archivo que tocaste, en assumptions cada supuesto que dejaste marcado y en ` +
+  `openQuestions las preguntas que quedaron abiertas, de la más a la menos importante. No las escribas en ` +
+  `${INBOX}: eso lo hace el paso siguiente.`,
   { schema: WRITTEN, label: 'contexto' },
 )
 if (!drafted) return stop('draft-unavailable', 'los borradores no devolvieron resultado')
 
 phase('Epic')
 
+// Las preguntas abiertas van al INBOX con tope, y el tope lo aplica el recorrido: por eso las escribe
+// este paso con lo que el anterior devolvió, y no el anterior mientras las redactaba (caso 101). Las que
+// no entran se dicen al cerrar, que es donde la persona que arrancó la instancia las lee.
+const questions = (drafted.openQuestions || []).map(oneLine)
+const inboxed = questions.slice(0, INBOX_CAP)
+const INBOX_ASK = inboxed.length
+  ? `Registrá además en la sección Ideas de ${INBOX}, sin promover, estas preguntas abiertas: ` +
+    `${JSON.stringify(inboxed)}. ${inboxAsk(['Ideas'], { ideas: state.inboxIdeas || [] })}\n\n`
+  : ''
+
 const epic = await agent(
   `${BASE}\n\n${EVIDENCE}\n\nSupuestos que quedaron escritos: ${JSON.stringify(drafted.assumptions || [])}\n\n` +
+  INBOX_ASK +
   `Escribí en ${ROADMAP} la épica epic-001-<slug>.md siguiendo el contrato de ${P}/PROTOCOL.md: ` +
   `frontmatter epic/title/status/service con status open, criterios **CN** observables, "## Contexto ` +
   `relevante" con rutas reales e historias con (→ CN) y (service: ruta), cada una de menos de cuatro ` +
@@ -223,11 +239,17 @@ const assumptions = (drafted.assumptions || []).length
 const humanActions = (drafted.humanActions || []).length
 log(`Contexto escrito con ${assumptions} supuesto(s) por confirmar y ${humanActions} acción(es) humana(s) en ${HUMAN}.`)
 log(`Épica en ${epic.file}, sin promover: revisala, promoví una historia a un hito del BACKLOG y corré /autobuild.`)
+const unlisted = questions.slice(INBOX_CAP)
+if (unlisted.length) {
+  log(`${unlisted.length} pregunta(s) abierta(s) más no entraron al INBOX (tope de ${INBOX_CAP}): ` +
+    unlisted.join(' · '))
+}
 
 return finish({
   services: services.length,
   assumptions,
   humanActions,
   epic: epic.file,
+  unlistedQuestions: unlisted,
   promoted: false,
 })