@ingeniomaps/cauce 0.81.0 → 0.83.0

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,10 @@ 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,
+    // La fecha, del mismo comando que trae los nombres (caso 115).
+    today: { type: 'string' },
     owners: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
       domain: { type: 'string' }, agent: { type: 'string' },
     } } },
@@ -161,6 +166,8 @@ 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 its inbox field into inbox and its today field ` +
+  `into today, both verbatim, and nothing else it printed.\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 ` +
@@ -197,6 +204,11 @@ const RULES = `${BASE}\n\nRecorrido ${contract.name}: ${contract.purpose}\n` +
     + `destino, sale de esa lista; si ninguno sirve, decilo con su razón en vez de inventar uno.\n` : ''}` +
   `Contexto de la empresa en ${WORKDIR}/organization/. Intención a evaluar: ${GOAL}`
 
+// De qué vía sale lo que este recorrido escriba en el INBOX: el recorrido, el equipo que lo corrió y la
+// fecha que dio el motor. En modo informe la unidad es el informe y esa rama arma la suya, porque es
+// donde queda la evidencia de lo que se anotó.
+const ORIGIN = inboxOrigin('flow', FLOW, contract.today)
+
 phase('Stages')
 
 const handoffs = []
@@ -398,17 +410,40 @@ 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 reportOrigin = inboxOrigin('flow', report.file, contract.today)
+  const listed = followUps.slice(0, INBOX_CAP)
+    .map((one) => ({ section: one.section, entry: withOrigin(one.entry, reportOrigin) }))
+  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, reportOrigin)} ` +
+      `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 +466,8 @@ 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, ORIGIN)} ` +
+    `Motivo: ${withOrigin(epic.reason, ORIGIN)}`,
     { label: 'inbox-lesson' },
   )
   return stop('no-viable', epic.reason)
@@ -442,7 +478,8 @@ 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, ORIGIN)} ` +
+    `Qué falta averiguar: ${withOrigin(epic.reason, ORIGIN)}`,
     { 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,10 @@ 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' } },
+    // La fecha que lleva la procedencia de lo que se escriba en Ideas (caso 115).
+    today: { type: 'string' },
   },
 }
 
