@ingeniomaps/cauce 0.81.0 → 0.83.0

package/engine/hooks/ops-config.js

@@ -0,0 +1,110 @@
+'use strict'
+
+// Las dos llaves que deciden si un `git push` se publica —`runner.allowPush` y `runner.pushToLiveBranches`—
+// viven en `ops.config.json`, y hasta 0.82.0 ningún guard miraba ese archivo: el bloqueo que dice «esto lo
+// decide una persona» se levantaba escribiendo el archivo que lo levanta, por `Write` o por `sed -i`, y el
+// mensaje del bloqueo nombra el campo exacto que hay que agregar (caso 114).
+//
+// **Protege esos dos campos y no el archivo.** Protegerlo entero repondría el candado que el 090 sacó: el
+// límite de raíces manda a declarar la ruta en `writableOutsideRoots`, de este mismo archivo, así que
+// frenar esa edición dejaría al agente sin la salida que el otro guard le acaba de indicar. Todo lo demás
+// —raíces, migraciones, lo que sea— sigue pasando como trabajo normal.
+//
+// Son dos guards y un solo archivo, como `secrets` y `secrets-shell`: corren en eventos distintos y cada
+// grupo cubre a cada guard una vez, mientras que lo que deciden —cuál es el archivo, qué llave cambió y
+// cómo se dice— es uno solo y copiarlo dejaría dos mitades que dejan de coincidir.
+
+const path = require('node:path')
+const { block, commandOf, configOf, contentOf, cwdOf, filesOf, opsRoot } = require('./input')
+const CHAT = require('./chat')
+const { writesWithBase } = require('./shell')
+
+const INSTANCE_CONFIG = 'ops.config.json'
+const PROTECTED = ['allowPush', 'pushToLiveBranches']
+const NAMES = PROTECTED.map((name) => `runner.${name}`).join(' y ')
+
+// El valor de cada llave en la forma en que se comparan. Ausente no es vacío: sacar `pushToLiveBranches`
+// cambia qué ramas alcanza el permiso y tiene que distinguirse de dejarlo en una lista sin ramas. Lo hace
+// `JSON.stringify`, que de un campo ausente no devuelve nada y de ninguno presente devuelve la cadena vacía.
+function keysOf(config) {
+  const runner = (config && typeof config.runner === 'object' && config.runner) || {}
+  return PROTECTED.map((name) => JSON.stringify(runner[name])).join(' ')
+}
+
+// El mensaje le habla a la persona y deja el permiso como cosa suya; el porqué de esa redacción está en
+// `HOW`, en `approval.js`.
+const HANDS_OFF = 'Lo decide una persona (R10): decile qué se frenó y esperá. Lo pone ella editando el '
+  + `archivo, o pidiéndotelo en el chat nombrando ${INSTANCE_CONFIG}.`
+
+function changeMessage(file) {
+  return `${file} lleva las dos llaves que deciden qué push se publica, ${NAMES}, y este cambio las toca. `
+    + `${HANDS_OFF}\nEl resto del archivo no lo frena este guard: si venías a declarar una raíz o a tocar `
+    + 'cualquier otro campo, mandá el mismo cambio sin mover esas dos llaves.'
+}
+
+// **Un contenido que no se puede leer como JSON se frena.** Un `Edit` manda el fragmento que reemplaza y no
+// el archivo, así que no hay con qué comparar: dejarlo pasar apagaría este guard con la herramienta más
+// común de todas, y frenarlo deja una salida más cara pero escrita —mandar el archivo entero, que sí se
+// compara—. Es el mismo criterio con el que el motor decide cuando no puede leer el índice de git.
+function unreadableMessage(file) {
+  return `${file} no llega como un JSON completo que se pueda leer, así que no hay cómo saber si el cambio `
+    + `toca ${NAMES}, las dos llaves que deciden qué push se publica. Un guard que no puede verificar no `
+    + 'autoriza: mandá el archivo entero en una sola escritura y el guard compara lo que cambia.'
+}
+
+// **Por shell se frena toda escritura, y no sólo la de las dos llaves.** La mitad de archivos compara dos
+// contenidos porque tiene los dos: el entrante viene en la llamada y el otro está en disco. Un comando no
+// trae ninguno —`sed -i 's/false/true/'` dice qué reemplaza, no con qué va a quedar el archivo—, y
+// averiguarlo sería ejecutarlo, que es justo lo que este guard corre antes de que ocurra. Sin contenido que
+// comparar quedan dos conductas posibles y ninguna intermedia, y se elige la que cierra la vía que el 114
+// midió.
+function commandMessage(file) {
+  return `el comando escribe en ${file}, donde viven las dos llaves que deciden qué push se publica, `
+    + `${NAMES}. Un comando no dice con qué va a quedar el archivo, así que acá se frena toda escritura y `
+    + `no sólo la de esas dos llaves. ${HANDS_OFF}\nSi el cambio es de cualquier otro campo, escribí el `
+    + 'archivo entero con la herramienta de edición, que el guard sí puede comparar.'
+}
+
+// Lo que la persona pidió nombrando el archivo pasa: ahí quien decide es ella, que es lo que este guard
+// cuida. Se pregunta cada vez —sin conceder y sin heredar—, igual que `self-approval`: las dos llaves que
+// viven acá son el permiso de push, y nombrar el archivo una vez no lo deja abierto toda la sesión. El
+// comentario decía «lo mismo» mientras el código concedía (caso 119).
+const asked = (input, file) => !CHAT.unauthorizedNow(input, [file]).length
+
+function judgeWrite(input, root, file) {
+  if (!filesOf(input).some((raw) => path.resolve(cwdOf(input), raw) === file)) return
+  if (asked(input, file)) return
+  let incoming = null
+  try { incoming = JSON.parse(contentOf(input)) } catch { block(unreadableMessage(file)) }
+  if (keysOf(configOf(root)) !== keysOf(incoming)) block(changeMessage(file))
+}
+
+function judgeCommand(input, file) {
+  for (const { raw, base } of writesWithBase(commandOf(input), cwdOf(input))) {
+    // Una ruta relativa sin base contra la que resolverla no se puede juzgar, y esa pregunta es de
+    // `shell-boundary`, que ya la contesta para todo destino.
+    if (!path.isAbsolute(raw) && base === null) continue
+    if (path.resolve(base || '/', raw) !== file) continue
+    if (asked(input, file)) return
+    block(commandMessage(file))
+  }
+}
+
+// La configuración que decide, o nada. Sin raíz ops no hay ninguna: `push.js` lee el `runner` de esta
+// misma raíz, así que donde no la hay tampoco hay permiso que escribirse.
+function target(input) {
+  const root = opsRoot(input)
+  return root ? { root, file: path.join(root, INSTANCE_CONFIG) } : null
+}
+
+function opsConfig(input) {
+  const found = target(input)
+  if (found) judgeWrite(input, found.root, found.file)
+}
+
+function opsConfigShell(input) {
+  const found = target(input)
+  if (found) judgeCommand(input, found.file)
+}
+
+module.exports = { opsConfig, opsConfigShell }

