@ingeniomaps/cauce 0.80.0 → 0.82.0

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,
 })

package/engine/automation/index.js

@@ -7,6 +7,7 @@ const F = require('../core/files')
 const catalog = require('../agents/catalog')
 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,
   runnerPaths, resolveItem, inline, render, runnerConfig, activated,
@@ -51,7 +52,15 @@ function check(root) {
       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`'
@@ -145,6 +154,10 @@ function doctor(root, name, output = console) {
   } catch (error) {
     errors.push(`${runner.config.target}: ${error.message}`)
   }
+  // Una regla nueva cambia el render: se dice cuál, y calla el genérico, que mandaba a buscar un cambio de Cauce.
+  const ruled = RL.drift(root, name)
+  warnings.push(...ruled.map((one) => RL.driftLine(name, one)))
+  const quiet = (item) => ruled.some((one) => one.target === item.target)
   for (const item of runner.instructions || []) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
     // El archivo compartido no se compara entero: alrededor del bloque vive el texto de la empresa, así
@@ -155,7 +168,7 @@ function doctor(root, name, output = console) {
       if (!fs.existsSync(resolved.target)) errors.push(`falta ${item.target}`)
       else if (!fs.readFileSync(resolved.target, 'utf8').includes(blockStart(name))) {
         errors.push(`${item.target}: no tiene las instrucciones de Cauce; reinstalá el adaptador`)
-      } else if (!blockUpToDate(resolved.target, name, content)) {
+      } else if (!quiet(item) && !blockUpToDate(resolved.target, name, content)) {
         warnings.push(`${item.target}: su bloque de Cauce quedó viejo; reinstalá el adaptador`)
       }
       continue
@@ -168,7 +181,7 @@ function doctor(root, name, output = console) {
     else if (!ownFile && !fs.readFileSync(resolved.target, 'utf8').includes('AGENTS.md')) {
       warnings.push(`${item.target}: no referencia AGENTS.md; verifica las reglas globales`)
     }
-    if (deliveryState(M.readRunners(root), name, resolved, opsPrefix(root)) === 'desactualizado') {
+    if (!quiet(item) && deliveryState(M.readRunners(root), name, resolved, opsPrefix(root)) === 'desactualizado') {
       warnings.push(`${item.target}: Cauce trae una versión más nueva y vos no lo tocaste; reinstalá`)
     }
   }
@@ -179,7 +192,7 @@ function doctor(root, name, output = console) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
     const status = deliveryState(recorded, name, resolved, opsPrefix(root))
     if (status === 'nuevo') errors.push(`falta ${item.target}`)
-    else if (status === 'desactualizado') {
+    else if (status === 'desactualizado' && !quiet(item)) {
       warnings.push(`${item.target}: hay una versión más nueva en Cauce; reinstalá el adaptador`)
     } else if (status === 'ajeno') {
       warnings.push(`${item.target}: lo editaste y es del toolkit; `
@@ -322,7 +335,7 @@ function uninstall(root, name, output = console) {
 
   if (fs.existsSync(paths.configTarget)) {
     const current = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8'))
-    const clean = unmergeConfig(current, runnerConfig(paths, root))
+    const clean = unmergeConfig(unmergeConfig(current, runnerConfig(paths, root)), runner.config.retired || {})
     if (clean && Object.keys(clean).length) F.atomicWriteJson(paths.configTarget, clean)
     else { removeFile(paths.configTarget, paths.install); removed += 1 }
     output.log(`✓ ${name}: ${runner.config.target} sin las entradas de Cauce`)
@@ -389,6 +402,14 @@ function install(root, name, output = console, options = {}) {
     ? { config: {}, dropped: [] }
     : withoutDeliveredHooks(current, live, previous)
   reportRemoved(name, clean.dropped, live, output)
+  // Lo que Cauce entregó en una versión y retiró en otra sin ser un hook, que el merge no saca: las reglas
+  // `permissions.deny` que puso el 092 y sacó el 104. Se va exactamente lo que el adaptador declara como
+  // retirado; una regla de la empresa que no coincide letra por letra se queda.
+  if (runner.config.retired) {
+    const before = JSON.stringify(clean.config)
+    clean.config = unmergeConfig(clean.config, runner.config.retired) || {}
+    if (JSON.stringify(clean.config) !== before) output.log(`− ${name}: quitadas las reglas que Cauce ya no entrega`)
+  }
   F.atomicWriteJson(paths.configTarget, mergeConfig(clean.config, incoming))
   // Dónde aterrizó, no sólo qué archivo: en sidecar el destino no es el repo desde el que se corrió
   // el comando, y descubrirlo por sorpresa es la diferencia entre confiar y adivinar.
@@ -424,7 +445,9 @@ function install(root, name, output = console, options = {}) {
       continue
     }
     if (status === 'ajeno' && ownFile) {
-      output.log(`= ${name}: conservado ${resolved.item.target} (tiene cambios tuyos)`)
+      output.log(RL.refresh(resolved.target, render(resolved.source, prefix, resolved.automationRoot, resolved.opsRoot))
+        ? `✓ ${name}: ${resolved.item.target} conserva tus cambios y recibió las reglas vigentes`
+        : `= ${name}: conservado ${resolved.item.target} (tiene cambios tuyos)`)
     } else if (status === 'al día') {
       output.log(`= ${name}: ${resolved.item.target} ya está al día`)
     } else {

package/engine/automation/rules.js

@@ -0,0 +1,122 @@
+'use strict'
+
+// Cómo llegan a un runner las reglas que rigen la instancia (casos 099 y 105). Su archivo de instrucciones las
+// nombraba fijas —las cuatro de `system/`—, así que la sesión cargaba la que la empresa había sobrescrito y
+// ninguna de las propias. El adaptador trae un marcador y el motor lo resuelve contra `effectiveRules` al
+// instalar. Y como `upgrade` no reinstala, `check` y `doctor` comparan lo instalado con lo vigente.
+
+const fs = require('node:fs')
+const F = require('../core/files')
+const O = require('../core/ownership')
+
+// `imports` para el runner que carga archivos con `@ruta`; `list` para el que sólo lee prosa, donde un `@` no
+// significa nada.
+const MARKER = /\{\{RULES:(imports|list)\}\}/g
+const START = '<!-- cauce:reglas inicio — lo reescribe "automation install" con las reglas vigentes -->'
+const END = '<!-- cauce:reglas fin -->'
+// Se reconoce por el arranque y no por la línea entera: quien quiera el bloque en un archivo propio escribe las
+// dos marcas a mano, y pedirle el texto exacto de la primera es pedirle que acierte un guion largo.
+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*$/
+
+// 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'))
+}
+
+function blockOf(text) {
+  const start = text.indexOf(START_AT)
+  if (start === -1) return null
+  const end = text.indexOf(END, start)
+  if (end === -1) return null
+  return { start, end: end + END.length, body: text.slice(start, end + END.length) }
+}
+
+// Las reglas que nombra un archivo instalado, relativas a la raíz ops: las del bloque o, si es anterior al
+// bloque, sus imports sueltos.
+function listed(text) {
+  const found = blockOf(text)
+  const lines = found ? found.body.split('\n') : text.split('\n').filter((line) => LEGACY_IMPORT.test(line))
+  return lines.map((line) => (line.match(/planning\/rules\/[^\s`]+\.md/) || [])[0]).filter(Boolean)
+}
+
+// Un archivo de instrucciones con cambios de la empresa se conserva, y hasta acá eso lo dejaba sin reglas
+// nuevas para siempre. Recibe el bloque donde estaba el suyo, o donde estaban los imports fijos de antes, y el
+// resto queda como lo dejó quien lo editó. Devuelve null si el archivo no tiene dónde recibirlo: uno propio,
+// sin marcas ni imports de Cauce, no se toca.
+function withBlock(text, rendered) {
+  const fresh = blockOf(rendered)
+  if (!fresh) return null
+  const current = blockOf(text)
+  if (current) return `${text.slice(0, current.start)}${fresh.body}${text.slice(current.end)}`
+  const lines = text.split('\n')
+  const first = lines.findIndex((line) => LEGACY_IMPORT.test(line))
+  if (first === -1) return null
+  const kept = lines.filter((line, index) => index === first || !LEGACY_IMPORT.test(line))
+  kept[first] = fresh.body
+  return kept.join('\n')
+}
+
+// Qué archivos de un runner nombran otras reglas que las vigentes: sólo los que su adaptador entrega con el
+// marcador y que están en disco. Se carga tarde porque `runners` usa `fill` para renderizar.
+function drift(root, name) {
+  const { runnerManifest, runnerPaths, resolveItem } = require('./runners')
+  const runner = runnerManifest(root, name)
+  const paths = runnerPaths(root, name, runner)
+  const expected = O.effectiveRules(root)
+  const found = []
+  for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
+    const { source, target } = resolveItem(paths, root, name, item)
+    if (!fs.existsSync(target) || !fs.readFileSync(source, 'utf8').includes('{{RULES:')) continue
+    const text = fs.readFileSync(target, 'utf8')
+    const have = listed(text)
+    const missing = expected.filter((file) => !have.includes(file))
+    const extra = have.filter((file) => !expected.includes(file))
+    if (!blockOf(text) && !have.length) found.push({ target: item.target, bare: true, missing, extra })
+    else if (missing.length || extra.length) found.push({ target: item.target, bare: false, missing, extra })
+  }
+  return found
+}
+
+// Escribe el bloque nuevo dentro de un archivo con cambios propios; dice si hubo algo que escribir.
+function refresh(file, rendered) {
+  const current = fs.readFileSync(file, 'utf8')
+  const updated = withBlock(current, rendered)
+  if (updated === null || updated === current) return false
+  F.atomicWrite(file, updated)
+  return true
+}
+
+function driftLine(name, one) {
+  if (one.bare) {
+    return `${one.target} no carga las reglas vigentes; reinstalá el adaptador (make install-${name}), `
+      + `y si ese archivo es tuyo, marcá dónde va el bloque con ${START_AT} --> y ${END}`
+  }
+  const parts = [
+    one.missing.length ? `no carga ${one.missing.join(', ')}` : '',
+    one.extra.length ? `carga ${one.extra.join(', ')}, que ya no rige` : '',
+  ].filter(Boolean)
+  return `${one.target} ${parts.join(' y ')}; reinstalá el adaptador (make install-${name})`
+}
+
+// Lo mismo para cada runner que esta instancia instaló, que es lo que `check` mira en cada corrida: una regla
+// escrita después de instalar, o traída por un `upgrade`, no llega a ninguna sesión hasta reinstalar.
+function staleLines(root) {
+  const { RUNNER_NAMES } = require('./runners')
+  const recorded = Object.keys(require('../core/manifest').readRunners(root))
+  const lines = []
+  for (const name of RUNNER_NAMES) {
+    if (!recorded.some((key) => key.startsWith(`${name}/`))) continue
+    // Sin el paquete no hay adaptador contra el cual comparar, y eso ya lo dice `automation doctor`.
+    try { for (const one of drift(root, name)) lines.push(`${name}: ${driftLine(name, one)}`) } catch { continue }
+  }
+  return lines
+}
+
+module.exports = { fill, refresh, drift, driftLine, staleLines }

package/engine/automation/runners.js

@@ -10,6 +10,7 @@ const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const F = require('../core/files')
 const O = require('../core/ownership')
+const { fill } = require('./rules')
 
 const RUNNER_NAMES = ['claude', 'codex', 'gemini', 'antigravity']
 
@@ -126,8 +127,9 @@ function inline(text, automationRoot) {
 // archivo se rompe si el proyecto se mueve, así que la lleva sólo el que se queda sin alternativa.
 const OPS_ROOT = '{{OPS_ROOT}}'
 
+// `{{RULES:…}}` va antes que `{{OPS_DIR}}` por lo mismo que el include: las rutas que escribe llevan el prefijo.
 function render(file, prefix, automationRoot, opsRoot = '') {
-  return inline(fs.readFileSync(file, 'utf8'), automationRoot)
+  return fill(inline(fs.readFileSync(file, 'utf8'), automationRoot), opsRoot)
     .split(OPS_ROOT).join(opsRoot)
     .split(OPS_DIR).join(prefix)
 }