@ingeniomaps/cauce 0.81.0 → 0.82.0

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:

package/engine/config/validate.js

@@ -20,7 +20,7 @@ function validateOpsConfig(config) {
   // `cauceVersion` la escribe el toolkit, no la persona: registra de qué versión salió la instancia.
   const allowed = new Set([
     '$schema', 'cauceVersion', 'project', 'mode', 'workspaceRoots', 'writableOutsideRoots', 'runner',
-    'migrations',
+    'migrations', 'inbox',
   ])
   for (const key of Object.keys(config)) {
     if (RETIRED[key]) errors.push(`ops.config.json: ${key} ya no se usa: ${RETIRED[key]}`)
@@ -34,9 +34,26 @@ function validateOpsConfig(config) {
   validateWritable(config.writableOutsideRoots, errors)
   validateRunner(config.runner, errors)
   validateMigrations(config.migrations, errors)
+  validateInbox(config.inbox, errors)
   return errors
 }
 
+// El umbral del aviso de tamaño del INBOX. Sólo un entero positivo: un cero o un texto se leerían como
+// «avisá siempre» o «nunca», y ninguno de los dos es algo que alguien escriba a propósito.
+function validateInbox(inbox, errors) {
+  if (inbox === undefined) return
+  if (!inbox || typeof inbox !== 'object' || Array.isArray(inbox)) {
+    errors.push('ops.config.json: inbox debe ser un objeto')
+    return
+  }
+  for (const key of Object.keys(inbox)) {
+    if (key !== 'warnLines') errors.push(`ops.config.json: inbox.${key} no está permitido`)
+  }
+  if ('warnLines' in inbox && !(Number.isInteger(inbox.warnLines) && inbox.warnLines > 0)) {
+    errors.push('ops.config.json: inbox.warnLines debe ser un entero mayor que cero, o no estar')
+  }
+}
+
 // Qué cuenta como migración para el guard. Sin declararlo, sólo `.sql` — y ése es el default que hace
 // falta decir, porque un proyecto TypeORM, Prisma, Django o Rails tiene el guard cableado y en verde sin
 // que mire una sola migración (caso 077).
@@ -68,11 +85,36 @@ function validateMigrations(migrations, errors) {
   }
 }
 
+// Lo que la configuración tiene de dudoso y no de inválido. Va aparte de `validateOpsConfig` porque lo que
+// aquélla devuelve son errores y la leen también los guards: una advertencia ahí sería un rechazo.
+//
+// Hoy sólo el nombre repetido: dos raíces con el mismo `name` dejan dos servicios indistinguibles en
+// `check`, `onboard` y `scan`, y una credencial que no se puede atribuir a ninguno (caso 113). Avisa y no
+// falla porque nadie eligió su `name` pensando que fuera único, así que rechazarlo le rompería la puerta a
+// una instancia que hoy funciona, y lo que está en juego es un nombre ambiguo, no algo que se pierda.
+function configWarnings(config) {
+  const roots = Array.isArray(config && config.workspaceRoots) ? config.workspaceRoots : []
+  const found = []
+  const named = new Map()
+  for (const workspace of roots) {
+    const name = workspace && typeof workspace.name === 'string' ? workspace.name.trim() : ''
+    if (!name) continue
+    if (named.has(name)) {
+      found.push(`ops.config.json: ${name} nombra dos raíces (${named.get(name)} y ${workspace.path}): `
+        + 'sus servicios salen con el mismo nombre. Renombrá una')
+    } else named.set(name, workspace.path)
+  }
+  return found
+}
+
 function validateWorkspaces(workspaces, errors) {
   if (!Array.isArray(workspaces) || !workspaces.length) {
     errors.push('ops.config.json: workspaceRoots debe contener al menos una raíz')
     return
   }
+  // El nombre repetido no se rechaza acá: lo avisa `check`, que es quien puede hacerlo sin romperle la
+  // puerta a una instancia que hoy funciona (caso 113). Este validador lo leen también los guards, y lo
+  // que devuelve son errores: meterlo acá era decidir que la configuración es inválida.
   for (const [index, workspace] of workspaces.entries()) {
     if (!workspace || typeof workspace !== 'object' || Array.isArray(workspace)) {
       errors.push(`ops.config.json: workspaceRoots[${index}] debe ser un objeto`)
@@ -119,10 +161,18 @@ function validateRunner(runner, errors) {
     return
   }
   const booleans = ['humanCheckpointBetweenMilestones', 'commitPerTask', 'allowPush']
-  const allowed = new Set(['maxTaskHours', ...booleans])
+  const allowed = new Set(['maxTaskHours', 'pushToLiveBranches', ...booleans])
   for (const key of Object.keys(runner)) {
     if (!allowed.has(key)) errors.push(`ops.config.json: runner.${key} no está permitido`)
   }
+  // Un patrón haría de un permiso por rama un permiso por familia, que es lo que el campo vino a evitar
+  // (caso 108): el guard compara el nombre tal cual, y `release/*` no publicaría en ninguna.
+  const live = runner.pushToLiveBranches
+  if (live !== undefined && (!Array.isArray(live)
+    || live.some((branch) => typeof branch !== 'string' || !/^[^\s*?[]+$/.test(branch)))) {
+    errors.push('ops.config.json: runner.pushToLiveBranches debe ser una lista de nombres de rama exactos, '
+      + 'sin espacios ni patrones')
+  }
   if (typeof runner.maxTaskHours !== 'number' || runner.maxTaskHours <= 0) {
     errors.push('ops.config.json: runner.maxTaskHours debe ser mayor que cero')
   }
@@ -133,4 +183,4 @@ function validateRunner(runner, errors) {
   }
 }
 
-module.exports = { validateOpsConfig }
+module.exports = { configWarnings, validateOpsConfig }

package/engine/core/onboarding.js

@@ -9,6 +9,7 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const { inventory } = require('./scan')
+const { sensitiveKey } = require('../integrations/registry')
 
 // La raíz del paquete: el molde contra el que se compara lo que una instancia escribió.
 const PACKAGE_ROOT = path.resolve(__dirname, '..', '..')
@@ -91,11 +92,23 @@ function missingSections(root) {
   return warnings
 }
 
+// Una aparición cuenta sólo si lo que la rodea no puede ser parte de otro nombre de variable: buscada
+// como subcadena, API_SECRET_ROTATION daba por cargada a API_SECRET (caso 111). El escaneo sólo deja
+// pasar identificadores, así que el nombre entra a la expresión sin nada que escapar.
+function named(text, name) {
+  return new RegExp(`(?<![A-Za-z0-9_])${name}(?![A-Za-z0-9_])`).test(text)
+}
+
 // Credenciales que el proyecto declara y que no aparecen en ningún contrato. El arranque tiene que
 // dejar una fila por cada una —quién la carga y dónde— y en la práctica cubre las que se hablaron en la
 // conversación: las que sólo estaban en el inventario se pierden, y con ellas el servicio externo que
 // hay detrás. Una variable sin dueño no rompe nada hoy; rompe el día que alguien tiene que desplegar.
 //
+// Credencial es lo que tiene nombre de secreto según `sensitiveKey`, la misma regla con la que la
+// declaración de secretos y la configuración de una integración rechazan un valor. Contando cualquier
+// variable, el aviso listaba ciento ocho nombres de build y la única credencial quedaba en «y 1 más»
+// (caso 102). El precio es el secreto con nombre de configuración, y el aviso lo dice.
+//
 // Sólo cuando la instancia ya tiene contexto escrito: antes del arranque no hay dónde estuvieran.
 function orphanCredentials(root) {
   if (guide(root).fresh) return []
@@ -108,16 +121,33 @@ function orphanCredentials(root) {
     .join('\n')
   if (!contracts) return []
   const orphans = []
+  const cut = []
   for (const service of inventory(root)) {
-    for (const name of (service.env || {}).names || []) {
-      if (!contracts.includes(name)) orphans.push(`${name} (${service.path})`)
+    const env = service.env || {}
+    for (const name of env.names || []) {
+      if (sensitiveKey(name) && !named(contracts, name)) orphans.push({ name, service: service.path })
     }
+    if (env.truncated) cut.push(`${service.path} (${env.truncated} de ${env.names.length + env.truncated})`)
   }
-  if (!orphans.length) return []
-  const summary = orphans.length > 4
-    ? `${orphans.slice(0, 4).join(', ')} y ${orphans.length - 4} más`
-    : orphans.join(', ')
-  return [`el proyecto declara ${summary} y no aparecen en el mapa ni en HUMAN_ACTIONS: nadie las carga`]
+  const warnings = []
+  if (orphans.length) {
+    const listed = orphans.map((one) => `${one.name} (${one.service})`)
+    const summary = listed.length > 4
+      ? `${listed.slice(0, 4).join(', ')} y ${listed.length - 4} más`
+      : listed.join(', ')
+    const services = [...new Set(orphans.map((one) => one.service))].join(', ')
+    warnings.push(`credenciales por nombre sin dueño (${orphans.length}, en ${services}): ${summary} — no `
+      + 'aparecen en el mapa ni en HUMAN_ACTIONS: nadie las carga. El dueño se escribe en '
+      + 'organization/workspace.md o en una fila de planning/HUMAN_ACTIONS.md; el criterio es el nombre, así '
+      + 'que una credencial con nombre de configuración no aparece acá')
+  }
+  // El escaneo corta cada ejemplo en un tope, y lo que quedó afuera no se miró: con el filtro, puede ser
+  // justo la credencial.
+  if (cut.length) {
+    warnings.push(`sin revisar por credenciales sin dueño, pasado el tope de variables por servicio: `
+      + `${cut.join(', ')} — lo que quedó afuera puede incluir una credencial que nadie carga`)
+  }
+  return warnings
 }
 
 module.exports = {