package/engine/hooks/push.js

@@ -0,0 +1,194 @@
+'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 fs = require('node:fs')
+const path = require('node:path')
+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.'
+}
+
+// El rastro de las aprobaciones que publicaron: una línea por push que pasó porque alguien lo autorizó.
+// Una aprobación se consume sin dejar nada —un «dale» publica y al mensaje siguiente ya no queda quién lo
+// autorizó— y un push no vuelve atrás, así que «quién, a qué rama y cuándo» no tenía de dónde salir
+// (caso 112).
+//
+// Sólo agrega, a diferencia del registro de gates, que es rodante: lo que una auditoría pregunta es
+// justamente la entrada vieja.
+//
+// No guarda el texto de la persona. La vía y la sesión alcanzan para reconstruir qué pasó, y el texto se
+// queda en el temporal, que es donde el 098 decidió dejarlo.
+//
+// Y anota la autorización, no el resultado: este hook corre antes del comando, así que un push que después
+// falla queda registrado igual. Por eso la fecha se llama `authorizedAt` y no `at`: leer la línea como
+// «esto se publicó» afirmaría algo que el hook no puede saber.
+const LOG = path.join('planning', '.push-log')
+
+function trail(root, session, entries) {
+  if (!root) return
+  try {
+    const authorizedAt = new Date().toISOString()
+    const file = path.join(root, LOG)
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.appendFileSync(file, `${entries
+      .map((one) => JSON.stringify({ authorizedAt, ...one, session: session || null })).join('\n')}\n`)
+  } catch { /* el push ya estaba autorizado: no lo frena un registro que no se pudo escribir */ }
+}
+
+// Un destino en la forma en que se anota. Sin remoto ni rama resolubles va `null`, que es exactamente lo
+// que el comando dejó ver.
+const entryOf = (to, via) => ({ remote: to.remote || null, branch: to.branch || null, via })
+
+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 destinations = pushes.flatMap((match) => destinationsOf(match[1], dir))
+  const byFile = destinations.filter((to) => to.item && to.item.startsWith('push ') && filed.has(to.item))
+  const left = destinations.filter((to) => !byFile.includes(to))
+  const unlisted = left.filter((to) => to.every || (live.has(to.branch) && !listed.has(to.branch)))
+  if (unlisted.length) block(liveMessage(unlisted, input))
+  // Con la llave puesta no hizo falta ninguna aprobación, así que no hay ninguna que anotar: la
+  // autorización ya está escrita en `ops.config.json`, y repetirla en cada push sería registrar el archivo
+  // del proyecto contra sí mismo.
+  if (runner.allowPush === true) return
+  const items = [...new Set(left.map((to) => to.item))]
+  // Se pregunta sin conceder, a diferencia de lo que pasa por `AP.pending`: volver a leer lo que ya se
+  // leyó no agrega consecuencia y volver a publicar sí, así que la autorización de un push vale para esa
+  // operación y no para el mensaje siguiente (R10).
+  const cleared = CHAT.authorized(input, items, { asked: CHAT.ordersPush })
+  const unordered = items.filter((item) => !cleared.some((one) => one.item === item))
+  if (unordered.length) block(workMessage(unordered, input))
+  const destination = new Map(destinations.map((to) => [to.item, to]))
+  trail(root, input.session_id, [
+    ...new Map(byFile.map((to) => [to.item, entryOf(to, AP.APPROVAL)])).values(),
+    ...cleared.map((one) => entryOf(destination.get(one.item), one.via)),
+  ])
+}
+
+module.exports = { publish }

