@ingeniomaps/cauce 0.81.0 → 0.82.0

package/engine/core/ownership.js

@@ -8,6 +8,9 @@
 const fs = require('node:fs')
 const path = require('node:path')
 
+// El paquete que corre: contra él se decide qué del runtime es una entrega de Cauce (casos 100 y 110).
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..')
+
 // Archivos de los que el toolkit es único autor. Un proyecto que necesite cambiarlos no los
 // edita: agrega una regla propia junto a las de `system/`, que sí sobrevive al upgrade.
 const SYSTEM_FILES = [
@@ -176,6 +179,27 @@ function overrides(root) {
   return found
 }
 
+// Las reglas que rigen una instancia, relativas a su raíz: cada `planning/rules/*.md` del proyecto y cada una de
+// `system/` que el proyecto no sobrescribió. `overrides()` ya sabía cuál reemplaza a cuál y sólo servía para
+// avisar; esto es lo que se entrega a quien trabaja (casos 099 y 105). Sólo el primer nivel, igual que `check`.
+function effectiveRules(root) {
+  const dir = path.join(root, 'planning', 'rules')
+  const markdown = (sub) => {
+    try {
+      return fs.readdirSync(path.join(dir, sub), { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'README.md'
+          && !entry.name.startsWith('.'))
+        .map((entry) => entry.name).sort()
+    } catch { return [] }
+  }
+  const replaced = new Set(overrides(root).filter((one) => one.collection === 'planning/rules')
+    .map((one) => one.system))
+  return [
+    ...markdown('system').filter((name) => !replaced.has(name)).map((name) => `planning/rules/system/${name}`),
+    ...markdown('').map((name) => `planning/rules/${name}`),
+  ]
+}
+
 // Rutas que el toolkit dejó de materializar. Sin esto una instancia arrastra para siempre lo que
 // alguna versión suya copió: `upgrade` agrega y reemplaza, pero nunca quitaba nada.
 // Cada archivo propio del molde, con cómo llega a una instancia que **ya existe**. `upgrade` sólo
@@ -302,7 +326,7 @@ function localChanges(root) {
   for (const target of trackedPaths()) {
     const dir = path.join(root, target)
     if (!fs.existsSync(dir)) continue
-    for (const file of manifest.edited(root, target, treeFiles(dir))) changed.push(`${target}/${file}`)
+    for (const file of manifest.edited(root, target, deliveredFiles(root, target))) changed.push(`${target}/${file}`)
   }
   // Los archivos sueltos del sistema entran por la misma puerta. Quedaban afuera, así que `upgrade`
   // los reemplazaba en silencio: un cargo escribió el índice de ADR que el propio README le pedía
@@ -311,8 +335,47 @@ function localChanges(root) {
   return changed
 }
 
+// Lo que el paquete que corre trae en una ruta del runtime. El resto de esa carpeta es de la empresa —un
+// guard propio—, y no es una entrega: registrado, pasaba a «editado» en cuanto la empresa lo tocaba, y
+// `upgrade --check` salía con 1 por algo que nunca fue de Cauce (caso 100).
+function shippedFiles(relative) {
+  return new Set(treeFiles(path.join(PACKAGE_ROOT, sourceOf(relative))))
+}
+
+// Lo que de una ruta rastreada cuenta como entregado: todo, salvo en el runtime, donde sólo lo que el
+// paquete trae. Lo usan el registro de `init` y de `upgrade` y la detección de ediciones, que tienen que
+// contar lo mismo.
+function deliveredFiles(root, relative) {
+  const files = treeFiles(path.join(root, relative))
+  return RUNTIME_PATHS.includes(relative) ? files.filter((file) => shippedFiles(relative).has(file)) : files
+}
+
+// Lo que el paquete empieza a traer con un nombre que la instancia ya usaba para algo suyo: un guard propio
+// que se llama como uno nuevo del toolkit (caso 110). Sin huella en el registro no cuenta como edición, así
+// que copiar encima lo borraba sin decirlo. Sólo si el registro ya conoce la ruta: en una instancia
+// anterior al registro, «sin huella» también es «lo entregó una versión vieja».
+function collisions(root) {
+  const manifest = require('./manifest')
+  const recorded = manifest.read(root)
+  const found = []
+  for (const relative of RUNTIME_PATHS) {
+    if (!Object.keys(recorded).some((key) => key.startsWith(`${relative}/`))) continue
+    for (const file of shippedFiles(relative)) {
+      const local = path.join(root, relative, file)
+      if (recorded[`${relative}/${file}`] || !fs.existsSync(local)) continue
+      const shipped = path.join(PACKAGE_ROOT, sourceOf(relative), file)
+      if (manifest.digest(local) !== manifest.digest(shipped)) found.push(`${relative}/${file}`)
+    }
+  }
+  return found
+}
+
 module.exports = {
   RETIRED,
+  collisions,
+  deliveredFiles,
+  effectiveRules,
+  shippedFiles,
   RETIRED_COMPARTIDO,
   TEMPLATE_OWN,
   TEMPLATE_PREFIXES,

package/engine/core/scan.js

@@ -171,17 +171,28 @@ function scan(root, skip = '') {
   }
 }
 
-// Dónde puede mirar una instancia: exactamente las raíces que declara, y nada por encima de ellas. Sale
+// Dónde puede mirar una instancia: exactamente las raíces que declara, con el nombre que les puso. Sale
 // de `ops.config.json` en vez de suponerse —el sidecar declara `..`, el embebido `.`— para que acotar las
 // raíces acote también el escaneo, y para que nadie termine recorriendo la carpeta de al lado.
-function workspaceRoots(root) {
+//
+// El nombre cae a la carpeta cuando la raíz no lo declara: `check` lo exige, pero `scan` y `onboard`
+// corren igual sobre una configuración que nunca pasó por ahí, y ahí el prefijo saldría `undefined`.
+function declaredRoots(root) {
+  const fallback = [{ name: path.basename(root), dir: root }]
   try {
     const config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8'))
-    const declared = (config.workspaceRoots || []).map((entry) => path.resolve(root, entry.path || '.'))
-    return declared.length ? declared : [root]
-  } catch { return [root] }
+    const declared = (config.workspaceRoots || []).map((entry) => {
+      const dir = path.resolve(root, entry.path || '.')
+      return { name: String(entry.name || '').trim() || path.basename(dir), dir }
+    })
+    return declared.length ? declared : fallback
+  } catch { return fallback }
 }
 
+// Sólo las rutas. Es lo que mira quien acota una escritura, y `onboard --json` las emite tal cual en
+// `roots`: darles forma de objeto habría cambiado ese contrato para quien no necesita el nombre.
+const workspaceRoots = (root) => declaredRoots(root).map((one) => one.dir)
+
 // Qué hay en las raíces declaradas, antes de que nadie razone sobre ello. La raíz ops se saltea: no es
 // un servicio del proyecto, y su `package.json` sólo declara el motor.
 // Los candidatos de una raíz, con el proyecto que vive en ella misma primero: un monolito declara sus
@@ -197,12 +208,15 @@ function candidates(workspace, skip = '') {
 // Con varias raíces, cada repositorio es la raíz de su propio escaneo y su candidato principal se llama
 // `.`: tres servicios con el mismo nombre y nada que los distinga. El prefijo los vuelve nombrables, que
 // es la única forma de que una credencial pueda atribuirse a un servicio en vez de quedar suelta.
+//
+// El prefijo es el `name` declarado y no la carpeta, que es lo que dejaba a `gouduet/keycloak` y
+// `hypixo/keycloak` llamándose las dos `keycloak` (caso 113). Que no se repita lo exige el validador.
 function inventory(root) {
-  const roots = workspaceRoots(root)
-  if (roots.length === 1) return candidates(roots[0], root)
-  return roots.flatMap((workspace) => candidates(workspace, root).map((service) => ({
+  const roots = declaredRoots(root)
+  if (roots.length === 1) return candidates(roots[0].dir, root)
+  return roots.flatMap(({ name, dir }) => candidates(dir, root).map((service) => ({
     ...service,
-    path: service.path === '.' ? path.basename(workspace) : `${path.basename(workspace)}/${service.path}`,
+    path: service.path === '.' ? name : `${name}/${service.path}`,
   })))
 }
 

package/engine/hooks/approval.js

@@ -32,7 +32,8 @@ const CHAT = require('./chat')
 const APPROVAL = '.ops-approval'
 
 // Una ruta por línea, `#` para lo demás. El archivo ausente y el vacío son lo mismo: no hay nada
-// aprobado, que es el estado normal.
+// aprobado, que es el estado normal. Un push se aprueba igual, con la línea `push <remoto> <rama>`
+// tal cual y sin patrones: `feat/*` convertiría una aprobación puntual en un permiso (caso 103).
 function read(root) {
   let text = ''
   try { text = fs.readFileSync(path.join(root, 'planning', APPROVAL), 'utf8') } catch { return [] }
@@ -81,4 +82,4 @@ function HOW(variable, lines, input) {
     + 'y apaga el guard para toda la sesión, que es por lo que no es la vía recomendada.'
 }
 
-module.exports = { APPROVAL, read, pending, HOW }
+module.exports = { APPROVAL, read, pending, where, HOW }

package/engine/hooks/chat.js

@@ -45,10 +45,33 @@ function load(session) {
 // Nombrar no es pedir: «no toques el .env» nombra el .env. Cuenta la negación que está en la misma frase y
 // antes del nombre; la coma corta, porque «leé el config, no el .env» son dos pedidos.
 const NEGATION = /(?:^|[^\p{L}])(?:no|nunca|jam[aá]s|ni|sin|not|never|don'?t)(?![\p{L}])/iu
-const CLAUSE = /[.,;:!?\n]/
+// Un punto corta sólo si cierra la oración: el de `x.js` es parte del nombre, y cortar ahí dejaba el verbo de
+// «agregá src/x.js a .ops-approval» en otra frase que la del archivo.
+const CLAUSE = /[,;:!?\n]|\.(?=\s|$)/
 
-// Cada aparición del nombre en el texto y si va negada. Un nombre tiene que estar entero: `.env` no
-// aparece en «el .env.example», y un punto sólo lo cierra si termina la frase.
+// Y no negarlo tampoco alcanza: «¿para qué sirven las credentials?» o «el .env tiene algo raro» nombran el
+// archivo sin pedir nada (caso 109). La frase del nombre tiene que traer un verbo que pida una acción, en
+// español o en inglés; se compara sin tildes y sin el pronombre pegado —«leelo», «abrime»—. La lista va a
+// quedar corta, y lo que no reconoce no se pierde: se frena, y un «dale» lo aprueba.
+const ASKS = new Set(('lee leer abri abre abrir mostra muestra mostrar ensena edita editar cambia cambiar borra '
+  + 'borrar elimina eliminar escribi escribe escribir corre correr ejecuta ejecutar desactiva desactivar apaga '
+  + 'apagar reescribi reescribe reescribir agrega agregar anadi anade anadir saca sacar quita quitar actualiza '
+  + 'actualizar modifica modificar revisa revisar mira mirar fijate chequea verifica verificar instala instalar '
+  + 'subi sube subir pushea pushear commitea commitear usa usar crea crear arregla arreglar carga cargar copia '
+  + 'copiar toca tocar aproba aprueba aprobar habilita habilitar reemplaza reemplazar renombra renombrar mueve '
+  + 'mover restaura restaurar imprimi imprime imprimir deci dime proba probar '
+  + 'read open show print display edit change delete remove write run execute disable rewrite add update modify '
+  + 'check review inspect look cat commit push install use create fix load copy touch approve enable replace '
+  + 'rename move restore skip').split(' '))
+const ENCLITIC = /(?:selo|sela|melo|mela|telo|tela|los|las|lo|la|le|me)$/
+
+function asks(clause) {
+  const words = clause.normalize('NFD').replace(/[̀-ͯ]/g, '').match(/[a-z]+/g) || []
+  return words.some((word) => ASKS.has(word) || ASKS.has(word.replace(ENCLITIC, '')))
+}
+
+// Cada aparición del nombre en el texto: si va negada y si su frase pide algo. Un nombre tiene que estar
+// entero: `.env` no aparece en «el .env.example», y un punto sólo lo cierra si termina la frase.
 function mentions(text, item) {
   const lower = String(text).toLowerCase()
   const found = []
@@ -59,10 +82,34 @@ function mentions(text, item) {
       const rest = lower.slice(at + name.length)
       if (before && !/[\s'"`(/]/.test(before)) continue
       if (rest && !/^(?:[\s'"`),;:!?]|\.(?:\s|$)|$)/.test(rest)) continue
-      found.push(NEGATION.test(lower.slice(0, at).split(CLAUSE).pop()))
+      const clause = lower.slice(0, at).split(CLAUSE).pop()
+      found.push({ denied: NEGATION.test(clause), asked: asks(`${clause} ${rest.split(CLAUSE)[0]}`) })
     }
   }
-  return { named: found.includes(false), denied: found.includes(true) }
+  return { named: found.some((one) => one.asked && !one.denied), denied: found.some((one) => one.denied) }
+}
+
+// Una orden de publicar se lee aparte, porque `mentions` compara también el basename: para el ítem
+// `push origin feat/login` eso es `login`, y «arreglá el login y no subas nada» publicaba (caso 103). Acá
+// el remoto y la rama tienen que aparecer tal cual, como palabras enteras, en una frase que pida publicar
+// —un verbo de publicar, no cualquiera: «revisá feat/x en origin» no pide un push— y sin una negación
+// antes del último de los dos.
+const PUSHES = new Set('subi sube subir pushea pushear push publica publicar publish empuja empujar'.split(' '))
+function ordersPush(text, item) {
+  const [verb, remote, branch] = item.split(' ')
+  if (verb !== 'push' || !remote || !branch) return false
+  return String(text).split(CLAUSE).some((clause) => {
+    // La comilla simple se saca de los bordes y no se corta en ella: partida, «don't» dejaba de ser una
+    // negación.
+    const words = clause.split(/[\s"`()]+/)
+      .map((word) => word.replace(/^'+/, '').replace(/\.$/, '').replace(/'+$/, ''))
+    const last = Math.max(words.indexOf(remote), words.indexOf(branch))
+    if (words.indexOf(remote) < 0 || words.indexOf(branch) < 0) return false
+    const plain = clause.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+      .match(/[a-z]+/g) || []
+    return plain.some((word) => PUSHES.has(word) || PUSHES.has(word.replace(ENCLITIC, '')))
+      && !NEGATION.test(words.slice(0, last + 1).join(' '))
+  })
 }
 
 // Quien contesta a un bloqueo que quedó pendiente. Sólo el principio del mensaje: «dale» es la respuesta
@@ -99,12 +146,14 @@ function said(input) {
   return current && saved.id && current !== saved.id ? null : saved
 }
 
-// Lo que la persona no autorizó de lo que un guard está por frenar: ni lo nombró en su mensaje ni lo
-// aprobó contestando.
-function unauthorized(input, items) {
+// Lo que la persona no autorizó de lo que un guard está por frenar: ni lo pidió en su mensaje ni lo
+// aprobó contestando. Qué cuenta como pedirlo depende de qué se frena: un archivo se nombra, un push se
+// ordena con su remoto y su rama.
+const named = (text, item) => mentions(text, item).named
+function unauthorized(input, items, asked = named) {
   const saved = said(input)
   if (!saved) return items
-  return items.filter((item) => !saved.approved.includes(item) && !mentions(saved.text, item).named)
+  return items.filter((item) => !saved.approved.includes(item) && !asked(saved.text, item))
 }
 
 // Lo que quedó frenado, para que un «dale» en el mensaje siguiente apruebe exactamente eso y nada más.
@@ -119,4 +168,4 @@ function hold(input, items) {
   } catch { return false }
 }
 
-module.exports = { DIR, record, said, unauthorized, hold }
+module.exports = { DIR, record, said, unauthorized, hold, ordersPush }

package/engine/hooks/input.js

@@ -183,9 +183,6 @@ function stagedFiles(dir) {
   return result.stdout.trim().split('\n').filter(Boolean)
 }
 
-// R10 pide «la autorización configurada para el proyecto» y `runner.allowPush` es esa configuración:
-// sin esto era un interruptor que nadie leía, y un cargo que lo leyó dio por imposible un push que el
-// guard bloqueaba igual. Sin raíz legible no hay permiso que verificar, así que no se autoriza.
 // El índice que un hook de pre-ejecución lee es el de **antes** del comando, y el comando puede ser
 // justamente el que lo llene. Ahí los tres guards que juzgan mirando el índice no fallan: leen bien,
 // encuentran cero archivos y concluyen que no hay nada que revisar.
@@ -212,13 +209,6 @@ function stagedForCommit(command, cwd) {
   return { dir, staged: stagedFiles(dir) }
 }
 
-function pushAllowed(input) {
-  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
-  if (!root) return false
-  const runner = configOf(root).runner
-  return Boolean(runner && runner.allowPush === true)
-}
-
 function findOpsRoot(start) {
   let current = path.resolve(start)
   while (true) {
@@ -270,7 +260,7 @@ function opsRoot(input) {
 
 module.exports = {
   readInput, commandOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
-  gitDirectory, isCommit, withoutGitGlobals, stagedFiles, stagedForCommit, pushAllowed,
+  gitDirectory, isCommit, withoutGitGlobals, stagedFiles, stagedForCommit,
   findOpsRoot, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT, unquoted,
 }

package/engine/hooks/push.js

@@ -0,0 +1,147 @@
+'use strict'
+
+// Si un `git push` se publica, y con qué autorización. R10 pide «la autorización configurada para el
+// proyecto», y hasta 0.81.0 era un solo interruptor: `runner.allowPush` dejaba pasar cualquier push —a la
+// rama viva, y de un subagente igual que de la persona— y, apagado, frenaba también el que la persona
+// acababa de pedir con todas las letras (casos 103 y 108).
+//
+// Lo que garantiza, en orden:
+//
+// - Un subagente no publica, con ningún permiso: es trabajo que el agente delegó, dos pasos más lejos de
+//   la persona que la sesión. El push sale de la sesión principal.
+// - Una rama viva —`main`, `master` y la rama por defecto de cada remoto— no la alcanza ni `allowPush` ni
+//   una orden del chat si el proyecto no la nombró en `runner.pushToLiveBranches`. La línea exacta en
+//   `.ops-approval` sí la alcanza: la escribe una persona a mano y los guards de límites no dejan que el
+//   agente se la escriba.
+// - A una rama de trabajo, o a una viva ya nombrada, la alcanzan `allowPush`, la línea exacta en
+//   `.ops-approval`, un mensaje de la persona que ordena ese push con su remoto y su rama, o un «dale» al
+//   push que quedó frenado. Qué cuenta como orden lo decide `chat.js`.
+//
+// El `--force` no llega hasta acá: lo frena `destructive` antes, sin override (R8).
+
+const { spawnSync } = require('node:child_process')
+const { block, cwdOf, gitDirectory, opsRoot, configOf } = require('./input')
+const AP = require('./approval')
+const CHAT = require('./chat')
+
+// Lo que va entre `git push` y el fin del comando. El salto de línea corta igual que `;`, por lo que
+// `destructive` explica en MISMO.
+const PUSH = /\bgit\s+push\b([^;&|\n]*)/g
+// Las banderas que llevan su valor en la palabra siguiente: sin saltearlo, el valor se leía como remoto.
+const VALUED = new Set(['-o', '--push-option', '--repo', '--receive-pack', '--exec'])
+// Publican todas las ramas, así que entre ellas la viva: no hay una rama que nombrar ni que aprobar.
+const EVERY = new Set(['--all', '--branches', '--mirror'])
+
+// Lectura local e inocua del repositorio: ninguna de estas consultas habla con el remoto. Si falla, no
+// hay dato, y quien pregunta decide sin él.
+function git(dir, args) {
+  const result = spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8' })
+  return result.status === 0 ? result.stdout.trim() : ''
+}
+
+// La rama por defecto de un remoto es la que git anota en `refs/remotes/<remoto>/HEAD`: la escribe el
+// `clone` y la cambia `git remote set-head`, así que el proyecto la declara sin un campo nuevo. `main` y
+// `master` cuentan siempre, porque un remoto agregado a mano no la anota.
+function liveBranches(dir) {
+  const live = new Set(['main', 'master'])
+  const refs = git(dir, ['for-each-ref', '--format=%(refname)%09%(symref)', 'refs/remotes/'])
+  for (const line of refs.split('\n')) {
+    const [name, target] = line.split('\t')
+    if (!target || !name.endsWith('/HEAD')) continue
+    live.add(target.slice(name.length - 'HEAD'.length))
+  }
+  return live
+}
+
+// A dónde publicaría un `git push` sin rama: lo que git resuelve como `@{push}`, que ya aplica
+// push.default y el remoto de publicación que declare la rama. Sin upstream no resuelve, y git mismo
+// tampoco sabría a dónde ir.
+function pushTarget(dir, current) {
+  if (!current) return null
+  const remote = git(dir, ['for-each-ref', '--format=%(push:remotename)', `refs/heads/${current}`])
+  const full = git(dir, ['rev-parse', '--symbolic-full-name', '@{push}'])
+  const prefix = `refs/remotes/${remote}/`
+  return remote && full.startsWith(prefix) ? { remote, branch: full.slice(prefix.length) } : null
+}
+
+// Los destinos de un push: `{ item, remote, branch }` con el ítem que se aprueba, `push <remoto> <rama>`.
+// El que no se puede resolver lleva por ítem el comando mismo, que no nombra ninguna rama: lo aprueba un
+// «dale» a ese bloqueo y nada en `.ops-approval`.
+function destinationsOf(args, dir) {
+  const words = args.trim().split(/\s+/).filter(Boolean).map((word) => word.replace(/^['"]|['"]$/g, ''))
+  const positional = []
+  const found = []
+  for (let at = 0; at < words.length; at += 1) {
+    if (!words[at].startsWith('-')) positional.push(words[at])
+    else if (EVERY.has(words[at])) found.push({ every: true })
+    else if (VALUED.has(words[at])) at += 1
+    else if (words[at] === '--tags') found.push({ tags: true })
+  }
+  const current = git(dir, ['symbolic-ref', '--quiet', '--short', 'HEAD'])
+  const target = pushTarget(dir, current)
+  const [remote, ...refspecs] = positional
+  const unknown = { item: 'git push', branch: current }
+  const one = (to, branch) => (branch ? { item: `push ${to} ${branch}`, remote: to, branch } : unknown)
+  const named = refspecs.map((spec) => {
+    const destination = spec.replace(/^\+/, '').split(':').pop().replace(/^refs\/heads\//, '')
+    return one(remote, destination === 'HEAD' ? current : destination)
+  })
+  const rest = found.map((flag) => (flag.every ? { every: true }
+    : one(remote || (target && target.remote) || 'origin', '--tags')))
+  if (named.length || found.length) return [...named, ...rest]
+  if (remote) return [one(remote, target && target.remote === remote ? target.branch : current)]
+  return [target ? one(target.remote, target.branch) : unknown]
+}
+
+const SUBAGENT = "'git push' desde un subagente no se publica, con ningún permiso: publicar lo decide una "
+  + 'persona (R10), y un subagente es trabajo que el agente delegó. Devolvé el resultado a la sesión '
+  + 'principal, que es la que publica.'
+
+function liveMessage(live, input) {
+  const lines = live.filter((to) => to.remote).map((to) => to.item)
+  const names = [...new Set(live.map((to) => (to.every ? 'todas las ramas' : to.branch)))].join(', ')
+  // Le habla al agente y deja el permiso como cosa de la persona, por lo mismo que `AP.HOW`: medido en
+  // una sesión real, con «pegando tal cual» a secas el agente se ofreció a escribirse la aprobación.
+  return `'git push' publica cambios en ${names}, la rama viva, y requiere una acción humana: ni `
+    + 'runner.allowPush ni una orden en el chat llegan ahí sin un permiso por rama. Decile a la persona qué '
+    + 'se frenó y esperá: un «dale» no lo destraba. Lo da ella, nombrando la rama en '
+    + 'runner.pushToLiveBranches de ops.config.json, que la deja como una rama de trabajo'
+    + (lines.length ? `, o pegando ella tal cual en ${AP.where(input)} estas líneas:\n`
+      + lines.map((line) => `  ${line}\n`).join('') : '.')
+}
+
+function workMessage(items, input) {
+  const lines = items.filter((item) => item.startsWith('push '))
+  const chat = CHAT.hold(input, items)
+  const how = chat
+    ? 'Decile a la persona qué se frenó y esperá: si contesta «dale», reintentá el mismo push y pasa. '
+      + 'También pasa si lo pide nombrando el remoto y la rama, como «subí feat/x a origin».'
+    : 'Lo destraba una persona pidiéndolo en el chat con el remoto y la rama.'
+  const paste = lines.length
+    ? `\nSi prefiere aprobarlo a mano, que pegue ella tal cual en ${AP.where(input)} estas líneas:\n`
+      + lines.map((line) => `  ${line}\n`).join('')
+    : ' Sin remoto y rama que se puedan leer del comando no hay línea que aprobar: nombralos.\n'
+  return `'git push' publica cambios y requiere una acción humana. ${how}${paste}`
+    + 'El permiso permanente es runner.allowPush en ops.config.json, y lo decide una persona.'
+}
+
+function publish(input, command) {
+  const pushes = [...command.matchAll(PUSH)]
+  if (!pushes.length) return
+  if (input.agent_id) block(SUBAGENT)
+  const dir = gitDirectory(command, cwdOf(input))
+  const root = opsRoot(input)
+  const runner = (root && configOf(root).runner) || {}
+  const listed = new Set(Array.isArray(runner.pushToLiveBranches) ? runner.pushToLiveBranches : [])
+  const filed = new Set(root ? AP.read(root) : [])
+  const live = liveBranches(dir)
+  const left = pushes.flatMap((match) => destinationsOf(match[1], dir))
+    .filter((to) => !(to.item && to.item.startsWith('push ') && filed.has(to.item)))
+  const unlisted = left.filter((to) => to.every || (live.has(to.branch) && !listed.has(to.branch)))
+  if (unlisted.length) block(liveMessage(unlisted, input))
+  if (runner.allowPush === true) return
+  const unordered = CHAT.unauthorized(input, [...new Set(left.map((to) => to.item))], CHAT.ordersPush)
+  if (unordered.length) block(workMessage(unordered, input))
+}
+
+module.exports = { publish }

package/engine/hooks/shell.js

@@ -9,10 +9,11 @@ const os = require('node:os')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const {
-  commandOf, cwdOf, block, isCommit, stagedForCommit, pushAllowed,
+  commandOf, cwdOf, block, isCommit, stagedForCommit,
   writableRoots, outsideRoots, DECLARE_IT, unquoted, opsRoot, withoutGitGlobals,
 } = require('./input')
 const AP = require('./approval')
+const { publish } = require('./push')
 const { selfApproval } = require('./self-approval')
 const EV = require('../core/evidence')
 
@@ -64,14 +65,15 @@ function destructive(input) {
   // matchea igual las dos formas, así que `allowPush` habilitaba el force-push sin que nadie lo decidiera
   // y el párrafo de autonomía de `AGENTS.md` tenía que confesarlo. R8 prohíbe `force` sin excepción
   // configurable, así que esta rama va antes del permiso y no lo consulta.
-  if (new RegExp(String.raw`\bgit\s+push\b${MISMO}*\s(?:-f|--force(?:-with-lease|-if-includes)?)\b`)
+  //
+  // El `+` delante de una rama es el mismo force escrito en el refspec —`git push origin +main`—, y
+  // pasaba como un push normal: la regla miraba sólo las banderas (caso 103).
+  if (new RegExp(String.raw`\bgit\s+push\b${MISMO}*\s(?:(?:-f|--force(?:-with-lease|-if-includes)?)\b|\+\S)`)
     .test(command)) {
     block("'git push --force' reescribe historia ya publicada. R8 lo prohíbe y runner.allowPush no lo "
       + 'habilita: publicá con un push normal, o registrá una acción humana.')
   }
-  if (/\bgit\s+push\b/.test(command) && !pushAllowed(input)) {
-    block("'git push' publica cambios y requiere una acción humana. Se habilita con runner.allowPush.")
-  }
+  publish(input, command)
   const rules = [
     [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales."],
     // R8 lo prohíbe sin excepción configurable y ningún guard lo miraba: `grep -rn amend engine/hooks/`

package/engine/integrations/registry.js

@@ -64,11 +64,22 @@ function adapter(root, name, entry = {}) {
   return impl
 }
 
+// Qué nombre tiene forma de secreto. Es una sola regla para los tres que la necesitan: la configuración
+// de una integración, la declaración de secretos y el aviso de credenciales sin dueño de «ops check».
+// La clave cuenta sólo como palabra propia —API_KEY sí, projectKey no—, porque el campo de Jira con la
+// clave del proyecto está en instancias reales y rechazarlo les rompería la validación (caso 102, donde
+// está la medición).
+const SENSITIVE = /(password|secret|token|authorization|cookie|dsn|credentials?|(?:^|_)key)$/i
+
+function sensitiveKey(key) {
+  return SENSITIVE.test(key)
+}
+
 function sensitivePath(value, trail = '') {
   if (!value || typeof value !== 'object') return ''
   for (const [key, child] of Object.entries(value)) {
     const next = trail ? `${trail}.${key}` : key
-    if (/(password|secret|token|authorization|cookie)$/i.test(key) && !/Env$/i.test(key)) return next
+    if (sensitiveKey(key)) return next
     const nested = sensitivePath(child, next)
     if (nested) return nested
   }
@@ -442,6 +453,7 @@ module.exports = {
   providerConfig,
   reconcile,
   safeSegment,
+  sensitiveKey,
   sensitivePath,
   sync,
   validate,

package/engine/planning/inbox.js

@@ -0,0 +1,36 @@
+'use strict'
+
+// Lo que `check` dice sobre el INBOX. Son advertencias y nunca errores: el INBOX es de la persona, y un
+// `check` rojo por lo que tiene adentro la frenaría a ella por lo que escribió un recorrido (caso 101).
+
+const path = require('node:path')
+const P = require('./parser')
+
+const FILE = 'INBOX.md'
+// Un archivo que todavía se recorre de una sentada; el molde vacío ocupa menos de treinta. La instancia
+// lo cambia en `inbox.warnLines`.
+const WARN_LINES = 300
+
+function warnings(root, done, config) {
+  const text = P.read(path.join(root, FILE))
+  if (!text.trim()) return []
+  const found = []
+  const declared = config && config.inbox && config.inbox.warnLines
+  const limit = Number.isInteger(declared) && declared > 0 ? declared : WARN_LINES
+  const count = text.replace(/\n$/, '').split('\n').length
+  if (count > limit) {
+    found.push(`${FILE}: ${count} líneas, más que el umbral de ${limit} (inbox.warnLines en ops.config.json); `
+      + 'recorrelo y borrá lo que ya se decidió')
+  }
+  // Una entrada que se llama como una tarea cerrada probablemente se promovió y nadie la borró. Es un
+  // indicio y no una prueba —el molde no obliga a que la tarea conserve el nombre del ítem—, y por eso
+  // avisa en vez de fallar (caso 106).
+  for (const name of Object.values(P.inboxHeads(root)).flat()) {
+    if (done.set.has(name)) {
+      found.push(`${FILE}: **${name}** se llama como done/${name}.md; si ya se promovió, borrala`)
+    }
+  }
+  return found
+}
+
+module.exports = { warnings }

package/engine/planning/parser.js

@@ -405,18 +405,31 @@ function readWips(dir) {
 // La plantilla no traía ningún ejemplo, así que quien escribía viñetas planas veía cero ítems sobre un
 // archivo con doce y nada se lo decía. `skipped` es lo que vuelve visible esa diferencia.
 function readInbox(dir) {
-  const result = { deuda: 0, ideas: 0, propuestas: 0, lecciones: 0, skipped: 0 }
+  const { heads, skipped } = inboxSections(dir)
+  return { ...Object.fromEntries(Object.entries(heads).map(([key, names]) => [key, names.length])), skipped }
+}
+
+// Los nombres en negrita de cada sección, que es lo que un recorrido necesita para no volver a escribir
+// lo que ya está: el nombre y no la entrada, porque pasar el archivo entero a cada tarea cuesta lo que
+// el INBOX pesa (caso 101).
+function inboxHeads(dir) {
+  return inboxSections(dir).heads
+}
+
+function inboxSections(dir) {
+  const heads = { deuda: [], ideas: [], propuestas: [], lecciones: [] }
+  let skipped = 0
   for (const part of read(path.join(dir, 'INBOX.md')).split(/^##\s+/m)) {
     const title = part.split('\n')[0]
     const bullets = (part.match(/^[-*]\s+(?:\[[ xX]\]\s+)?/gm) || []).length
-    const count = (part.match(/^[-*]\s+(?:\[[ xX]\]\s+)?\*\*/gm) || []).length
-    if (/Deuda|Ideas|Visi[oó]n|Propuestas|Lecciones/i.test(title)) result.skipped += bullets - count
-    if (/Deuda/i.test(title)) result.deuda = count
-    if (/Ideas|Visi[oó]n/i.test(title)) result.ideas = count
-    if (/Propuestas/i.test(title)) result.propuestas = count
-    if (/Lecciones/i.test(title)) result.lecciones = count
+    const names = [...part.matchAll(/^[-*]\s+(?:\[[ xX]\]\s+)?\*\*([^*\n]*)/gm)].map((hit) => hit[1].trim())
+    if (/Deuda|Ideas|Visi[oó]n|Propuestas|Lecciones/i.test(title)) skipped += bullets - names.length
+    if (/Deuda/i.test(title)) heads.deuda = names
+    if (/Ideas|Visi[oó]n/i.test(title)) heads.ideas = names
+    if (/Propuestas/i.test(title)) heads.propuestas = names
+    if (/Lecciones/i.test(title)) heads.lecciones = names
   }
-  return result
+  return { heads, skipped }
 }
 
 module.exports = {
@@ -424,5 +437,5 @@ module.exports = {
   TASK_LINE, TASK_LINE_ANY_LANE,
   read, section, withoutComments, frontmatter, readEpics, readBacklog, readDone, readWip, readWips, wipName,
   acceptanceConditions, tableRows, taskFromLine,
-  readInbox, readHumanActions,
+  readInbox, inboxHeads, readHumanActions,
 }

package/engine/planning/recurring.js

@@ -19,6 +19,10 @@ const CADENCES = { mensual: 1, trimestral: 3, semestral: 6, anual: 12 }
 
 const ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
 const DATE = /^\d{4}-\d{2}-\d{2}$/
+// La fila que el molde trae activa escribe su `Desde` como marcador, porque la fecha depende del día en
+// que se crea la instancia y la reemplazan `init` y `upgrade`. Sin resolver sólo existe en el molde
+// mismo —el que `npm run check` valida en el toolkit—, y ahí no vence: `status` la descarta por fecha.
+const PLACEHOLDER = /^\{\{[A-Z_]+\}\}$/
 // `- **qué** AAAA-MM-DD — razón`. El nombre en negrita adelante es la misma convención del INBOX, y por
 // el mismo motivo: es con lo que se cita la fila desde otro lado.
 const POSTPONEMENT = /^-\s+\*\*([^*]+)\*\*\s+(\S+)\s+[—-]\s+(.+)$/
@@ -77,7 +81,7 @@ function validate({ exists, rows, postponements }) {
     if (!CADENCES[row.cadence]) {
       errors.push(`${at}: cadencia "${row.cadence}" fuera de ${Object.keys(CADENCES).join(' | ')}`)
     }
-    if (!DATE.test(row.since)) errors.push(`${at}: Desde debe ser AAAA-MM-DD`)
+    if (!DATE.test(row.since) && !PLACEHOLDER.test(row.since)) errors.push(`${at}: Desde debe ser AAAA-MM-DD`)
     // Se juzga la línea armada y no la celda suelta: lo que se promueve es esa línea, y quien la va a
     // leer es el mismo lector de BACKLOG. Una celda que pasa acá y una línea que BACKLOG rechaza es el
     // error que aparece un mes después, con la tarea ya pegada.
@@ -145,4 +149,11 @@ function warnings(state) {
   return lines
 }
 
-module.exports = { FILE, read, validate, status, warnings, taskLine }
+// Los marcadores de fecha del molde, resueltos para una instancia que nace hoy. `Desde` es la primera
+// fecha de vencimiento y no el día en que se declara la fila, así que va un período después: con la
+// fecha de hoy la fila nacía «vence hoy» (caso 106). Trimestral es la cadencia de la fila del molde.
+function sinceValues(today) {
+  return { '{{INBOX_SINCE}}': addMonths(today, CADENCES.trimestral) }
+}
+
+module.exports = { FILE, read, validate, status, warnings, taskLine, sinceValues }