@@ -104,13 +109,15 @@ 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 and its today ` +
+  `into today, both 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 +187,32 @@ 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.
+// De qué vía salieron: este recorrido y la fecha del motor. Un arranque no tiene ni tarea ni informe que
+// nombrar, así que su procedencia son esas dos partes y nada más (caso 115). El log de las que no entran
+// se queda sin ella: quien lo lee está mirando la corrida que las produjo.
+const ORIGIN = inboxOrigin('onboard', state.today)
+const questions = (drafted.openQuestions || []).map(oneLine)
+const inboxed = questions.slice(0, INBOX_CAP).map((one) => withOrigin(one, ORIGIN))
+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 || [] }, ORIGIN)}\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 +246,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; `
@@ -432,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)
 }

package/engine/cli/instance.js

@@ -13,6 +13,7 @@ const M = require('../core/manifest')
 const OB = require('../core/onboarding')
 const P = require('../planning/parser')
 const ST = require('../planning/state')
+const RC = require('../planning/recurring')
 const A = require('../automation')
 const { fail } = require('./io')
 const { declareEngine, pinEngine, undeclareEngine } = require('./dependency')
@@ -97,6 +98,7 @@ function scaffold(root, { name, mode, force = false, quiet = false }) {
     '{{PROJECT_NAME}}': name,
     '{{MODE}}': mode,
     '{{WORKSPACE_PATH}}': mode === 'embedded' ? '.' : '..',
+    ...RC.sinceValues(new Date().toISOString().slice(0, 10)),
   }, force, providerNames(), quiet)
   // No se copia `.github/`: `ci.yml` valida el toolkit con `npm run ci` —que una instancia no tiene— y
   // el ciclo de aprendizaje dejó de distribuirse en 0.4.0. Copiar salteando lo que no aplica dejaba
@@ -113,8 +115,9 @@ function scaffold(root, { name, mode, force = false, quiet = false }) {
   declareEngine(path.join(root, 'package.json'), version)
   let deliveredPaths = {}
   for (const relative of O.trackedPaths()) {
-    const dir = path.join(root, relative)
-    if (fs.existsSync(dir)) deliveredPaths = M.record(root, relative, O.treeFiles(dir), deliveredPaths)
+    if (fs.existsSync(path.join(root, relative))) {
+      deliveredPaths = M.record(root, relative, O.deliveredFiles(root, relative), deliveredPaths)
+    }
   }
   deliveredPaths = M.recordPaths(root, O.SYSTEM_FILES, deliveredPaths)
   // Adoptar Cauce en un repositorio con contenido es `init --force`, y lo que se conserva ahí lo
@@ -277,12 +280,14 @@ function upgrade(dir, cli) {
   const to = require(path.join(PROJECT_ROOT, 'package.json')).version
   const system = O.systemPaths(root)
   const changed = O.localChanges(root)
+  const colliding = O.collisions(root)
   const overrides = O.overrides(root)
 
   // El código de salida lo aplica acá y no adentro: `--check` mira y cuenta, y quien decide qué hacer
   // con lo que vio es el comando. Escondido en la función que informa, el corte del flujo no se ve.
   if (dry) {
-    const code = previewUpgrade({ from, to, changed })
+    for (const file of colliding) console.log(`  choca con uno tuyo: ${file}`)
+    const code = previewUpgrade({ from, to, changed }) || (colliding.length ? 1 : 0)
     if (code) process.exit(code)
     return
   }
@@ -311,6 +316,16 @@ function upgrade(dir, cli) {
     console.log(`${adviceFor([...conservados])}\n`)
     console.log('Para tomar la versión nueva y descartar la tuya, repetí con --force.\n')
   }
+  // Un archivo propio que se llama como uno que el paquete empieza a traer (caso 110): se conserva y se
+  // dice, igual que una edición local, y `--force` lo reemplaza diciéndolo.
+  const choques = new Set(force ? [] : colliding)
+  for (const file of choques) {
+    console.log(`= conservado ${file}: ya existía y Cauce no lo entregó, así que el del paquete no se `
+      + 'instaló. Renombrá el tuyo y repetí, o repetí con --force para reemplazarlo.')
+  }
+  if (force) {
+    for (const file of colliding) console.log(`− reemplazado ${file}, que era tuyo y se llamaba como uno del paquete`)
+  }
 
   // Lo que una versión agrega y es del proyecto: se crea si falta y nunca se pisa. `systemPaths` no lo
   // incluye a propósito —lo reemplazaría en cada actualización, que es lo que un archivo del proyecto
@@ -330,6 +345,7 @@ function upgrade(dir, cli) {
       '{{PROJECT_NAME}}': config.project || path.basename(root),
       '{{MODE}}': O.mode(root),
       '{{WORKSPACE_PATH}}': O.mode(root) === 'embedded' ? '.' : '..',
+      ...RC.sinceValues(new Date().toISOString().slice(0, 10)),
     })) content = content.replaceAll(key, value)
     F.atomicWrite(target, content)
     added.push(relative)
@@ -350,7 +366,10 @@ function upgrade(dir, cli) {
     }
   }
 
-  const conservar = (file) => conservados.has(path.relative(root, file).replace(/\\/g, '/'))
+  const conservar = (file) => {
+    const relative = path.relative(root, file).replace(/\\/g, '/')
+    return conservados.has(relative) || choques.has(relative)
+  }
   for (const relative of [...system, ...O.RUNTIME_PATHS]) {
     const origin = path.join(PROJECT_ROOT, O.sourceOf(relative))
     if (!fs.existsSync(origin)) continue
@@ -396,11 +415,21 @@ function upgrade(dir, cli) {
   // la puerta de atrás, y no se ve mirando el archivo — se ve dos upgrades después.
   const entregado = { ...record }
   for (const relative of O.trackedPaths()) {
-    const dir = path.join(root, relative)
-    if (fs.existsSync(dir)) record = M.record(root, relative, O.treeFiles(dir), record)
+    if (fs.existsSync(path.join(root, relative))) {
+      record = M.record(root, relative, O.deliveredFiles(root, relative), record)
+    }
+  }
+  // Migración: una versión anterior pudo haber registrado un guard propio —qué cuenta, en `deliveredFiles`—.
+  // Se olvida acá. Y un choque que se conservó no se registra, para que la corrida siguiente lo vuelva a ver.
+  for (const relative of O.RUNTIME_PATHS) {
+    const shipped = O.shippedFiles(relative)
+    for (const key of Object.keys(record)) {
+      if (key.startsWith(`${relative}/`) && !shipped.has(key.slice(relative.length + 1))) delete record[key]
+    }
   }
   record = M.recordPaths(root, O.SYSTEM_FILES, record)
   for (const file of conservados) if (entregado[file]) record[file] = entregado[file]
+  for (const file of choques) delete record[file]
   // El registro de forks se poda igual que el de archivos: un cargo devuelto al catálogo deja su
   // entrada, y una entrada sin copia sólo puede producir avisos sobre algo que no está.
   const kept = Object.fromEntries(Object.entries(M.readForks(root)).filter(

package/engine/cli/planning.js

@@ -11,6 +11,7 @@ const PC = require('../planning/contracts')
 const SR = require('../planning/structure')
 const SZ = require('../planning/sizing')
 const RC = require('../planning/recurring')
+const IB = require('../planning/inbox')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const ST = require('../planning/state')
@@ -23,6 +24,7 @@ const OB = require('../core/onboarding')
 const C = require('../config/validate')
 const CP = require('../config/paths')
 const AG = require('../agents/catalog')
+const RL = require('../automation/rules')
 const { fail, planningRoot } = require('./io')
 
 // Qué dimensiones enumera el molde de `organization/` y cuáles dejaron de estar. Un agente que reescribe
@@ -97,12 +99,14 @@ function check(dir, cli) {
   for (const file of required) if (!fs.existsSync(path.join(root, file))) errors.push(`falta ${file}`)
 
   const configPath = path.join(root, '..', 'ops.config.json')
+  let config = null
   if (fs.existsSync(configPath)) {
     try {
       const raw = fs.readFileSync(configPath, 'utf8')
-      const config = JSON.parse(raw)
+      config = JSON.parse(raw)
       if (!raw.includes('{{')) {
         errors.push(...C.validateOpsConfig(config))
+        warnings.push(...C.configWarnings(config))
         if (Array.isArray(config.workspaceRoots)) {
           for (const workspace of config.workspaceRoots) {
             if (workspace && workspace.name && workspace.path
@@ -169,6 +173,7 @@ function check(dir, cli) {
   const recurring = RC.read(root)
   errors.push(...RC.validate(recurring))
   warnings.push(...RC.warnings(RC.status({ ...recurring, done, today: TODAY() })))
+  warnings.push(...IB.warnings(root, done, config))
   warnings.push(...AD.sealWarnings(root))
   // Una aprobación vale para el conjunto que nombra, así que olvidada sigue autorizando
   // esas mismas rutas la próxima vez que alguien las stagee. No caduca sola: lo que la cierra es que se
@@ -213,6 +218,8 @@ function check(dir, cli) {
     warnings.push(`${override.collection}/${override.project} sobrescribe ${override.system} `
       + `(override explícito)${retired.length ? `; deja de regir ${retired.join(', ')}` : ''}`)
   }
+  // Y lo que instaló cada runner, contra esas mismas reglas (caso 099).
+  warnings.push(...RL.staleLines(path.resolve(root, '..')))
   // Misma regla para los cargos, que es donde más caro sale: un fork se hace una vez y se olvida.
   const FK = require('../agents/fork')
   for (const entry of FK.drift(path.resolve(root, '..'))) warnings.push(FK.driftLine(entry))
@@ -380,8 +387,14 @@ function context(dir, cli) {
     // mismo criterio. Por qué no la encola una máquina está en la fase Pick de `autobuild`.
     nextEpic: (!task && [...state.epics].filter((one) => one.status === 'open')
       .sort((a, b) => String(a.num).localeCompare(String(b.num)))[0]) || null,
+    // Sólo en el JSON: lo leen los recorridos que escriben en el INBOX, para no repetir un nombre.
+    inbox: P.inboxHeads(root),
+    // Las reglas que rigen, con los overrides resueltos. Van acá porque `autobuild` ya lee este comando y
+    // tiene prohibido abrir otros archivos para completar su contrato (caso 105).
+    rules: O.effectiveRules(path.resolve(root, '..')),
   }
   if (cli.has('--json')) return console.log(JSON.stringify(report))
+  const reglas = () => console.log(`RULES  ${report.rules.join(', ') || '(ninguna)'}`)
 
   if (report.blocked === 'awaiting-review') {
     const first = P.read(gate).split('\n').find((line) => line.trim() && !line.startsWith('#')) || ''
@@ -419,7 +432,7 @@ function context(dir, cli) {
     espera()
     for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
     due()
-    return
+    return reglas()
   }
   console.log(`TASK   ${report.task.slug}${report.task.tier ? ` [${report.task.tier}]` : ''}` +
     `${report.task.service ? `  service: ${report.task.service}` : ''}` +
@@ -448,6 +461,7 @@ function context(dir, cli) {
   if (report.blockedTasks.length) console.log(`SKIP   ${report.blockedTasks.join(', ')} (acción humana abierta)`)
   for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
   due()
+  reglas()
 }
 
 // Qué trabajo recurrente vence, y la línea con la que se promueve. Emite esa línea y no la escribe: