@ingeniomaps/cauce 0.83.0 → 0.85.0

package/CHANGELOG.md

@@ -14,6 +14,68 @@ desde este repositorio no va, porque el que lee no puede actuar sobre eso. Cuand
 unas pocas líneas casi siempre es porque cuenta cómo se descubrió el problema o por qué se eligió el
 diseño — eso vive en el commit y en el código.
 
+## [0.85.0] - 2026-09-12
+
+### Corregido
+
+- **Gobernanza ya no te interroga cuando sos vos quien pide el trabajo.** El guard que frena un commit que
+  toca reglas, ADR, `automatization/`, `engine/` o contratos de cargo te pedía **nombrar cada archivo** en
+  tu mensaje, o contestar «dale», o pegar las rutas en `planning/.ops-approval` — y te lo cobraba en cada
+  commit. Ahora, con una persona conduciendo el turno, no pregunta nada.
+
+  Lo que **no** cambia, y es el punto del guard: sigue frenando igual cuando el que commitea es un
+  subagente, un recorrido de Cauce o CI. Ahí nadie está conduciendo, que es exactamente para lo que existe.
+
+  Sus dos vecinos —`verify` y `dependencies`— **siguen preguntando**, y la diferencia no es quién pidió el
+  commit: esos frenan porque algo está mal —una verificación que falla, un manifiesto sin su lockfile— y
+  callarlos porque hay alguien hablando sería taparte un rojo. `OPS_GOVERNANCE_OVERRIDE` sigue existiendo
+  para el caso sin persona.
+
+  **Qué cambia para vos**: nada que hacer. Si venías aprobando commits de gobernanza uno por uno, o pegando
+  rutas a mano para poder trabajar, eso se terminó.
+
+## [0.84.0] - 2026-09-12
+
+### Corregido
+
+- **Una frase en inglés que prohíbe ya no autoriza.** Cauce reconoce si le negás algo antes de dejarlo
+  pasar, y en inglés sólo entendía `don't`: «the tool doesn't read the .env» o «we can't read the .env»
+  nombraban el archivo, traían un verbo y ninguna negación reconocida, así que **una frase que prohíbe
+  terminaba autorizando**. Entran ahora las contraídas con auxiliar —`doesn't`, `isn't`, `can't`,
+  `won't`, `wasn't`, `wouldn't`, `shouldn't`…—, con o sin apóstrofo.
+
+  **Qué cambia para vos**: nada que hacer. Si trabajás en inglés, negar algo ahora se respeta; lo que antes
+  pasaba por no entenderse, se frena. Una frase como «I can't tell if the .env is right» deja de autorizar
+  y cuesta un «dale», que es el mismo costo que el español ya tenía.
+
+- **La entrada de DONE dice contra qué reglas se revisó.** `autobuild` exige que Review nombre las reglas
+  contra las que revisó —si no las nombra, la corrida para—, pero esa lista quedaba sólo en el registro de
+  la corrida, que no sobrevive. Ahora va también en la línea `review=` de `DONE.md`, que es lo que queda.
+
+  **Qué cambia para vos**: nada que hacer. Al auditar una entrega vieja vas a poder decir contra qué se
+  revisó sin depender del registro de aquella corrida.
+
+- **Lo que pedís vos ya no se frena sin ofrecerte ninguna salida.** Siete de los guards que pueden frenar
+  nunca consultaban si lo habías pedido: no tenían variable, ni línea que pegar en
+  `planning/.ops-approval`, ni «dale». Entre ellos estaban las reglas que cubren trabajo de todos los días
+  —`git reset --hard`, `git clean -f`, `git checkout -- .`, `docker compose down`, `docker system prune`—
+  y los que frenan escribir una credencial, un archivo generado, un snapshot del sincronizador o el motor
+  instalado. Pedirlos con todas las letras no servía de nada: se frenaban igual que si los hubiera
+  decidido el agente por su cuenta.
+
+  Ahora preguntan lo mismo que el resto de los guards: si lo pediste en el chat pasa, y si no, el bloqueo
+  te dice qué se frenó y un «dale» lo aprueba. De paso se cierra una asimetría que nadie había decidido:
+  **leer** una credencial se podía aprobar desde 0.80.0 y **escribirla** no.
+
+  **Lo que no cambia, y es a propósito**: reescribir historia publicada —`git push --force`,
+  `git commit --amend`—, el borrado de disco, `rm -r` sobre la raíz, el home o el directorio padre, y
+  `git add -A`. Ésos no se abren ni pidiéndolos, porque R8 y R23 no admiten excepción configurable.
+
+  **Qué cambia para vos**: nada que hacer ni que reinstalar. Lo que antes te obligaba a exportar una
+  variable para poder trabajar —o directamente no tenía salida— ahora se destraba diciéndolo. El permiso
+  es angosto a propósito: vale para el comando entero tal como lo escribiste, así que otra bandera es otro
+  comando y se vuelve a preguntar.
+
 ## [0.83.0] - 2026-09-11
 
 ### Agregado