package/engine/hooks/run.js

@@ -14,6 +14,7 @@ const shell = require('./shell')
 const files = require('./files')
 const chat = require('./chat')
 const { secretsShell } = require('./secrets-shell')
+const { opsConfig, opsConfigShell } = require('./ops-config')
 
 function planningDrift(input) {
   const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
@@ -42,6 +43,8 @@ const guards = {
   verify: shell.verify,
   'shell-boundary': shell.shellBoundary,
   'secrets-shell': secretsShell,
+  'ops-config-shell': opsConfigShell,
+  'ops-config': opsConfig,
   secrets: files.secrets,
   generated: files.generated,
   'workspace-boundary': files.workspaceBoundary,
@@ -58,9 +61,9 @@ const guards = {
 // 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',
-    'secrets-shell'],
+    'secrets-shell', 'ops-config-shell'],
   'pre-files': ['secrets', 'generated', 'workspace-boundary', 'engine', 'migrations',
-    'integration-snapshot', 'test-evidence', 'plan-first'],
+    'integration-snapshot', 'test-evidence', 'plan-first', 'ops-config'],
   'pre-read': ['secrets-read'],
   prompt: ['chat'],
   stop: ['planning-drift'],
@@ -114,6 +117,18 @@ const hookMetadata = [
     purpose: 'Bloquea leer por shell una credencial conocida o declarada; lo que la persona pidió en el chat '
       + 'pasa.',
   },
