@ingeniomaps/cauce 0.80.0 → 0.82.0

package/engine/hooks/chat.js

@@ -0,0 +1,171 @@
+'use strict'
+
+// Lo que la persona dijo en el chat, capturado por el runner y no contado por el modelo. Existe porque un
+// guard sólo ve la llamada a la herramienta: frenaba igual lo que la persona pidió con todas las letras y
+// lo que el agente decidió solo, y la única forma de decir «sí» era un archivo que el agente también
+// podía escribirse (caso 098).
+//
+// El hook de mensaje del runner —`UserPromptSubmit` en Claude y Codex, `BeforeAgent` en Gemini— corre
+// cuando la persona manda algo, y Claude y Codex le pasan a cada llamada el identificador del mensaje que
+// la originó. Lo que llega por otro lado —un README, un ticket, el resultado de una herramienta— nunca
+// pasa por acá, y ésa es toda la diferencia entre una orden y una sugerencia.
+//
+// No es un límite de seguridad, como ningún guard: un agente decidido a escribir este registro lo escribe
+// con un script. Lo que se frena es la forma habitual, y la frenan los guards de límites.
+
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+
+// El temporal y no la instancia: el texto de la persona no tiene por qué terminar en un commit, y una
+// orden dura lo que dura la sesión.
+const DIR = path.join(os.tmpdir(), 'cauce-chat')
+
+// Los recorridos de Cauce, donde el que piensa es el agente y los guards contienen como siempre. Salen de
+// los workflows que el paquete entrega, así que uno nuevo queda cubierto sin tocar esto; los de
+// `integrations/` se invocan con ese prefijo. Claude y Gemini los llaman con `/`, Codex con `$`.
+const WORKFLOWS = path.join(__dirname, '..', '..', 'automatization', 'workflows')
+const scripts = (dir, prefix) => fs.readdirSync(dir).filter((one) => one.endsWith('.js'))
+  .map((one) => `${prefix}${one.slice(0, -3)}`)
+function flowCommand(text) {
+  let names = []
+  try { names = [...scripts(WORKFLOWS, ''), ...scripts(path.join(WORKFLOWS, 'integrations'), 'integration-')] }
+  catch { return false }
+  return names.length > 0 && new RegExp(`^\\s*[/$](?:cauce:)?(?:${names.join('|')})(?![\\w-])`).test(text)
+}
+
+// Claude lo llama `prompt_id` y Codex `turn_id`; Gemini no manda ninguno y ahí vale el último mensaje.
+const idOf = (input) => String(input.prompt_id || input.turn_id || '')
+const recordPath = (session) => path.join(DIR, `${String(session).replace(/[^a-zA-Z0-9_-]/g, '_')}.json`)
+
+function load(session) {
+  try { return JSON.parse(fs.readFileSync(recordPath(session), 'utf8')) } catch { return null }
+}
+
+// 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
+// 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|$)/
+
+// 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 = []
+  for (const name of new Set([item, path.basename(item)].map((one) => one.toLowerCase()))) {
+    if (name.length < 3) continue
+    for (let at = lower.indexOf(name); at !== -1; at = lower.indexOf(name, at + 1)) {
+      const before = lower[at - 1]
+      const rest = lower.slice(at + name.length)
+      if (before && !/[\s'"`(/]/.test(before)) continue
+      if (rest && !/^(?:[\s'"`),;:!?]|\.(?:\s|$)|$)/.test(rest)) continue
+      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.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
+// entera o su primera palabra, no algo que aparece en medio de otra frase.
+const YES = new RegExp(String.raw`^\s*(?:s[ií]|dale|ok(?:ay)?|hac[eé]lo|hazlo|adelante|aprobado|apruebo`
+  + String.raw`|aprob[aá]lo|de acuerdo|yes)(?![\p{L}])`, 'iu')
+
+// 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.
+function record(input) {
+  try {
+    if (!input.session_id) return
+    const text = String(input.prompt || '')
+    const human = !process.env.CI && !/^\s*</.test(text)
+    const previous = load(input.session_id)
+    const approved = human && previous && YES.test(text)
+      ? previous.pending.filter((item) => !mentions(text, item).denied)
+      : []
+    fs.mkdirSync(DIR, { recursive: true })
+    fs.writeFileSync(recordPath(input.session_id),
+      JSON.stringify({ id: idOf(input), text, human, flow: flowCommand(text), approved, pending: [] }))
+  } catch { /* registrar es un extra: si falla, los guards siguen frenando lo que frenaban */ }
+}
+
+// El mensaje de la persona que originó esta llamada, o nada. Nada cuando no hay persona, cuando lo que
+// pidió es un recorrido de Cauce, cuando la llamada la hace un subagente —trabajo que el agente delegó,
+// y Claude lo marca con `agent_id`— o cuando el registro es de otro mensaje.
+function said(input) {
+  if (process.env.CI || input.agent_id || !input.session_id) return null
+  const saved = load(input.session_id)
+  if (!saved || !saved.human || saved.flow) return null
+  const current = idOf(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 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) && !asked(saved.text, item))
+}
+
+// Lo que quedó frenado, para que un «dale» en el mensaje siguiente apruebe exactamente eso y nada más.
+// Devuelve si hay una persona a quien preguntarle.
+function hold(input, items) {
+  const saved = said(input)
+  if (!saved) return false
+  try {
+    saved.pending = [...new Set([...saved.pending, ...items])]
+    fs.writeFileSync(recordPath(input.session_id), JSON.stringify(saved))
+    return true
+  } catch { return false }
+}
+
+module.exports = { DIR, record, said, unauthorized, hold, ordersPush }

package/engine/hooks/files.js

@@ -8,24 +8,21 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const {
-  patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot,
+  patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT,
 } = require('./input')
 const AP = require('./approval')
+const CHAT = require('./chat')
+const { selfApproval } = require('./self-approval')
 const { readWip } = require('../planning/parser')
 const { runner } = require('../planning/claims')
 const { hasTasks } = require('../planning/state')
 const { TEMPLATE_PREFIXES } = require('../core/ownership')
 
-// La raíz donde vive `planning/`, que es donde se busca la aprobación por operación.
-function opsRoot(input) {
-  return findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
-}
-
 // Si la ruta que este guard está por bloquear está aprobada, no hay nada que decir. Es la salida
 // angosta: vale para esa ruta y deja de valer en cuanto cambie, a diferencia de la variable, que apaga
 // el guard hasta que cierre la sesión.
-const approved = (input, file) => !AP.pending(opsRoot(input), [file]).length
+const approved = (input, file) => !AP.pending(opsRoot(input), [file], input).length
 
 // Si la migración ya viajó a otra copia, que es lo que el bloqueo de abajo quiere saber y `existsSync`
 // no contesta. Devuelve el motivo del bloqueo o cadena vacía.
@@ -88,12 +85,20 @@ function secrets(input) {
 
 // Leer una credencial la deja en el contexto de la sesión, y de ahí en los transcripts. Corre en su propio
 // grupo porque los guards de escritura frenarían leer fuera de las raíces o con el WIP vacío.
+// Un comodín también nombra: `rg -g '.env*'`, el `glob` del Grep de Claude o el `include_pattern` del
+// `grep_search` de Gemini recorren la carpeta buscando justo eso, y así leyeron el `.env` dos agentes en
+// sesiones reales (caso 104). Se prueba el nombre con el comodín vacío, la forma más corta que el patrón
+// acepta.
+const patternNames = (token) => (/[*?]/.test(token) ? [token.replace(/[*?]/g, '')] : [token]).filter(Boolean)
+
 function secretsRead(input) {
   if (process.env.OPS_SECRETS_READ_OVERRIDE === '1') return
-  for (const file of filesOf(input)) {
-    if (!credential(input, file) || approved(input, file)) continue
+  const fields = input.tool_input || {}
+  const patterns = [fields.glob, fields.include_pattern].filter((one) => typeof one === 'string')
+  for (const file of [...filesOf(input), ...patterns]) {
+    if (!patternNames(file).some((name) => credential(input, name)) || approved(input, file)) continue
     block(`${file} es una credencial: leerla la deja en el contexto de la sesión. Si hace falta un valor, `
-      + `pedíselo a una persona.\n${AP.HOW('OPS_SECRETS_READ_OVERRIDE', [file])}`)
+      + `pedíselo a una persona.\n${AP.HOW('OPS_SECRETS_READ_OVERRIDE', [file], input)}`)
   }
 }
 
@@ -147,7 +152,7 @@ function testEvidence(input) {
     'Si la aserción está mal, corregila; si el comportamiento cambió, cambialo junto con la prueba que ' +
     'lo fija. Si tiene que quedar afuera igual —flake conocido, entorno que acá no existe—, es una ' +
     'decisión con dueño.\n'
-  const how = (file) => AP.HOW('OPS_TEST_EVIDENCE_OVERRIDE', [file])
+  const how = (file) => AP.HOW('OPS_TEST_EVIDENCE_OVERRIDE', [file], input)
   for (const match of patchOf(input).matchAll(/^\*\*\* Delete File:\s*(.+)$/gm)) {
     const removed = match[1].trim()
     if (isTestFile(removed) && !approved(input, removed)) block(`${removed} borra una prueba.\n${why}${how(removed)}`)
@@ -208,6 +213,10 @@ function isProduct(root, file) {
 // vigila: la tarea ya está nombrada y el plan todavía no existe.
 function planFirst(input) {
   if (process.env.OPS_PLAN_FIRST_OVERRIDE === '1') return
+  // El plan lo exige el flujo, que es donde piensa el agente. Cuando la persona pide un cambio directo en
+  // el chat la que decidió es ella, y frenarla para que escriba un plan o apruebe una ruta es limitarla en
+  // lo que acaba de pedir (caso 098). Un subagente o un recorrido de Cauce no cuentan: `said` los descarta.
+  if (CHAT.said(input)) return
   const root = opsRoot(input)
   if (!root) return
   const planning = path.join(root, 'planning')
@@ -227,16 +236,18 @@ function planFirst(input) {
   for (const raw of filesOf(input)) {
     if (!isProduct(root, path.resolve(cwdOf(input), raw))) continue
     if (approved(input, raw)) continue
-    block(`${raw} cambia el producto sin plan. ${why}${AP.HOW('OPS_PLAN_FIRST_OVERRIDE', [raw])}`)
+    block(`${raw} cambia el producto sin plan. ${why}${AP.HOW('OPS_PLAN_FIRST_OVERRIDE', [raw], input)}`)
   }
 }
 
 function workspaceBoundary(input) {
   const allowed = writableRoots(input)
-  if (!allowed) return
   for (const raw of filesOf(input)) {
     const file = path.resolve(cwdOf(input), raw)
-    if (outsideRoots(file, allowed)) {
+    // Lo mismo que en `shell-boundary`: la aprobación de la persona se juzga aunque no haya raíces.
+    const own = selfApproval(input, file)
+    if (own) block(own)
+    if (allowed && outsideRoots(file, allowed)) {
       block(`${file} está fuera de las raíces declaradas en ops.config.json. ${DECLARE_IT}`)
     }
   }
@@ -301,7 +312,7 @@ function migrations(input) {
     if (!esMigracion.test(normalized)) continue
     if (approved(input, normalized)) continue
     if (destructiveSql.test(contentOf(input))) {
-      block(`${raw} contiene SQL destructivo.\n${AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized])}`)
+      block(`${raw} contiene SQL destructivo.\n${AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized], input)}`)
     }
     // El mensaje nombra el hecho que sostiene el bloqueo y no su interpretación: «historial» era una
     // lectura que `existsSync` no podía dar, y se la daba igual sobre stubs de la misma sesión. Y lleva
@@ -311,7 +322,7 @@ function migrations(input) {
     const shipped = alreadyShipped(file)
     if (shipped) {
       block(`${raw} ${shipped}. Crea una nueva en vez de reescribirla.\n`
-        + AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized]))
+        + AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized], input))
     }
   }
 }
@@ -342,6 +353,7 @@ function engineWrites(input) {
 }
 
 module.exports = {
+  credential, patternNames,
   secrets, secretsRead, integrationSnapshot, generated, testEvidence, planFirst, workspaceBoundary,
   migrations, engineWrites,
 }

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) {
@@ -262,9 +252,15 @@ function outsideRoots(file, allowed) {
 const DECLARE_IT = 'Si el proyecto necesita escribir ahí, declaralo en writableOutsideRoots de '
   + 'ops.config.json; cambiar de herramienta no lo autoriza.'
 
+// La raíz donde vive `planning/`, que es donde se busca la aprobación. La resuelven igual los guards de
+// archivos, los de shell y la aprobación misma, así que se resuelve en un solo lugar.
+function opsRoot(input) {
+  return findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+}
+
 module.exports = {
   readInput, commandOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
-  gitDirectory, isCommit, withoutGitGlobals, stagedFiles, stagedForCommit, pushAllowed,
-  findOpsRoot,
+  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/run.js

@@ -12,6 +12,8 @@ const path = require('node:path')
 const { readInput, cwdOf, block, findOpsRoot } = require('./input')
 const shell = require('./shell')
 const files = require('./files')
+const chat = require('./chat')
+const { secretsShell } = require('./secrets-shell')
 
 function planningDrift(input) {
   const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
@@ -39,6 +41,7 @@ const guards = {
   governance: shell.governance,
   verify: shell.verify,
   'shell-boundary': shell.shellBoundary,
+  'secrets-shell': secretsShell,
   secrets: files.secrets,
   generated: files.generated,
   'workspace-boundary': files.workspaceBoundary,
@@ -48,15 +51,18 @@ const guards = {
   'test-evidence': files.testEvidence,
   'plan-first': files.planFirst,
   'secrets-read': files.secretsRead,
+  chat: chat.record,
   'planning-drift': planningDrift,
 }
 
 // Grupos por evento: un runner corre el grupo entero en un solo proceso en lugar de un guard por hook.
 const hookGroups = {
-  'pre-shell': ['destructive', 'git-add', 'dependencies', 'governance', 'verify', 'shell-boundary'],
+  'pre-shell': ['destructive', 'git-add', 'dependencies', 'governance', 'verify', 'shell-boundary',
+    'secrets-shell'],
   'pre-files': ['secrets', 'generated', 'workspace-boundary', 'engine', 'migrations',
     'integration-snapshot', 'test-evidence', 'plan-first'],
   'pre-read': ['secrets-read'],
+  prompt: ['chat'],
   stop: ['planning-drift'],
 }
 
@@ -89,7 +95,8 @@ const hookMetadata = [
   {
     name: 'shell-boundary',
     event: 'PreToolUse · shell',
-    purpose: 'Frena el destino evidente de un comando que escribe fuera de las raíces declaradas.',
+    purpose: 'Frena el destino evidente de un comando que escribe fuera de las raíces declaradas, o en la '
+      + 'aprobación de la persona.',
   },
   {
     name: 'secrets',
@@ -101,11 +108,18 @@ const hookMetadata = [
     event: 'PreToolUse · read',
     purpose: 'Bloquea leer con la herramienta del runner una credencial conocida o declarada.',
   },
+  {
+    name: 'secrets-shell',
+    event: 'PreToolUse · shell',
+    purpose: 'Bloquea leer por shell una credencial conocida o declarada; lo que la persona pidió en el chat '
+      + 'pasa.',
+  },
   { name: 'generated', event: 'PreToolUse · files', purpose: 'Impide editar código generado manualmente.' },
   {
     name: 'workspace-boundary',
     event: 'PreToolUse · files',
-    purpose: 'Limita escrituras a las raíces declaradas en ops.config.json.',
+    purpose: 'Limita escrituras a las raíces declaradas en ops.config.json, y no deja al agente escribirse '
+      + 'la aprobación de la persona.',
   },
   {
     name: 'engine',
@@ -133,6 +147,12 @@ const hookMetadata = [
     event: 'PreToolUse · files',
     purpose: 'Exige WIP activo con plan escrito antes de cambiar el producto.',
   },
+  {
+    name: 'chat',
+    event: 'UserPromptSubmit / BeforeAgent',
+    purpose: 'Registra el mensaje de la persona: lo que nombró o aprobó en el chat pasa sin archivo. Nunca '
+      + 'bloquea.',
+  },
   {
     name: 'planning-drift',
     event: 'Stop / SessionEnd',

package/engine/hooks/secrets-shell.js

@@ -0,0 +1,62 @@
+'use strict'
+
+// Leer una credencial por shell. `secrets-read` mira la herramienta de lectura del runner, y un `cat .env`
+// no pasa por ella: en Claude lo tapaba una regla nativa `permissions.deny`, que además frenaba lo que la
+// persona pedía, y en los otros runners no lo tapaba nada (caso 104). Esto lo mira donde pasan todos los
+// comandos, con la misma salida que el resto: lo que la persona pidió en el chat pasa.
+//
+// Como todo lo que lee el texto de un comando, frena la forma habitual y no un script decidido: un nombre
+// armado en una variable o un `grep -r` sobre la carpeta sin nombrar el archivo pasan.
+
+const path = require('node:path')
+const { commandOf, cwdOf, block, isCommit, unquoted, opsRoot } = require('./input')
+const { credential, patternNames } = require('./files')
+const AP = require('./approval')
+
+// Lo que muestra el contenido de un archivo. Queda afuera lo que sólo lo nombra —`ls`, `test -f`, `rm`,
+// `git add`—, que no deja nada en la sesión, y `cp` y `mv`, cuyo último argumento es un destino: `cp
+// .env.example .env` es preparar el entorno, no leerlo. `nl` entró porque un agente lo usó en una sesión
+// real para leer el `.env` después de que la lista no lo tuviera.
+const READERS = new Set(['cat', 'tac', 'nl', 'head', 'tail', 'less', 'more', 'bat', 'sed', 'awk', 'grep', 'egrep',
+  'fgrep', 'rg', 'strings', 'xxd', 'od', 'hexdump', 'base64', 'cut', 'sort', 'uniq', 'rev', 'paste', 'fold', 'pr',
+  'dd', 'jq', 'yq', 'diff', 'cmp', 'source', '.', 'node', 'python', 'python3', 'ruby', 'perl', 'php', 'deno', 'bun'])
+const PREFIXES = new Set(['sudo', 'env', 'command', 'exec', 'time', 'nohup', 'nice', 'xargs'])
+
+// El verbo de un tramo, saltando lo que va delante sin serlo: asignaciones, prefijos y sus banderas.
+function verbOf(words) {
+  let prefixed = false
+  while (words.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]) || PREFIXES.has(words[0])
+    || (prefixed && words[0].startsWith('-')))) {
+    prefixed = prefixed || PREFIXES.has(words[0])
+    words.shift()
+  }
+  return words[0] || ''
+}
+
+// Las palabras de cada tramo que lee: el que empieza con un lector, o el que redirige un archivo a la
+// entrada. Lo entrecomillado se mira, porque el código de un `node -e` nombra el archivo ahí adentro.
+function readTokens(command) {
+  const found = []
+  for (const segment of command.split(/[;&|\n]+|\$\(|`/)) {
+    const words = segment.trim().replace(/^[({]+\s*/, '').split(/\s+/).filter(Boolean)
+    const reads = READERS.has(path.basename(verbOf(words))) || /<(?![<(])/.test(segment)
+    if (reads) found.push(...(segment.match(/[^\s'"`\\;|&<>(){}=,]+/g) || []))
+  }
+  return [...new Set(found)]
+}
+
+function secretsShell(input) {
+  if (process.env.OPS_SECRETS_READ_OVERRIDE === '1') return
+  const raw = commandOf(input)
+  // El mensaje de un commit es dato, como en `destructive`: nombrar el archivo ahí no lo lee.
+  const command = isCommit(raw) ? unquoted(raw) : raw
+  const cwd = cwdOf(input)
+  const files = readTokens(command).filter((token) => patternNames(token).some((name) => credential(input, name)))
+    .map((token) => path.resolve(cwd, token))
+  const left = AP.pending(opsRoot(input), [...new Set(files)], input)
+  if (!left.length) return
+  block(`el comando lee ${left.join(', ')}, que es una credencial: leerla la deja en el contexto de la sesión. `
+    + `Si hace falta un valor, pedíselo a una persona.\n${AP.HOW('OPS_SECRETS_READ_OVERRIDE', left, input)}`)
+}
+
+module.exports = { secretsShell }

package/engine/hooks/self-approval.js

@@ -0,0 +1,31 @@
+'use strict'
+
+// El canal por el que una persona dice «sí» no lo puede escribir el agente: si pudiera, cada bloqueo que
+// ofrece aprobarse se aprobaría solo. Pasaba —ningún guard miraba `planning/.ops-approval`— y en la prueba
+// en vivo del 092 el agente, frenado, intentó escribírsela (caso 098).
+//
+// Lo preguntan los dos guards de límites —el que mira un `Write` y el que mira el destino de un comando—,
+// que ya son los que deciden dónde puede caer una escritura. La persona edita el archivo a mano, que ningún
+// hook ve, o se lo pide al agente nombrándolo en el chat. El registro del chat no lo escribe nunca una
+// herramienta.
+
+const path = require('node:path')
+const { opsRoot } = require('./input')
+const AP = require('./approval')
+const CHAT = require('./chat')
+
+// Por qué el agente no puede escribir en `file`, o vacío.
+function selfApproval(input, file) {
+  if (file === CHAT.DIR || file.startsWith(`${CHAT.DIR}${path.sep}`)) {
+    return `${file} es el registro de lo que la persona dijo en el chat: lo escribe el runner, nunca una `
+      + 'herramienta.'
+  }
+  const root = opsRoot(input)
+  if (!root || file !== path.join(root, 'planning', AP.APPROVAL)) return ''
+  if (!CHAT.unauthorized(input, [file]).length) return ''
+  return `${file} es la aprobación de una persona, y escribírsela es aprobarse solo. Si la persona quiere `
+    + 'autorizar algo, que lo diga en el chat —nombrándolo, o contestando «dale» al bloqueo— o que edite el '
+    + 'archivo ella.'
+}
+
+module.exports = { selfApproval }