@ingeniomaps/cauce 0.84.0 → 0.86.0

package/CHANGELOG.md

@@ -14,6 +14,98 @@ 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.86.0] - 2026-09-12
+
+### Corregido
+
+- **Tu guard propio ya no se pierde al actualizar una instancia vieja.** Si tu instancia es anterior al
+  registro de entregas —no tiene `.cauce/manifest.json`— y tenés un guard tuyo con un nombre que el paquete
+  hoy trae, `upgrade` lo reemplazaba sin nombrarlo, salía con 0 y después lo anotaba como entregado por
+  Cauce. Los tres pasos juntos hacían la pérdida silenciosa **e** irrecuperable: para cuando la notabas, el
+  registro decía que ese archivo siempre había sido nuestro. Y la última línea de la corrida afirmaba lo
+  contrario de lo que había pasado — «planning, organization y todo lo propio quedaron intactos».
+
+  Ahora, sin registro para esa ruta, la duda se resuelve del lado del que se vuelve: el archivo se conserva,
+  `upgrade` lo nombra y `upgrade --check` sale con 1 **antes** de tocar nada. Si el que querés es el del
+  paquete, `--force` lo reemplaza diciéndolo, como ya hacía.
+
+### Agregado
+
+- **`check` te avisa de una fila de `HUMAN_ACTIONS.md` que figura resuelta y que ningún commit registró.**
+  Una decisión que nadie dejó escrita es una aprobación autoservida, y la puerta barata no la miraba: el
+  recorrido la rechazaba recién en Ready, con Triage, Pick, Claim y Decompose ya pagados. En la corrida que
+  lo destapó fueron tres paradas y 1,21 M de tokens, con `check` en verde las tres veces.
+
+  Avisa, no falla —rechazar enunciados por heurística frenaría trabajo legítimo— y **se calla cuando no hay
+  con qué contestar**: sin repositorio, o con el archivo todavía sin commitear, no dice nada.
+
+- **`check` muestra lo que autorizaste en el chat y sigue vigente.** Desde 0.83.0, lo que un guard te deja
+  pasar queda concedido para el resto de la sesión, así no te vuelve a preguntar lo mismo en cada mensaje.
+  Eso está bien, y no se veía en ninguna parte: por una línea olvidada en `planning/.ops-approval` `check` te
+  avisaba, y por una concesión que vale toda la sesión no decía nada. Ahora lista las dos. Lo que concediste
+  trabajando en otra instancia no se le cuenta a ésta.
+
+- **Podés acotar una concesión diciendo hasta cuándo vale, y Cauce te hace caso.** Si al autorizar algo
+  escribís «mientras dure la tarea t-014», esa concesión deja de valer en cuanto esa tarea ya no sea la de
+  tu WIP, en vez de durar toda la sesión. Ya lo escribías y se perdía: de esa frase sobrevivía la ruta y el
+  acote se tiraba.
+
+  Hace falta la palabra `tarea` o `task` —«mientras dure la tarea t-014», «only for task t-014»—, porque sin
+  ella no hay contra qué comparar. Lo que no se reconoce no se pierde: vale lo de antes, la sesión entera.
+
+- **Lo que concedés en el chat deja un rastro local en `planning/.grant-log`.** Una línea por concesión, con
+  la fecha, el alcance, la vía y la sesión; **no guarda lo que escribiste**. Es el mismo molde que
+  `planning/.push-log`: sólo agrega, y sirve para contestar meses después quién autorizó qué.
+
+  **Si tu instancia ya existía, agregale a mano esta línea a tu `.gitignore`:** `planning/.grant-log`.
+  `upgrade` no puede tocar ese archivo porque es tuyo, así que la línea sólo llega a las instancias nuevas;
+  sin ella, el rastro te va a aparecer en `git status`. Es lo mismo que pasó con `planning/.push-log`.
+
+- **`check` te avisa si git no está ignorando los rastros locales de Cauce.** Son tres —
+  `planning/.verify-log`, `planning/.push-log` y `planning/.grant-log`— y no deben viajar: son evidencia de
+  una corrida tuya, de tu máquina. La línea que los cubre la trae el `.gitignore` que se escribe **al crear**
+  la instancia, y `upgrade` no lo toca porque ese archivo es tuyo y puede tener líneas propias. Así que una
+  instancia anterior a cada rastro nuevo se quedaba sin su línea para siempre y el archivo aparecía en
+  `git status` listo para commitearse.
+
+  Ahora `check` lo dice y nombra las rutas, que es lo que hay que pegar. Pregunta si git **los ignora**, no
+  si la línea está escrita: si ya los cubrís con una regla propia, no te molesta. Sin repositorio se calla.
+
+  **Si tu instancia ya existía, pegá estas tres líneas en tu `.gitignore`** — o dejá que `check` te diga
+  cuáles te faltan:
+
+  ```
+  planning/.verify-log
+  planning/.push-log
+  planning/.grant-log
+  ```
+
+### Cambiado
+
+- **La guía dejó de pedirle al agente que borre una autorización que no escribió él.** `AGENTS.md` decía que
+  «borrarla es parte de terminar» sin distinguir la línea que el agente pidió para una operación de la que
+  dejaste puesta vos a propósito. Ahora sólo se borra la primera.
+
+## [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

