@ingeniomaps/cauce 0.79.0 → 0.81.0

package/engine/hooks/chat.js

@@ -0,0 +1,122 @@
+'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
+const CLAUSE = /[.,;:!?\n]/
+
+// 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.
+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
+      found.push(NEGATION.test(lower.slice(0, at).split(CLAUSE).pop()))
+    }
+  }
+  return { named: found.includes(false), denied: found.includes(true) }
+}
+
+// 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 nombró en su mensaje ni lo
+// aprobó contestando.
+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)
+}
+
+// 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 }

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.
@@ -50,25 +47,58 @@ function alreadyShipped(file) {
 }
 
 
+// Qué archivo es una credencial, para los dos guards que la cuidan: `secrets`, que frena escribirla, y
+// `secrets-read`, que frena leerla. Devuelve el motivo, o vacío.
+function credential(input, raw) {
+  const base = path.basename(raw)
+  if (/^(?:\.env|\.env\..+)$/.test(base) && !/\.(?:example|sample|template|schema|dist|tpl)$/.test(base)) {
+    return 'parece contener secretos. Edita una plantilla o registra una acción humana.'
+  }
+  if (/^(?:accesos\.md|credenciales.*|credentials.*\.json|.*service-account.*\.json|.*\.(?:pem|key))$/i.test(base)) {
+    return 'parece un archivo de credenciales en texto plano.'
+  }
+  // Nombres de credencial que la herramienta escribe sola y que la lista anterior no cubría:
+  // `.npmrc` guarda el token de publicación, `.netrc` el de cualquier host, `id_rsa` y sus tres
+  // hermanas una clave privada de SSH, y `credentials` las de AWS. Los cuatro son estándar, no
+  // exóticos — y las claves SSH van por nombre de algoritmo, no por prefijo.
+  //
+  // Esto tapa un caso conocido; no vuelve completo al guard. La forma de decidir sigue siendo el
+  // nombre del archivo, así que otro formato pasa igual — ver «Qué son y qué no son» en el README.
+  if (/^(?:\.npmrc|\.netrc|_netrc|\.pypirc|\.dockercfg|id_(?:rsa|dsa|ecdsa|ed25519)|credentials)$/i.test(base)) {
+    return 'es un archivo de credenciales que su herramienta mantiene. No lo edites a mano.'
+  }
+  // Lo que ningún nombre delata: una identidad de máquina que el 088 declara puede llamarse
+  // `local-dev.env` (caso 092). Se lee sólo si la declaración existe, para no cargarla en cada hook.
+  const root = opsRoot(input)
+  if (!root || !fs.existsSync(path.join(root, 'organization', 'secrets.json'))) return ''
+  return require('../secrets').identityFiles(root).includes(path.resolve(cwdOf(input), raw))
+    ? 'es una identidad declarada en organization/secrets.json: la carga una persona.'
+    : ''
+}
+
 function secrets(input) {
   for (const file of filesOf(input)) {
-    const base = path.basename(file)
-    if (/^(?:\.env|\.env\..+)$/.test(base) && !/\.(?:example|sample|template|schema|dist|tpl)$/.test(base)) {
-      block(`${file} parece contener secretos. Edita una plantilla o registra una acción humana.`)
-    }
-    if (/^(?:accesos\.md|credenciales.*|credentials.*\.json|.*service-account.*\.json|.*\.(?:pem|key))$/i.test(base)) {
-      block(`${file} parece un archivo de credenciales en texto plano.`)
-    }
-    // Nombres de credencial que la herramienta escribe sola y que la lista anterior no cubría:
-    // `.npmrc` guarda el token de publicación, `.netrc` el de cualquier host, `id_rsa` y sus tres
-    // hermanas una clave privada de SSH, y `credentials` las de AWS. Los cuatro son estándar, no
-    // exóticos — y las claves SSH van por nombre de algoritmo, no por prefijo.
-    //
-    // Esto tapa un caso conocido; no vuelve completo al guard. La forma de decidir sigue siendo el
-    // nombre del archivo, así que otro formato pasa igual — ver «Qué son y qué no son» en el README.
-    if (/^(?:\.npmrc|\.netrc|_netrc|\.pypirc|\.dockercfg|id_(?:rsa|dsa|ecdsa|ed25519)|credentials)$/i.test(base)) {
-      block(`${file} es un archivo de credenciales que su herramienta mantiene. No lo edites a mano.`)
-    }
+    const reason = credential(input, file)
+    if (reason) block(`${file} ${reason}`)
+  }
+}
+
+// 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
+  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], input)}`)
   }
 }
 
@@ -121,17 +151,18 @@ function testEvidence(input) {
     'decir que el comportamiento está y pasa a decir que nadie lo miró.\n' +
     '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' + AP.HOW('OPS_TEST_EVIDENCE_OVERRIDE')
+    'decisión con dueño.\n'
+  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}`)
+    if (isTestFile(removed) && !approved(input, removed)) block(`${removed} borra una prueba.\n${why}${how(removed)}`)
   }
   const content = contentOf(input)
   if (!content) return
   for (const raw of filesOf(input)) {
     if (!isTestFile(raw) || approved(input, raw)) continue
     for (const [marca, nombre] of TEST_OFF) {
-      if (marca.test(content)) block(`${raw} apaga una prueba con ${nombre}.\n${why}`)
+      if (marca.test(content)) block(`${raw} apaga una prueba con ${nombre}.\n${why}${how(raw)}`)
     }
   }
 }
