@ingeniomaps/cauce 0.81.0 → 0.83.0

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 = {

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,19 +32,39 @@ 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).
+//
+// El texto se lee aparte del archivo porque `self-approval` compara lo que se está por escribir contra lo
+// que ya está en disco: con dos parsers, una línea podría contar de un lado y no del otro (caso 119).
+const lines = (text) => text.split('\n').map((line) => line.replace(/#.*$/, '').trim()).filter(Boolean)
+
 function read(root) {
-  let text = ''
-  try { text = fs.readFileSync(path.join(root, 'planning', APPROVAL), 'utf8') } catch { return [] }
-  return text.split('\n').map((line) => line.replace(/#.*$/, '').trim()).filter(Boolean)
+  try { return lines(fs.readFileSync(path.join(root, 'planning', APPROVAL), 'utf8')) } catch { return [] }
 }
 
 // Qué queda sin aprobar de lo que un guard está por bloquear. Se reporta sólo eso: mandar a revisar lo
 // que ya se aprobó es lo que hace que la próxima vez nadie lea el mensaje. Cuenta también lo que la
 // persona pidió en el chat.
-function pending(root, files, input) {
+const left = (root, files) => {
   const approved = new Set(root ? read(root) : [])
-  return CHAT.unauthorized(input, files.filter((file) => !approved.has(file)))
+  return files.filter((file) => !approved.has(file))
+}
+
+function pending(root, files, input) {
+  return CHAT.unauthorized(input, left(root, files))
+}
+
+// Lo mismo para los gates de commit —`governance`, `verify` y `dependencies`—, que preguntan cada vez: no
+// conceden nada y no heredan lo que la sesión venía concediendo.
+//
+// Commitear está del lado de publicar y no del de leer, y por qué esa diferencia decide quién hereda está
+// en `push.js`. Lo propio de un commit es que el objeto del permiso se mueve solo: lo que autoriza uno no
+// dice nada del siguiente, porque el índice ya es otro. Nadie lo había decidido para los gates —heredaban
+// por venir todos de `pending`—, y se midió: con otro mensaje en curso, un commit de gobernanza pasaba
+// (caso 119).
+function pendingNow(root, files, input) {
+  return CHAT.unauthorizedNow(input, left(root, files))
 }
 
 // El archivo que el guard va a leer, nombrado desde la carpeta en la que está la sesión. En sidecar la
@@ -69,16 +89,31 @@ function where(input) {
 // primero: contestar es más corto que editar un archivo, y es lo que la persona ya está haciendo. El
 // archivo queda como cosa de ella: dicho en imperativo, el agente leía «aprobalo» como una orden para él
 // e intentaba escribírselo en vez de reintentar, medido en una sesión real de Claude Code.
-function HOW(variable, lines, input) {
+//
+// `pasteable` es lo que se puede aprobar por archivo, y por defecto es todo: un guard lo angosta cuando lo
+// que tiene a mano no sirve para pegar —por qué, en `secrets-shell.js` (caso 118)—. Lo frenado se anota
+// igual, así que el «dale» sigue cubriendo todo.
+function HOW(variable, lines, input, pasteable = lines) {
   const chat = CHAT.hold(input, lines)
-  return (chat
+  const stuck = lines.filter((one) => !pasteable.includes(one))
+  const ask = chat
     ? 'Decile a la persona qué se frenó y por qué, y esperá: si contesta «dale», reintentá el mismo cambio y '
-      + 'pasa. Si prefiere aprobarlo a mano, que pegue ella tal cual en'
-    : 'Aprobalo pegando tal cual en')
-    + ` ${where(input)} estas líneas:\n`
-    + lines.map((line) => `  ${line}\n`).join('')
-    + `Valen para ese conjunto y dejan de valer en cuanto cambie. La variable ${variable}=1 sigue existiendo `
-    + 'y apaga el guard para toda la sesión, que es por lo que no es la vía recomendada.'
+      + 'pasa. '
+    : ''
+  const paste = pasteable.length
+    ? (chat ? 'Si prefiere aprobarlo a mano, que pegue ella tal cual en' : 'Aprobalo pegando tal cual en')
+      + ` ${where(input)} estas líneas:\n`
+      + pasteable.map((line) => `  ${line}\n`).join('')
+      + 'Valen para ese conjunto y dejan de valer en cuanto cambie. '
+    : ''
+  const unresolved = stuck.length
+    ? `Por archivo no hay línea que pegar para ${stuck.join(', ')}: la ruta llegó con una expansión del shell `
+      + 'sin resolver, y la aprobación compara texto, así que esa línea sólo valdría para un comando escrito '
+      + 'igual. Volvé a correrlo con la ruta escrita y el bloqueo va a decir qué pegar. '
+    : ''
+  return ask + paste + unresolved
+    + `La variable ${variable}=1 sigue existiendo 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, lines, read, pending, pendingNow, where, HOW }

package/engine/hooks/chat.js

@@ -45,10 +45,41 @@ 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.
+//
+// Autorizar también es pedir, y era lo que faltaba: «autorizo la lectura del .env» es la forma más
+// explícita de decir que sí y se frenaba igual, porque ninguna de sus palabras estaba (caso 118). Entran
+// las formas con que una persona **concede** —primera persona e imperativo— y no los sustantivos que
+// nombran el acto: `lectura`, `permiso` y `autorizacion` aparecen igual en una pregunta que no autoriza
+// nada, y dejarlos afuera es lo que el 109 decidió cuando dijo que nombrar no alcanza.
+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 '
+  + 'autorizo autoriza autorizar autorizado permito permiti permite permitir apruebo habilito '
+  + '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 '
+  + 'authorize authorized allow allowed permit permitted grant granted approved').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 +90,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
@@ -73,6 +128,10 @@ const YES = new RegExp(String.raw`^\s*(?:s[ií]|dale|ok(?:ay)?|hac[eé]lo|hazlo|
 // El hook de mensaje. Nunca frena: un mensaje de la persona no se bloquea, y sin registro los guards
 // deciden como antes. Un texto que empieza con una etiqueta no lo escribió una persona —Claude avisa así
 // que terminó un subagente, con `<task-notification>`—, y en CI no hay persona.
+//
+// Lo concedido es lo único que cruza de un mensaje al siguiente, y se hereda aunque este mensaje no lo
+// haya escrito una persona: un aviso del runner en el medio no le quita a nadie lo que ya autorizó. La
+// negación se aplica venga de donde venga, porque revocar es la dirección segura.
 function record(input) {
   try {
     if (!input.session_id) return
@@ -82,9 +141,10 @@ function record(input) {
     const approved = human && previous && YES.test(text)
       ? previous.pending.filter((item) => !mentions(text, item).denied)
       : []
+    const granted = previous ? (previous.granted || []).filter((one) => !mentions(text, one).denied) : []
     fs.mkdirSync(DIR, { recursive: true })
-    fs.writeFileSync(recordPath(input.session_id),
-      JSON.stringify({ id: idOf(input), text, human, flow: flowCommand(text), approved, pending: [] }))
+    fs.writeFileSync(recordPath(input.session_id), JSON.stringify(
+      { id: idOf(input), text, human, flow: flowCommand(text), approved, granted, pending: [] }))
   } catch { /* registrar es un extra: si falla, los guards siguen frenando lo que frenaban */ }
 }
 
@@ -99,12 +159,63 @@ 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.
+// Con qué autorización pasa un ítem, o vacío si no pasa: lo pidió este mensaje, un «dale» aprobó lo que
+// había quedado frenado, o se lo concedieron antes en esta sesión. 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 why(saved, item, asked, inherit) {
+  if (asked(saved.text, item)) return 'orden'
+  if (saved.approved.includes(item)) return 'dale'
+  if (!inherit) return ''
+  return (saved.granted || []).includes(item) ? 'concedido' : ''
+}
+
+// Lo que un guard dejó pasar queda anotado, que es la contracara de `hold`: hasta 0.82.0 sólo se anotaba
+// lo frenado, así que una autorización usada moría con el mensaje y lo mismo se frenaba una y otra vez.
+// Ahí la salida barata era apagar el guard para toda la sesión con una variable, o sea el permiso más
+// ancho de los dos (caso 116).
+//
+// Se anota el ítem **como el guard lo nombró** —la ruta en la forma que ese guard tiene a mano— y no el
+// archivo que hay detrás: es el mismo alcance que tiene una línea de `.ops-approval`, angosto de más
+// antes que de menos.
+function grant(input, saved, items) {
+  const before = saved.granted || []
+  const granted = [...new Set([...before, ...items])]
+  if (granted.length === before.length) return
+  try {
+    saved.granted = granted
+    fs.writeFileSync(recordPath(input.session_id), JSON.stringify(saved))
+  } catch { /* sin anotarlo, se vuelve a pedir */ }
+}
+
+// Con qué autorización pasa cada uno de los que pasan. Lo pregunta quien necesita el porqué y no sólo el
+// qué —el rastro de un push lo anota (caso 112)—, y no concede nada: preguntar no cambia qué va a valer
+// en el mensaje siguiente.
+//
+// Conceder y heredar son dos cosas distintas y hasta 0.83.0 se movían juntas: conceder es escribir en el
+// registro, heredar es leer lo que escribió un mensaje anterior. Quien decide algo que vuelve a tener
+// consecuencia cada vez que ocurre apaga lo segundo con `inherit: false`, y ahí vale lo que la persona pidió
+// en el mensaje en curso o aprobó con un «dale» (caso 119).
+function authorized(input, items, { asked = named, inherit = true } = {}) {
+  const saved = said(input)
+  if (!saved) return []
+  return items.map((item) => ({ item, via: why(saved, item, asked, inherit) })).filter((one) => one.via)
+}
+
+// Lo que la persona no autorizó de lo que un guard está por frenar; lo que sí, queda concedido.
 function unauthorized(input, items) {
   const saved = said(input)
   if (!saved) return items
-  return items.filter((item) => !saved.approved.includes(item) && !mentions(saved.text, item).named)
+  const passed = items.filter((item) => why(saved, item, named, true))
+  grant(input, saved, passed)
+  return items.filter((item) => !passed.includes(item))
+}
+
+// Lo mismo sin conceder y sin heredar: lo que no está en el mensaje en curso queda pendiente aunque la
+// sesión lo haya dejado pasar antes.
+function unauthorizedNow(input, items) {
+  const cleared = new Set(authorized(input, items, { inherit: false }).map((one) => one.item))
+  return items.filter((item) => !cleared.has(item))
 }
 
 // Lo que quedó frenado, para que un «dale» en el mensaje siguiente apruebe exactamente eso y nada más.
@@ -119,4 +230,4 @@ function hold(input, items) {
   } catch { return false }
 }
 
-module.exports = { DIR, record, said, unauthorized, hold }
+module.exports = { DIR, record, said, authorized, unauthorized, unauthorizedNow, 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,
 }