+  {
+    name: 'ops-config',
+    event: 'PreToolUse · files',
+    purpose: 'No deja al agente escribirse el permiso de push: frena la escritura que cambia '
+      + 'runner.allowPush o runner.pushToLiveBranches en ops.config.json. El resto del archivo pasa.',
+  },
+  {
+    name: 'ops-config-shell',
+    event: 'PreToolUse · shell',
+    purpose: 'Frena toda escritura por shell sobre ops.config.json: un comando no dice con qué va a '
+      + 'quedar el archivo, así que no hay contenido que comparar.',
+  },
   { name: 'generated', event: 'PreToolUse · files', purpose: 'Impide editar código generado manualmente.' },
   {
     name: 'workspace-boundary',

package/engine/hooks/secrets-shell.js

@@ -33,11 +33,21 @@ function verbOf(words) {
   return words[0] || ''
 }
 
+// `${VAR}` y `$VAR` son la misma expansión, y sólo la primera lleva llaves: la separación de palabras corta
+// ahí, así que de `ops/${O}/.env.infisical` quedaba suelto `/.env.infisical` —una ruta absoluta que el
+// comando no lee y que el bloqueo ofrecía aprobar—. Sin llaves, la expansión se queda pegada a su ruta y el
+// guard la ve como lo que es: algo que no resolvió (caso 118).
+const unbraced = (command) => String(command).replace(/\$\{(\w+)\}/g, '$$$1')
+
+// Lo que el shell iba a expandir y el guard no: una variable, un `$(…)` o un backtick. Lo que sale de ahí
+// no nombra ningún archivo, así que no se puede aprobar por archivo.
+const UNRESOLVED = /[$`]/
+
 // 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]+|\$\(|`/)) {
+  for (const segment of unbraced(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) || []))
@@ -56,7 +66,8 @@ function secretsShell(input) {
   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)}`)
+    + 'Si hace falta un valor, pedíselo a una persona.\n'
+    + AP.HOW('OPS_SECRETS_READ_OVERRIDE', left, input, left.filter((one) => !UNRESOLVED.test(one))))
 }
 
 module.exports = { secretsShell }

package/engine/hooks/self-approval.js

@@ -8,24 +8,104 @@
 // 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.
+//
+// **Nombrar el archivo autoriza el archivo, no lo que se escribe adentro**, y hasta 0.83.0 eso era todo lo
+// que se comprobaba: la persona pedía agregar una ruta inocua, el agente escribía `push origin main`, y esa
+// línea después publicaba en la rama viva —el alcance que el 108 le dio a propósito, apoyado en que sólo
+// una persona podía escribirla—. Medido punta a punta (caso 119). Por eso lo que llega se compara línea por
+// línea contra lo que la persona pidió, y son dos entradas porque cada vía tiene con qué distinto.
 
 const path = require('node:path')
-const { opsRoot } = require('./input')
+const { contentOf, 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 CHAT_RECORD = (file) => `${file} es el registro de lo que la persona dijo en el chat: lo escribe el `
+  + 'runner, nunca una herramienta.'
+
+const SELF = (file) => `${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.'
+
+// Las líneas van en el mensaje porque son lo que el «dale» va a aprobar: una confirmación que no muestra
+// qué autoriza es la que firma lo que nadie leyó.
+const UNASKED = (file, missing) => `${file} es la aprobación de una persona y estas líneas no las pidió:\n`
+  + missing.map((line) => `  ${line}\n`).join('')
+  + 'Escribí sólo lo que ella nombró en su mensaje. Si hacen falta las otras, decile cuáles y por qué, y '
+  + 'esperá: si contesta «dale», reintentá la misma escritura y pasa.'
+
+// **Por shell se frena toda escritura.** Es la misma decisión que toma `ops-config`, y por qué un comando
+// no se puede comparar está escrito allá. Lo que la trae hasta acá es que el contenido es lo único que
+// separa la línea que la persona pidió de la que el agente se escribe solo.
+const BY_COMMAND = (file) => `el comando escribe en ${file}, la aprobación de una persona, y no dice con `
+  + 'qué va a quedar el archivo: sin eso no hay cómo saber si lo que se agrega es lo que ella pidió. '
+  + 'Mandalo con la herramienta de edición, que trae el contenido y se compara línea por línea, o que lo '
+  + 'pegue ella.'
+
+// La raíz de la instancia si `file` es su aprobación, o `null`.
+function approvalRoot(input, file) {
   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.'
+  return root && file === path.join(root, 'planning', AP.APPROVAL) ? root : null
+}
+
+// Lo que las dos vías deciden igual: el registro del chat no se escribe nunca, y la aprobación sólo si la
+// persona la nombró en su mensaje.
+//
+// Se pregunta sin conceder: una concesión que sobreviviera al mensaje convertiría «agregá src/x.js a
+// .ops-approval» en permiso para escribirle después cualquier otra línea, que es aprobarse solo por la
+// puerta de al lado.
+function common(input, file) {
+  if (file === CHAT.DIR || file.startsWith(`${CHAT.DIR}${path.sep}`)) return CHAT_RECORD(file)
+  if (!approvalRoot(input, file)) return ''
+  return CHAT.authorized(input, [file]).length ? '' : SELF(file)
+}
+
+// Una línea de push no se pregunta como una ruta: `mentions` compara también el basename, así que para
+// `push origin feat/login` alcanzaría con que el mensaje pidiera algo del login (caso 103). Es la misma
+// partición que hace `push.js` cuando pregunta por un destino.
+const isPush = (line) => /^push\s+\S+\s+\S+$/.test(line)
+
+// Por qué no se puede escribir este contenido, o vacío.
+//
+// **Lo que ya estaba en disco no se vuelve a nombrar**: esta escritura no lo agrega, y exigirlo obligaría a
+// repetir el archivo entero para sumar una línea. Quitar tampoco se pregunta: una aprobación más corta
+// autoriza menos.
+//
+// **Un fragmento sí se juzga, al revés que en `ops.config.json`.** Allá el archivo entrante se compara
+// entero porque una llave cambia de sentido según lo que la rodea, y un `Edit` manda un pedazo; acá cada
+// línea vale por sí sola, así que el pedazo que llega es exactamente lo que se agrega. Lo que no se puede
+// leer como líneas —un parche con sus encabezados— no coincide con nada pedido y se frena, que es el lado
+// correcto para equivocarse.
+//
+// Y se pregunta sin heredar lo que la sesión concedió antes: una línea acá la leen todos los guards y llega
+// hasta la rama viva, así que tiene que ser la que la persona dijo en el mensaje en curso.
+function unasked(input, root, file) {
+  const filed = new Set(AP.read(root))
+  const added = AP.lines(contentOf(input)).filter((line) => !filed.has(line))
+  const pushes = CHAT.authorized(input, added.filter(isPush), { asked: CHAT.ordersPush, inherit: false })
+  const paths = CHAT.authorized(input, added.filter((line) => !isPush(line)), { inherit: false })
+  const cleared = new Set([...pushes, ...paths].map((one) => one.item))
+  const missing = added.filter((line) => !cleared.has(line))
+  if (!missing.length) return ''
+  // El archivo se anota junto con las líneas: sin él, el «dale» aprobaría las líneas y el guard volvería a
+  // frenar por el archivo, que en ese mensaje ya nadie nombra.
+  CHAT.hold(input, [file, ...missing])
+  return UNASKED(file, missing)
+}
+
+// Por qué el agente no puede escribir en `file` con la herramienta de edición, o vacío.
+function selfApproval(input, file) {
+  const stop = common(input, file)
+  if (stop) return stop
+  const root = approvalRoot(input, file)
+  return root ? unasked(input, root, file) : ''
+}
+
+// Lo mismo para el destino de un comando, o vacío.
+function selfApprovalShell(input, file) {
+  const stop = common(input, file)
+  if (stop) return stop
+  return approvalRoot(input, file) ? BY_COMMAND(file) : ''
 }
 
-module.exports = { selfApproval }
+module.exports = { selfApproval, selfApprovalShell }

package/engine/hooks/shell.js

@@ -9,11 +9,12 @@ 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 { selfApproval } = require('./self-approval')
+const { publish } = require('./push')
+const { selfApprovalShell } = require('./self-approval')
 const EV = require('../core/evidence')
 
 // Dónde empieza y dónde termina una palabra dentro de un comando. Tres reglas de la tabla de abajo lo
@@ -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/`
@@ -175,7 +177,7 @@ function dependencies(input) {
   // Lo que se juzga acá es el archivo staged, así que la aprobación por ruta lo expresa: autorizar
   // `package.json` dice «este manifiesto va sin su lock a propósito» y deja de valer en cuanto el
   // conjunto cambie. La rama de publicar no pasa por acá y no tiene ruta: sigue arriba, con su variable.
-  const sinAprobar = (parent, names) => AP.pending(opsRoot(input),
+  const sinAprobar = (parent, names) => AP.pendingNow(opsRoot(input),
     names.map((name) => path.posix.join(parent === '.' ? '' : parent, name)), input)
   // Un lock cuenta si está en disco **o** si el commit lo va a llevar, y la unión no es un detalle: el
   // disco solo perdía el que alguien borró del árbol sin stagear el borrado —sigue en el índice, sigue
@@ -313,7 +315,7 @@ function shellBoundary(input) {
     const file = path.resolve(base || '/', raw)
     // El canal por el que la persona aprueba no es un destino más: se juzga aunque no haya raíces
     // declaradas y aunque caiga en el temporal, que el resto de este guard deja pasar (caso 098).
-    const own = selfApproval(input, file)
+    const own = selfApprovalShell(input, file)
     if (own) block(own)
     if (!allowed || NEUTRAL.some((pattern) => pattern.test(file))) continue
     if (outsideRoots(file, allowed)) {
@@ -346,7 +348,7 @@ function governance(input) {
   // La aprobación vale para lo que nombra y para nada más: lo que quede sin cubrir es lo que se
   // reporta. Así una aprobación vieja no autoriza el archivo que se sumó después, que es la diferencia
   // entre una llave por operación y una puerta que quedó abierta.
-  const pendientes = AP.pending(opsRoot(input), governed, input)
+  const pendientes = AP.pendingNow(opsRoot(input), governed, input)
   if (!pendientes.length) return
   block(`El commit toca gobernanza protegida.\n${AP.HOW('OPS_GOVERNANCE_OVERRIDE', pendientes, input)}`)
 }
@@ -487,7 +489,7 @@ function verify(input) {
   // Acá lo aprobado es el conjunto staged entero: decir «autorizo commitear exactamente estas rutas»
   // es lo que un gate en rojo necesita, y cambia en cuanto se stagea una más. La lista sale del índice
   // y no de una regla, que es lo que la vuelve una operación y no un permiso.
-  const sinAprobar = AP.pending(opsRoot(input), staged, input)
+  const sinAprobar = AP.pendingNow(opsRoot(input), staged, input)
   const aprobado = !sinAprobar.length
   if (changedOpenApi && !hasApiGenerated && !aprobado) {
     block('Cambió una fuente OpenAPI/Swagger sin incluir código regenerado. Ejecuta el generador y '
@@ -602,4 +604,4 @@ function verifyGates(root, dir, sinAprobar, env, input) {
     + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
 }
 
-module.exports = { destructive, gitAdd, dependencies, governance, verify, shellBoundary, run }
+module.exports = { destructive, gitAdd, dependencies, governance, verify, shellBoundary, run, writesWithBase }

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 }