@@ -150,6 +181,28 @@ function opsOwned(root, file) {
   return OPS_OWNED.some((prefix) => relative.startsWith(prefix))
 }
 
+// Producto es el código de una raíz declarada, y la instancia sidecar no lo es aunque viva dentro de una:
+// `init` escribe `..` como raíz en sidecar, así que la carpeta de la instancia cae adentro. En embedded la
+// raíz de ops **es** una raíz de producto, y ahí sólo se exime lo que la instancia posee. Lo que queda
+// fuera de toda raíz tampoco es producto: el límite de raíces ya lo juzgó, y si pasó es porque el proyecto
+// lo declaró en `writableOutsideRoots` (casos 089 y 090).
+//
+// `ops.config.json` se exime por nombre porque es la llave del límite de raíces: su mensaje manda a
+// editarlo, y frenar esa edición era el candado de arriba con otra forma.
+const INSTANCE_CONFIG = 'ops.config.json'
+
+function isProduct(root, file) {
+  if (opsOwned(root, file) || file === path.join(root, INSTANCE_CONFIG)) return false
+  const declared = configOf(root).workspaceRoots
+  const roots = (Array.isArray(declared) ? declared : [])
+    .filter((entry) => entry && typeof entry.path === 'string')
+    .map((entry) => path.resolve(root, entry.path))
+  // Sin raíces legibles no hay contra qué comparar, y se juzga como antes: frenar de más.
+  if (!roots.length) return true
+  if (outsideRoots(file, roots)) return false
+  return outsideRoots(file, [root]) || roots.includes(root)
+}
+
 // R1 y el paso 7 del protocolo piden el plan antes del primer cambio, y hasta acá nadie lo comprobaba:
 // tocar el archivo primero y redactar después la aceptación que lo justifica sale igual de verde que
 // hacerlo al revés, y se lee igual en DONE. Lo que se exige es lo mínimo que separa un plan de una
@@ -160,6 +213,10 @@ function opsOwned(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')
@@ -176,20 +233,21 @@ function planFirst(input) {
   const why = `${estado}, así que el plan todavía no está escrito.\n`
     + 'Escribí en tu planning/wip/<runner>.md la tarea y su plan aprobado —pasos numerados, cada uno con un estado '
     + 'verificable— y volvé al cambio. Si esto no es trabajo de una tarea, aprobá la ruta.\n'
-    + AP.HOW('OPS_PLAN_FIRST_OVERRIDE')
   for (const raw of filesOf(input)) {
-    if (opsOwned(root, path.resolve(cwdOf(input), raw))) continue
+    if (!isProduct(root, path.resolve(cwdOf(input), raw))) continue
     if (approved(input, raw)) continue
-    block(`${raw} cambia el producto sin plan. ${why}`)
+    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}`)
     }
   }
@@ -254,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')}`)
+      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
@@ -264,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'))
+        + AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized], input))
     }
   }
 }
@@ -295,6 +353,7 @@ function engineWrites(input) {
 }
 
 module.exports = {
-  secrets, integrationSnapshot, generated, testEvidence, planFirst, workspaceBoundary,
+  credential, patternNames,
+  secrets, secretsRead, integrationSnapshot, generated, testEvidence, planFirst, workspaceBoundary,
   migrations, engineWrites,
 }

package/engine/hooks/input.js

@@ -262,9 +262,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,
+  findOpsRoot, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT, unquoted,
 }

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,
@@ -47,14 +50,19 @@ const guards = {
   'integration-snapshot': files.integrationSnapshot,
   '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'],
 }
 
@@ -87,18 +95,31 @@ 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',
     event: 'PreToolUse · files',
     purpose: 'Bloquea escribir secretos, claves privadas y credenciales en texto plano.',
   },
+  {
+    name: 'secrets-read',
+    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',
@@ -126,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 }