package/engine/cli/planning.js

@@ -20,6 +20,7 @@ const AP = require('../hooks/approval')
 const I = require('../integrations/registry')
 const O = require('../core/ownership')
 const EV = require('../core/evidence')
+const TR = require('../core/trails')
 const OB = require('../core/onboarding')
 const C = require('../config/validate')
 const CP = require('../config/paths')
@@ -175,14 +176,9 @@ function check(dir, cli) {
   warnings.push(...RC.warnings(RC.status({ ...recurring, done, today: TODAY() })))
   warnings.push(...IB.warnings(root, done, config))
   warnings.push(...AD.sealWarnings(root))
-  // Una aprobación vale para el conjunto que nombra, así que olvidada sigue autorizando
-  // esas mismas rutas la próxima vez que alguien las stagee. No caduca sola: lo que la cierra es que se
-  // vea en cada corrida y alguien la borre.
-  const aprobadas = AP.read(path.resolve(root, '..'))
-  if (aprobadas.length) {
-    warnings.push(`planning/${AP.APPROVAL}: ${aprobadas.length} ruta(s) aprobadas y sin borrar; `
-      + 'el archivo sigue autorizándolas')
-  }
+  warnings.push(...R.unrecordedHumanActions(path.resolve(root, '..'), P.readHumanActions(root)))
+  warnings.push(...AP.warnings(path.resolve(root, '..')))
+  warnings.push(...TR.warnings(path.resolve(root, '..')))
 
   // Lo que `upgrade` conserva por estar editado deja de recibir mejoras, y eso es una deuda que no
   // avisa sola: la instancia queda con medio molde viejo y todo se ve normal. Sale acá para que se vea

package/engine/core/evidence.js

@@ -20,7 +20,7 @@
 const fs = require('node:fs')
 const path = require('node:path')
 
-const LOG = path.join('planning', '.verify-log')
+const LOG = require('./trails').VERIFY
 // Rodante: interesa el trabajo en curso, no la historia. Sin tope, el archivo crece con cada commit y
 // nadie lo mira; con tope, lo que queda es lo que todavía se puede cruzar contra una entrada abierta.
 const MAX_RUNS = 20

package/engine/core/ownership.js

@@ -352,14 +352,18 @@ function deliveredFiles(root, relative) {
 
 // Lo que el paquete empieza a traer con un nombre que la instancia ya usaba para algo suyo: un guard propio
 // que se llama como uno nuevo del toolkit (caso 110). Sin huella en el registro no cuenta como edición, así
-// que copiar encima lo borraba sin decirlo. Sólo si el registro ya conoce la ruta: en una instancia
-// anterior al registro, «sin huella» también es «lo entregó una versión vieja».
+// que copiar encima lo borraba sin decirlo.
+//
+// Sin registro para esa ruta la duda no se puede resolver —«sin huella» es tanto «es mío» como «lo entregó
+// una versión vieja»—, así que se elige el lado del que se vuelve: se conserva y se avisa. Mirar sólo las
+// instancias que ya tenían registro dejaba afuera justo a la que más perdía, la anterior al mecanismo, donde
+// el primer `upgrade` pisaba el guard propio sin nombrarlo y después lo registraba como entregado por Cauce
+// (caso 125). Equivocarse ahora cuesta un aviso de más; antes costaba un archivo que no vuelve.
 function collisions(root) {
   const manifest = require('./manifest')
   const recorded = manifest.read(root)
   const found = []
   for (const relative of RUNTIME_PATHS) {
-    if (!Object.keys(recorded).some((key) => key.startsWith(`${relative}/`))) continue
     for (const file of shippedFiles(relative)) {
       const local = path.join(root, relative, file)
       if (recorded[`${relative}/${file}`] || !fs.existsSync(local)) continue

package/engine/core/repos.js

@@ -119,4 +119,32 @@ function coverageWarnings(opsRoot, done) {
   return warnings
 }
 
-module.exports = { reposFor, repoOf, lastCommit, coverageWarnings }
+// La fila de `HUMAN_ACTIONS.md` que figura resuelta sin que ningún commit la haya tocado. Ready la rechaza
+// —una decisión que nadie dejó escrita es una aprobación autoservida— y `check` no la miraba, así que el
+// defecto se descubría en la fase 4 de un recorrido: 1,21 M de tokens en tres paradas, con la puerta en
+// verde las tres veces (caso 121).
+//
+// Se pregunta con el pickaxe sobre la línea entera y no por la palabra `resuelta`: lo que hay que
+// establecer es que **esa** fila, con ese estado, existió alguna vez en un commit. Una que pasó a resuelta
+// sólo en el árbol de trabajo no aparece en ninguno.
+//
+// Sin repositorio, o con el archivo todavía sin commitear, no dice nada: no hay historia contra la cual
+// preguntar y el aviso sería inventado. Degrada como el 086 con las migraciones — antes callar de más que
+// avisar de más, porque un aviso que salta siempre se termina apagando.
+function unrecordedHumanActions(opsRoot, rows) {
+  const file = path.join(opsRoot, 'planning', 'HUMAN_ACTIONS.md')
+  const top = git(path.dirname(file), 'rev-parse', '--show-toplevel')
+  if (top.status !== 0) return []
+  const repo = top.stdout.trim()
+  const relative = path.relative(repo, file)
+  const history = git(repo, 'log', '--format=%h', '--', relative)
+  if (history.status !== 0 || !history.stdout.trim()) return []
+  return rows.filter((row) => row.resolved)
+    .filter((row) => {
+      const found = git(repo, 'log', '--format=%h', `-S${row.raw}`, '--', relative)
+      return found.status === 0 && !found.stdout.trim()
+    })
+    .map((row) => `HUMAN_ACTIONS.md: ${row.task} figura resuelta y ningún commit la registró`)
+}
+
+module.exports = { reposFor, repoOf, lastCommit, coverageWarnings, unrecordedHumanActions }

package/engine/core/trails.js

@@ -0,0 +1,52 @@
+'use strict'
+
+// Los rastros que Cauce escribe **dentro** de la instancia y que no viajan: son evidencia de una corrida
+// local, de la máquina donde ocurrió, y committearlos sería historia que nadie lee y un conflicto por
+// commit. Cada uno nace con su razón escrita en `template/gitignore`, al lado de su línea.
+//
+// Viven declarados acá y no en el módulo que escribe cada uno porque son tres —`verify`, `push` y el
+// chat— y hacían falta en un cuarto lugar: el aviso de abajo. Escribir la lista ahí habría dejado una
+// cuarta copia de la misma ruta, que es la que se pudre cuando alguien renombra un archivo (caso 128).
+const VERIFY = 'planning/.verify-log'
+const PUSH = 'planning/.push-log'
+const GRANT = 'planning/.grant-log'
+
+const LOCAL = [VERIFY, PUSH, GRANT]
+
+const { spawnSync } = require('node:child_process')
+
+// Cuáles de esos rastros **git no está ignorando** en esta instancia.
+//
+// La línea que los cubre la trae `template/gitignore`, y ese archivo se escribe al **crear** la
+// instancia: `upgrade` no lo toca, porque es de la empresa y puede llevar líneas propias que un
+// reemplazo se llevaría puestas. Así que una instancia anterior a cada rastro nuevo se queda sin su
+// línea para siempre, y el archivo aparece en `git status` listo para commitearse por descuido.
+//
+// Se pregunta por el **efecto** y no por el texto del molde, y la diferencia importa en los dos
+// sentidos: la empresa puede cubrirlo con una regla propia —y comparar líneas daría un falso positivo—,
+// y en sidecar el `.gitignore` vive en la instancia mientras el repositorio es el workspace de arriba.
+// Medido en las dos topologías: `check-ignore` contesta igual.
+//
+// Sin repositorio no hay a quién preguntarle —`check-ignore` sale 128— y ahí se calla: un aviso sobre
+// lo que git haría en un repositorio que no existe sería inventado. Es la misma degradación que el 086
+// eligió para las migraciones y el 121 para las filas resueltas: antes callar de más que avisar de más.
+function unignored(root) {
+  const asked = spawnSync('git', ['check-ignore', '--', ...LOCAL], { cwd: root, encoding: 'utf8' })
+  // 0 = ignoró alguno, 1 = ninguno de los que preguntó; cualquier otro código es que no hay repositorio
+  // o que git no pudo contestar, y entonces no hay nada que reportar.
+  if (asked.status !== 0 && asked.status !== 1) return []
+  const covered = new Set(asked.stdout.split('\n').map((one) => one.trim()).filter(Boolean))
+  return LOCAL.filter((one) => !covered.has(one))
+}
+
+// El aviso, en la forma que `check` publica el resto: cuenta, nombra y no falla. Lleva las rutas porque
+// son exactamente lo que hay que pegar, que es lo único accionable — el archivo es de la empresa y Cauce
+// no lo edita.
+function warnings(root) {
+  const missing = unignored(root)
+  if (!missing.length) return []
+  return [`${missing.length} rastro(s) local(es) que git no ignora (${missing.join(', ')}); `
+    + 'agregá esas líneas a tu .gitignore o van a entrar al repositorio']
+}
+
+module.exports = { VERIFY, PUSH, GRANT, warnings }

package/engine/hooks/approval.js

@@ -121,4 +121,26 @@ function HOW(variable, lines, input, pasteable = lines) {
   return ask + paste + unresolved + off
 }
 
-module.exports = { APPROVAL, lines, read, pending, pendingNow, where, HOW }
+// Las dos exenciones que sobreviven a un bloqueo, para que `check` las muestre juntas: la lista que una
+// persona escribió a mano, y lo que la sesión fue concediendo sola a medida que los guards dejaban pasar.
+// Ninguna de las dos caduca por su cuenta, así que lo único que las cierra es verlas en cada corrida.
+//
+// La segunda no se veía en ninguna parte hasta 0.86.0. El 116 la trajo para que la persona no tuviera que
+// repetir la autorización en cada mensaje —y eso está bien—, pero quedó del lado que nadie audita: vive en
+// el temporal del sistema, mientras que por una sola línea del archivo `check` sí avisaba. Una exención que
+// no se ve es un límite que ya no existe (caso 117).
+function warnings(root) {
+  const out = []
+  const approved = read(root)
+  if (approved.length) {
+    out.push(`planning/${APPROVAL}: ${approved.length} ruta(s) aprobadas y sin borrar; `
+      + 'el archivo sigue autorizándolas')
+  }
+  const granted = CHAT.grantedIn(root)
+  if (granted.length) {
+    out.push(`${granted.length} ruta(s) concedidas en el chat de esta sesión: ${granted.join(', ')}`)
+  }
+  return out
+}
+
+module.exports = { APPROVAL, lines, read, pending, pendingNow, where, HOW, warnings }

package/engine/hooks/chat.js

@@ -16,6 +16,14 @@
 const fs = require('node:fs')
 const os = require('node:os')
 const path = require('node:path')
+const { opsRoot } = require('./input')
+const { readWip } = require('../planning/parser')
+const { runner } = require('../planning/claims')
+const TRAIL = require('./trail')
+
+// Dónde queda anotado lo que se concedió. Cómo se escribe un rastro, en `trail.js`; por qué éste no
+// viaja y quién más lo declara, en `core/trails.js`.
+const LOG = require('../core/trails').GRANT
 
 // 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.
@@ -80,6 +88,16 @@ const ASKS = new Set(('lee leer abri abre abrir mostra muestra mostrar ensena ed
   + 'authorize authorized allow allowed permit permitted grant granted approved').split(' '))
 const ENCLITIC = /(?:selo|sela|melo|mela|telo|tela|los|las|lo|la|le|me)$/
 
+// El alcance que la persona ya escribe al conceder: «escribí X mientras dure la tarea t-014». Medido, de
+// esa frase sobrevivía la ruta y el acote se tiraba, así que la concesión valía la sesión entera aunque
+// alguien hubiera dicho hasta cuándo (caso 127).
+//
+// Exige la palabra `tarea` o `task` a propósito. Sin ella —«mientras dure esto», «for now»— no hay contra
+// qué comparar, y adivinar un alcance que nadie nombró concede de menos por una lectura propia. La lista
+// es corta por lo mismo que la de verbos: lo que no se reconoce no se pierde, vale lo de antes.
+const SCOPE = new RegExp(String.raw`(?:mientras dure|mientras siga|durante|s[oó]lo para|solo para|only for)`
+  + String.raw`\s+(?:la\s+|the\s+)?(?:tarea|task)\s+([\p{L}\p{N}][\p{L}\p{N}._-]*)`, 'iu')
+
 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, '')))
@@ -98,10 +116,22 @@ function mentions(text, item) {
       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]}`) })
+      const frase = `${clause} ${rest.split(CLAUSE)[0]}`
+      found.push({
+        denied: NEGATION.test(clause),
+        asked: asks(frase),
+        // El alcance se lee de la misma frase que decide si la ruta fue pedida, y no del mensaje entero:
+        // un «mientras dure la tarea t-014» que hable de otra cosa, en otra oración, no acota a ésta.
+        scope: (frase.match(SCOPE) || [])[1] || '',
+      })
     }
   }
-  return { named: found.some((one) => one.asked && !one.denied), denied: found.some((one) => one.denied) }
+  const pedidas = found.filter((one) => one.asked && !one.denied)
+  return {
+    named: pedidas.length > 0,
+    denied: found.some((one) => one.denied),
+    scope: (pedidas.find((one) => one.scope) || {}).scope || '',
+  }
 }
 
 // Una orden de publicar se lee aparte, porque `mentions` compara también el basename: para el ítem
@@ -149,9 +179,16 @@ function record(input) {
       ? previous.pending.filter((item) => !mentions(text, item).denied)
       : []
     const granted = previous ? (previous.granted || []).filter((one) => !mentions(text, one).denied) : []
+    // El acote viaja con lo concedido: lo que se negó pierde las dos cosas a la vez, y nada queda con un
+    // alcance que ya no acota a nadie.
+    const scopes = {}
+    for (const one of granted) if (previous.scopes && previous.scopes[one]) scopes[one] = previous.scopes[one]
     fs.mkdirSync(DIR, { recursive: true })
+    // Sobre qué instancia se está hablando, que es lo que después deja filtrar lo concedido: por qué hace
+    // falta, en `grantedIn`.
     fs.writeFileSync(recordPath(input.session_id), JSON.stringify(
-      { id: idOf(input), text, human, flow: flowCommand(text), approved, granted, pending: [] }))
+      { id: idOf(input), text, human, flow: flowCommand(text), root: opsRoot(input), approved, granted,
+        scopes, pending: [] }))
   } catch { /* registrar es un extra: si falla, los guards siguen frenando lo que frenaban */ }
 }
 
@@ -170,11 +207,35 @@ function said(input) {
 // había quedado frenado, o se lo concedieron antes en esta sesión. Qué cuenta como pedirlo depende de qué
 // se frena: un archivo se nombra, un push se ordena con su remoto y su rama.
 const named = (text, item) => mentions(text, item).named
+
+// Si el acote que la persona puso sigue en pie. Sin alcance no hay nada que comprobar y vale lo de
+// siempre —la sesión—, que es lo que decidió el 116; con alcance, vale mientras esa tarea sea la del WIP,
+// y `readWip` devuelve nada con el WIP en IDLE, así que «se cerró» se lee sin mecanismo nuevo.
+//
+// El orden importa y es el mismo que toma `files.js` con el plan: primero lo barato. Una concesión sin
+// alcance —el caso común— no paga ninguna lectura del planning.
+//
+// Sin WIP legible el alcance venció, y son el mismo caso tres cosas que parecen distintas: el WIP en
+// IDLE, el archivo que no está y el `planning` que no se puede leer. `readWip` las devuelve todas como
+// nada —su lectura traga el error—, así que acá no hay ninguna rama de excepción que atender, y vencer es
+// la dirección de la que se vuelve: quien lo necesite lo vuelve a pedir.
+//
+// Sin instancia resoluble no hay WIP contra el cual comparar, y eso no es lo mismo: el alcance se respeta,
+// porque revocar ahí sería castigar a quien trabaja fuera de una instancia por algo que no dijo.
+function scopeAlive(saved, item) {
+  const scope = (saved.scopes || {})[item]
+  if (!scope) return true
+  if (!saved.root) return true
+  const wip = readWip(path.join(saved.root, 'planning'), runner())
+  return Boolean(wip && String(wip.task).toLowerCase() === String(scope).toLowerCase())
+}
+
 function why(saved, item, asked, inherit) {
   if (asked(saved.text, item)) return 'orden'
   if (saved.approved.includes(item)) return 'dale'
   if (!inherit) return ''
-  return (saved.granted || []).includes(item) ? 'concedido' : ''
+  if (!(saved.granted || []).includes(item)) return ''
+  return scopeAlive(saved, item) ? 'concedido' : ''
 }
 
 // Lo que un guard dejó pasar queda anotado, que es la contracara de `hold`: hasta 0.82.0 sólo se anotaba
@@ -185,14 +246,22 @@ function why(saved, item, asked, inherit) {
 // Se anota el ítem **como el guard lo nombró** —la ruta en la forma que ese guard tiene a mano— y no el
 // archivo que hay detrás: es el mismo alcance que tiene una línea de `.ops-approval`, angosto de más
 // antes que de menos.
-function grant(input, saved, items) {
+function grant(input, saved, entries) {
   const before = saved.granted || []
-  const granted = [...new Set([...before, ...items])]
-  if (granted.length === before.length) return
+  const nuevas = entries.filter((one) => !before.includes(one.item))
+  if (!nuevas.length) return
+  const grantedAt = new Date().toISOString()
   try {
-    saved.granted = granted
+    saved.granted = [...before, ...nuevas.map((one) => one.item)]
+    saved.scopes = { ...(saved.scopes || {}) }
+    for (const one of nuevas) if (one.scope) saved.scopes[one.item] = one.scope
     fs.writeFileSync(recordPath(input.session_id), JSON.stringify(saved))
   } catch { /* sin anotarlo, se vuelve a pedir */ }
+  // Y queda el rastro, que es lo que el registro de la sesión no puede dar: muere con ella, y lo que una
+  // auditoría pregunta es quién concedió qué y con qué alcance, meses después (caso 127).
+  TRAIL.append(saved.root, LOG, nuevas.map((one) => ({
+    grantedAt, item: one.item, scope: one.scope || null, via: one.via, session: input.session_id || null,
+  })))
 }
 
 // Con qué autorización pasa cada uno de los que pasan. Lo pregunta quien necesita el porqué y no sólo el
@@ -213,9 +282,15 @@ function authorized(input, items, { asked = named, inherit = true } = {}) {
 function unauthorized(input, items) {
   const saved = said(input)
   if (!saved) return items
-  const passed = items.filter((item) => why(saved, item, named, true))
-  grant(input, saved, passed)
-  return items.filter((item) => !passed.includes(item))
+  const passed = items.map((item) => ({ item, via: why(saved, item, named, true) })).filter((one) => one.via)
+  // El alcance sale del mensaje cuando es éste el que lo concede, y del registro cuando se hereda: una
+  // orden vieja no se reinterpreta contra un texto que no la nombraba.
+  grant(input, saved, passed.map((one) => ({
+    ...one,
+    scope: one.via === 'orden' ? mentions(saved.text, one.item).scope : (saved.scopes || {})[one.item] || '',
+  })))
+  const cleared = new Set(passed.map((one) => one.item))
+  return items.filter((item) => !cleared.has(item))
 }
 
 // Lo mismo sin conceder y sin heredar: lo que no está en el mensaje en curso queda pendiente aunque la
@@ -237,4 +312,24 @@ function hold(input, items) {
   } catch { return false }
 }
 
-module.exports = { DIR, record, said, authorized, unauthorized, unauthorizedNow, hold, ordersPush }
+// Lo que quedó concedido en esta máquina para una instancia, para que `check` pueda mostrarlo. Se filtra
+// por la raíz que anotó el mensaje: el directorio es uno solo por máquina, así que sin filtrar una
+// instancia reportaría las exenciones de la de al lado, que es peor que no reportar ninguna.
+//
+// Un registro anterior a que la raíz se anotara no trae el campo y queda afuera, igual que uno escrito
+// fuera de toda instancia —ahí `opsRoot` devuelve vacío—: decir «concedido» sin saber dónde es exactamente
+// lo que este filtro existe para evitar (caso 117).
+function grantedIn(root) {
+  let names = []
+  try { names = fs.readdirSync(DIR) } catch { return [] }
+  const found = new Set()
+  for (const name of names) {
+    let saved = null
+    try { saved = JSON.parse(fs.readFileSync(path.join(DIR, name), 'utf8')) } catch { continue }
+    if (!saved || !saved.root || saved.root !== root) continue
+    for (const one of saved.granted || []) found.add(one)
+  }
+  return [...found].sort()
+}
+
+module.exports = { DIR, record, said, authorized, unauthorized, unauthorizedNow, hold, ordersPush, grantedIn }

package/engine/hooks/push.js

@@ -19,12 +19,11 @@
 //
 // 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')
+const TRAIL = require('./trail')
 
 // 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.
@@ -130,28 +129,16 @@ function workMessage(items, input) {
 // 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).
+// (caso 112). Qué garantiza el archivo —que sólo agrega, que no frena si falla— está en `trail.js`.
 //
-// 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')
+// Acá se decide una sola cosa, y es del push: 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 = require('../core/trails').PUSH
 
 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 */ }
+  const authorizedAt = new Date().toISOString()
+  TRAIL.append(root, LOG, entries.map((one) => ({ authorizedAt, ...one, session: session || null })))
 }
 
 // Un destino en la forma en que se anota. Sin remoto ni rama resolubles va `null`, que es exactamente lo

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')
@@ -346,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/engine/hooks/trail.js

@@ -0,0 +1,34 @@
+'use strict'
+
+// El rastro local de una autorización: una línea JSON por cosa que pasó porque alguien la autorizó.
+//
+// **Sólo agrega**, a diferencia de un registro rodante como el de gates: lo que una auditoría pregunta es
+// justamente la entrada vieja.
+//
+// **No frena nada si no se puede escribir.** Lo que se anota ya fue autorizado antes de llegar acá, así
+// que un registro que falla no puede convertirse en un bloqueo: sería negar por no haber podido contar.
+//
+// **El texto de la persona no entra**, y eso lo decide quien arma las entradas: 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 lo dejó.
+//
+// Vive en su propio módulo y no dentro del guard que lo usa porque lo escriben dos —el push que se
+// autorizó (caso 112) y la concesión del chat (caso 127)— y `chat.js` **no puede importar a `push.js`**:
+// `push.js` ya lo importa a él, así que el require sería circular. Escrito dos veces, una de las dos
+// copias se pudre sin que nada falle.
+//
+// Las entradas llegan armadas y no se tocan acá: cada rastro nombra sus campos como corresponde a lo que
+// anota —`authorizedAt` no es `grantedAt`— y el orden de las claves es parte de lo que sus pruebas fijan.
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+function append(root, relative, entries) {
+  if (!root || !entries.length) return
+  try {
+    const file = path.join(root, relative)
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.appendFileSync(file, `${entries.map((one) => JSON.stringify(one)).join('\n')}\n`)
+  } catch { /* lo anotado ya estaba autorizado: no lo frena un registro que no se pudo escribir */ }
+}
+
+module.exports = { append }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.84.0",
+  "version": "0.86.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",
@@ -34,8 +34,7 @@
     "coverage": "bash test/tools/coverage.sh",
     "coverage:update": "bash test/tools/coverage.sh --update",
     "dead-code": "node test/tools/dead-code.js",
-    "dead-code:engine": "node test/tools/dead-code.js --engine",
-    "ci": "npm run check && npm run automation:check && npm run integration:check && npm run dead-code:engine && npm run coverage",
+    "ci": "npm run check && npm run automation:check && npm run integration:check && npm run dead-code && npm run coverage",
     "prepublishOnly": "npm run ci"
   },
   "engines": {

package/template/AGENTS.md

@@ -136,7 +136,8 @@ caduca, deja de coincidir. En la última fila es más visible —aprobás el ín
 una cosa más la invalida—, y es a propósito: commitear en rojo se autoriza para un commit concreto.
 
 No se borra sola, así que un commit frenado por otra cosa no te obliga a rehacerla. `check` te avisa
-mientras exista, y borrarla es parte de terminar.
+mientras exista, y borrar **la línea que pediste para una operación ya terminada** es parte de terminar.
+La que dejaste puesta vos no se toca: el agente no borra una autorización que no escribió él.
 
 **Publicar un paquete o instalar algo global no se aprueba así**, porque ahí no hay ninguna ruta sobre
 la cual decidir. Esa sigue siendo una acción humana y su única llave es la variable de abajo.

package/template/gitignore

@@ -14,6 +14,10 @@ planning/.verify-log
 # la sesión que publicó.
 planning/.push-log
 
+# El rastro de lo que se concedió en el chat, por lo mismo que el de arriba: una concesión se consume sin
+# dejar nada, y quién la dio y con qué alcance se pregunta en la máquina donde ocurrió la conversación.
+planning/.grant-log
+
 # El plan de cada runner. Es de la máquina que lo corre —existe para recuperar una ejecución
 # interrumpida, y nadie más puede retomarla— y cambia en cada paso, así que compartirlo es un conflicto
 # por commit a cambio de nada. Lo que el equipo sí necesita saber vive en `planning/claims/`.