package/automatization/workflows/autobuild.js

@@ -790,7 +790,11 @@ while (rounds++ < MAX_TASKS) {
     if (governing.length) log(`Review contra: ${review.rules.join(', ')}`)
     // Aprobar sin declarar qué se abrió no se arregla mandando a tocar código: falló quien revisó.
     if (!review.consulted.length) return stop('review-unbacked', 'aprobó el diff sin declarar qué inspeccionó')
+    // Contra qué reglas se revisó va también a la entrada de DONE, y no sólo al journal: el journal muere
+    // con la corrida y la entrada queda, así que sin esto no había cómo reconstruir contra cuáles se
+    // revisó cuando alguien audita la entrega meses después (caso 122).
     reviewFact = `${review.verdict} por ${cast.review}, sobre ${review.consulted.join(', ')}`
+      + ((review.rules || []).length ? ` · reglas: ${review.rules.join(', ')}` : '')
     // Lo que no impide entregar no manda a tocar código, y tampoco desaparece: la mejora opinable que se
     // corrige a las apuradas cuesta una vuelta y un riesgo que nadie pidió. Va a Propuestas y no a
     // Lecciones porque lo que la revisión anotó es un cambio del producto —su evidencia es la de la

package/engine/hooks/approval.js

@@ -111,9 +111,14 @@ function HOW(variable, lines, input, pasteable = lines) {
       + 'sin resolver, y la aprobación compara texto, así que esa línea sólo valdría para un comando escrito '
       + 'igual. Volvé a correrlo con la ruta escrita y el bloqueo va a decir qué pegar. '
     : ''
-  return ask + paste + unresolved
-    + `La variable ${variable}=1 sigue existiendo y apaga el guard para toda la sesión, que es por lo que no `
-    + 'es la vía recomendada.'
+  // Sin variable no se nombra ninguna. Un guard que no tiene apagado por sesión no debería anunciar uno, y
+  // los que estrenan salida angosta con el 117 no lo tienen a propósito: ofrecer el permiso más ancho
+  // cuando alcanza el más angosto es lo que hizo que la variable fuera la vía que quedaba a mano (caso 089).
+  const off = variable
+    ? `La variable ${variable}=1 sigue existiendo y apaga el guard para toda la sesión, que es por lo que no `
+      + 'es la vía recomendada.'
+    : ''
+  return ask + paste + unresolved + off
 }
 
 module.exports = { APPROVAL, lines, read, pending, pendingNow, where, HOW }

package/engine/hooks/chat.js

@@ -44,7 +44,14 @@ function load(session) {
 
 // Nombrar no es pedir: «no toques el .env» nombra el .env. Cuenta la negación que está en la misma frase y
 // antes del nombre; la coma corta, porque «leé el config, no el .env» son dos pedidos.
-const NEGATION = /(?:^|[^\p{L}])(?:no|nunca|jam[aá]s|ni|sin|not|never|don'?t)(?![\p{L}])/iu
+// En inglés la negación se escribe contraída, y de todas se conocía una sola: `don't`. «the tool doesn't
+// read the .env» nombraba el archivo, traía un verbo de la lista y ninguna negación reconocida, así que una
+// frase que **prohíbe** autorizaba (caso 120). Es el error en la dirección peligrosa, al revés que el 109.
+// El auxiliar entra en la alternancia con el apóstrofo opcional, que es lo que `don'?t` ya hacía para uno;
+// `don't` sale de acá —`do` + `n't`—, así que no quedan dos reglas para lo mismo.
+const CONTRACTED = String.raw`(?:do|does|did|is|are|was|were|ca|wo|would|should)n'?t`
+const NEGATION = new RegExp(
+  String.raw`(?:^|[^\p{L}])(?:no|nunca|jam[aá]s|ni|sin|not|never|${CONTRACTED})(?![\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|$)/

package/engine/hooks/files.js

@@ -76,10 +76,14 @@ function credential(input, raw) {
     : ''
 }
 
+// Escribir una credencial se autoriza igual que leerla. `secrets-read` consulta la aprobación desde 0.80.0
+// y éste frenaba sin ofrecer nada, así que la misma persona podía aprobar leer su `.env` y no podía aprobar
+// escribirlo. La asimetría no la decidió nadie (caso 117).
 function secrets(input) {
   for (const file of filesOf(input)) {
     const reason = credential(input, file)
-    if (reason) block(`${file} ${reason}`)
+    if (!reason || approved(input, file)) continue
+    block(`${file} ${reason}\n${AP.HOW(null, [file], input)}`)
   }
 }
 
@@ -105,9 +109,10 @@ function secretsRead(input) {
 function integrationSnapshot(input) {
   for (const raw of filesOf(input)) {
     const file = raw.replace(/\\/g, '/')
-    if (/(?:^|\/)integrations\/[^/]+\/staging\/(?:.+\/remote\.json|sync-state\.json)$/.test(file)) {
-      block(`${file} pertenece al sincronizador. Cura draft.md; no edites snapshots a mano.`)
-    }
+    if (!/(?:^|\/)integrations\/[^/]+\/staging\/(?:.+\/remote\.json|sync-state\.json)$/.test(file)) continue
+    if (approved(input, raw)) continue
+    block(`${file} pertenece al sincronizador. Cura draft.md; no edites snapshots a mano.\n`
+      + AP.HOW(null, [raw], input))
   }
 }
 
@@ -115,9 +120,10 @@ function generated(input) {
   for (const raw of filesOf(input)) {
     const file = raw.replace(/\\/g, '/')
     const base = path.basename(file)
-    if (/(?:^|[._-])generated\.[^.]+$/i.test(base) || /(?:^|[._-])gen\.(?:go|ts|js|py)$/i.test(base)) {
-      block(`${file} parece código generado. Modifica su fuente y ejecuta el generador; no lo edites a mano.`)
-    }
+    if (!/(?:^|[._-])generated\.[^.]+$/i.test(base) && !/(?:^|[._-])gen\.(?:go|ts|js|py)$/i.test(base)) continue
+    if (approved(input, raw)) continue
+    block(`${file} parece código generado. Modifica su fuente y ejecuta el generador; no lo edites a mano.\n`
+      + AP.HOW(null, [raw], input))
   }
 }
 
@@ -342,6 +348,7 @@ function engineWrites(input) {
   for (const raw of filesOf(input)) {
     const file = path.resolve(cwdOf(input), raw)
     if (file !== pkg && !file.startsWith(`${pkg}${path.sep}`)) continue
+    if (approved(input, raw)) continue
     block(`${raw} pertenece al motor de Cauce, que llega por npm.\n` +
       'Un cambio acá lo borra el próximo install y mientras tanto corrés un motor que no coincide ' +
       'con la versión que declarás. Para traer una versión nueva son dos pasos —el motor y después ' +

package/engine/hooks/shell.js

@@ -13,6 +13,7 @@ const {
   writableRoots, outsideRoots, DECLARE_IT, unquoted, opsRoot, withoutGitGlobals,
 } = require('./input')
 const AP = require('./approval')
+const CHAT = require('./chat')
 const { publish } = require('./push')
 const { selfApprovalShell } = require('./self-approval')
 const EV = require('../core/evidence')
@@ -75,7 +76,7 @@ function destructive(input) {
   }
   publish(input, command)
   const rules = [
-    [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales."],
+    [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales.", true],
     // R8 lo prohíbe sin excepción configurable y ningún guard lo miraba: `grep -rn amend engine/hooks/`
     // no devolvía una línea. Se bloquea por política y no por daño —un `--amend` sobre algo que nadie vio
     // no rompe nada—, así que el mensaje manda a lo que sí corresponde: otro commit.
@@ -83,7 +84,7 @@ function destructive(input) {
       new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s--amend\b`),
       "'git commit --amend' reescribe un commit ya creado. R8 pide uno nuevo en su lugar.",
     ],
-    [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento."],
+    [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento.", true],
     // `git checkout -- .` destruye lo mismo que `reset --hard` y sin recuperación, pero se escribe como
     // una limpieza. Se bloquea sólo la forma ancha —`.`, `*`, `:/`, o sin ruta—: revertir un archivo
     // nombrado es trabajo corriente y no se toca.
@@ -98,14 +99,17 @@ function destructive(input) {
         + String.raw`(?:--(?=\s*(?:${COMANDO}))|(?:--\s+)?(?:\.|\*|:\/)(?=\s*(?:${COMANDO})))`),
       "'git checkout -- .' revierte todo lo no commiteado del directorio, no sólo lo que estás mirando. "
       + 'Nombrá el archivo, o commiteá lo que quieras conservar antes.',
+      true,
     ],
     [
       /\bdocker(?:\s+\w+)*\s+(?:volume\s+(?:rm|prune)|system\s+prune|network\s+prune)\b/,
       'La limpieza global de Docker puede borrar datos compartidos.',
+      true,
     ],
     [
       /\bdocker(?:\s+compose|-compose)\s+(?:\S+\s+)*(?:down|stop|kill|rm)\b/,
       'Detener un stack Compose puede interrumpir servicios compartidos.',
+      true,
     ],
     [
       new RegExp(ANTES + String.raw`(?:mkfs\S*|shred)\s`
@@ -117,7 +121,22 @@ function destructive(input) {
       "'rm -r' sobre /, home o el directorio padre es catastrófico.",
     ],
   ]
-  for (const [pattern, message] of rules) if (pattern.test(command)) block(message)
+  // El tercer elemento dice si la regla tiene salida. Las que no la tienen son las que una persona tampoco
+  // debería poder abrir pidiéndolo: `--amend` y el force-push de arriba, que R8 prohíbe sin excepción
+  // configurable; el borrado de disco; y `rm -r` sobre raíz, home o el padre, que es la clase que gobierna
+  // R23. El resto no tenía salida por omisión y no por decisión: son anteriores al canal de chat de 0.81.0
+  // —por qué ese canal existe y qué distingue, en `chat.js`— y nadie volvió a pasarles por encima (117).
+  //
+  // El ítem que se aprueba es el comando entero tal como llegó, no el pedazo que matcheó: `git clean -f`
+  // no aparece entero dentro de «corré git clean -fd», así que aprobar el fragmento no destrabaría lo que
+  // la persona escribió. Entero es además lo que ella pegaría en el archivo, y lo más angosto: cualquier
+  // otra bandera es otro comando y vuelve a preguntarse.
+  for (const [pattern, message, open] of rules) {
+    if (!pattern.test(command)) continue
+    const item = String(raw).trim()
+    if (open && !AP.pending(opsRoot(input), [item], input).length) continue
+    block(open ? `${message}\n${AP.HOW(null, [item], input)}` : message)
+  }
 }
 
 function gitAdd(input) {
@@ -328,6 +347,16 @@ function governance(input) {
   if (process.env.OPS_GOVERNANCE_OVERRIDE === '1') return
   const command = commandOf(input)
   if (!isCommit(command)) return
+  // Con una persona conduciendo el turno, este guard no pregunta nada. Frena por **política** —qué archivos
+  // toca un commit— y no por un defecto de hecho, y esa pregunta a quien está dando instrucciones no le
+  // corresponde: lo que el guard contiene es al agente decidiendo solo (caso 126). `said` ya distingue las
+  // dos cosas —devuelve nada para un subagente, para un recorrido de Cauce y en CI—, así que la exención no
+  // alcanza a nada de eso. Es la misma forma que usa `plan-first` en `files.js`.
+  //
+  // Sus dos vecinos de gate no llevan esta exención y la diferencia no es quién pidió el commit: `verify` y
+  // `dependencies` frenan por algo que está mal —una verificación que falla, un manifiesto sin su lockfile—
+  // y callarlos porque hay alguien hablando sería tapar un rojo.
+  if (CHAT.said(input)) return
   // El contrato de un cargo y lo que lo mide son gobernanza, igual que un ADR o una regla. La firma de
   // «Aprobación humana» sólo estaba protegida por una frase en un prompt; `SKILL.md` y `references/`
   // son lo que la propuesta cambia, y editarlos directo saltea el ciclo entero; y `evaluations/` es el

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.83.0",
+  "version": "0.85.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",