@ingeniomaps/cauce 0.98.0 → 0.99.1

package/engine/hooks/chat.js

@@ -126,11 +126,11 @@ function mentions(text, item) {
       })
     }
   }
-  const pedidas = found.filter((one) => one.asked && !one.denied)
+  const asked = found.filter((one) => one.asked && !one.denied)
   return {
-    named: pedidas.length > 0,
+    named: asked.length > 0,
     denied: found.some((one) => one.denied),
-    scope: (pedidas.find((one) => one.scope) || {}).scope || '',
+    scope: (asked.find((one) => one.scope) || {}).scope || '',
   }
 }
 
@@ -139,7 +139,16 @@ function mentions(text, item) {
 // el remoto y la rama tienen que aparecer tal cual, como palabras enteras, en una frase que pida publicar
 // —un verbo de publicar, no cualquiera: «revisá feat/x en origin» no pide un push— y sin una negación
 // antes del último de los dos.
-const PUSHES = new Set('subi sube subir pushea pushear push publica publicar publish empuja empujar'.split(' '))
+// Con las formas de una prohibición —«no subas», «no publiques»—, que es como se niega un push.
+const PUSHES = new Set(('subi sube subir subas pushea pushear pushees push publica publicar publiques publish '
+  + 'empuja empujar empujes').split(' '))
+const pushVerb = (clause) => (clause.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+  .match(/[a-z]+/g) || []).some((word) => PUSHES.has(word) || PUSHES.has(word.replace(ENCLITIC, '')))
+
+// Un push no se nombra como un archivo: «no hagas push todavía» lo prohíbe sin decir remoto ni rama. Basta una
+// cláusula con un verbo de publicar y una negación.
+const refusesPush = (text) => String(text).split(CLAUSE)
+  .some((clause) => pushVerb(clause) && NEGATION.test(clause))
 function ordersPush(text, item) {
   const [verb, remote, branch] = item.split(' ')
   if (verb !== 'push' || !remote || !branch) return false
@@ -150,10 +159,7 @@ function ordersPush(text, item) {
       .map((word) => word.replace(/^'+/, '').replace(/\.$/, '').replace(/'+$/, ''))
     const last = Math.max(words.indexOf(remote), words.indexOf(branch))
     if (words.indexOf(remote) < 0 || words.indexOf(branch) < 0) return false
-    const plain = clause.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '')
-      .match(/[a-z]+/g) || []
-    return plain.some((word) => PUSHES.has(word) || PUSHES.has(word.replace(ENCLITIC, '')))
-      && !NEGATION.test(words.slice(0, last + 1).join(' '))
+    return pushVerb(clause) && !NEGATION.test(words.slice(0, last + 1).join(' '))
   })
 }
 
@@ -180,9 +186,16 @@ function record(input) {
     const text = String(input.prompt || '')
     const human = !process.env.CI && !/^\s*</.test(text)
     const previous = load(input.session_id)
-    const approved = human && previous && !refuses(text)
+    // Lanzar un recorrido no es contestar el bloqueo: para la sesión principal ya no valía —`said` descarta un
+    // mensaje `flow`—, pero lo aprobado sí les llegaba a los subagentes del recorrido (`confirmed`), así que
+    // escribir `/autobuild` aprobaba lo que estaba esperando una respuesta.
+    const answered = human && previous && !refuses(text) && !flowCommand(text)
       ? previous.pending.filter((item) => !mentions(text, item).denied)
       : []
+    // Lo que ella confirmó también sobrevive al aviso, porque quien lo usa puede ser un subagente que
+    // reintenta mientras ella no escribe nada (caso 186). A la sesión principal no le cambia nada: su
+    // lectura, `said`, exige un mensaje de la persona.
+    const approved = human || !previous ? answered : previous.approved || []
     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.
@@ -196,12 +209,20 @@ function record(input) {
     // ya era cierto. Lo vuelve a decidir el mensaje humano siguiente (caso 166).
     const flow = flowCommand(text)
     const askable = human ? !flow : Boolean(previous && previous.askable)
+    // Con la persona se arrastra también lo que dijo y lo que quedó esperando su respuesta. `hold` lee su
+    // negación en `spoken` y no en `text`, que en un aviso es la etiqueta del runner: sin esto, su «no
+    // toques el .env» dejaba de retener lo que se frenaba después del aviso, y el «seguí» siguiente lo
+    // aprobaba (caso 191). Y lo frenado en su turno sigue pendiente aunque el aviso llegue antes que ella.
+    // Un registro de antes de 0.99.0 no trae `spoken`: si lo escribió la persona, lo que dijo es su `text`.
+    const last = previous ? previous.spoken ?? (previous.human ? previous.text : '') : ''
+    const spoken = human ? text : String(last || '')
+    const pending = human || !previous ? [] : previous.pending
     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, askable, flow, root: opsRoot(input), approved, granted,
-        scopes, pending: [] }))
+      { id: idOf(input), text, spoken, human, askable, flow, root: opsRoot(input), approved, granted,
+        scopes, pending }))
   } catch { /* registrar es un extra: si falla, los guards siguen frenando lo que frenaban */ }
 }
 
@@ -224,8 +245,12 @@ function said(input) {
 //
 // Un registro escrito antes de que `askable` existiera no lo trae y queda afuera: la sesión pierde la
 // salida por chat hasta el mensaje siguiente, que la vuelve a escribir. Es la dirección barata del error.
+//
+// Un subagente también tiene a quién preguntarle: la persona es de la sesión, no de la llamada, y el
+// subagente hereda la sesión. Excluirlo acá cerraba la salida por chat en todo trabajo delegado —Build en
+// cada `autobuild`— y la persona decía que sí sin que llegara a ningún lado (caso 186).
 function present(input) {
-  if (process.env.CI || input.agent_id || !input.session_id) return null
+  if (process.env.CI || !input.session_id) return null
   const saved = load(input.session_id)
   return saved && saved.askable ? saved : null
 }
@@ -275,18 +300,18 @@ function why(saved, item, asked, inherit) {
 // antes que de menos.
 function grant(input, saved, entries) {
   const before = saved.granted || []
-  const nuevas = entries.filter((one) => !before.includes(one.item))
-  if (!nuevas.length) return
+  const added = entries.filter((one) => !before.includes(one.item))
+  if (!added.length) return
   const grantedAt = new Date().toISOString()
   try {
-    saved.granted = [...before, ...nuevas.map((one) => one.item)]
+    saved.granted = [...before, ...added.map((one) => one.item)]
     saved.scopes = { ...(saved.scopes || {}) }
-    for (const one of nuevas) if (one.scope) saved.scopes[one.item] = one.scope
+    for (const one of added) 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) => ({
+  TRAIL.append(saved.root, LOG, added.map((one) => ({
     grantedAt, item: one.item, scope: one.scope || null, via: one.via, session: input.session_id || null,
   })))
 }
@@ -301,14 +326,34 @@ function grant(input, saved, entries) {
 // en el mensaje en curso o aprobó con un «dale» (caso 119).
 function authorized(input, items, { asked = named, inherit = true } = {}) {
   const saved = said(input)
-  if (!saved) return []
+  if (!saved) return confirmed(input, items).map(({ item, via }) => ({ item, via }))
   return items.map((item) => ({ item, via: why(saved, item, asked, inherit) })).filter((one) => one.via)
 }
 
+// Lo que la persona confirmó y un subagente puede usar: eso y nada más. Una orden no, porque la da el mensaje
+// y la llamada de un subagente no es ese mensaje —es lo que `said` cuida—; lo concedido antes tampoco. Lo
+// confirmado sí: son los ítems exactos que un bloqueo nombró y ella aprobó al contestarle (caso 186). Sin
+// la comparación de `id`, porque el subagente puede reintentar después del mensaje en que ella contestó.
+function confirmed(input, items) {
+  if (process.env.CI || !input.agent_id || !input.session_id) return []
+  const saved = load(input.session_id)
+  const approved = (saved && saved.approved) || []
+  return items.filter((item) => approved.includes(item)).map((item) => ({ item, via: 'dale', saved }))
+}
+
 // Lo que la persona no autorizó de lo que un guard está por frenar; lo que sí, queda concedido.
 function unauthorized(input, items) {
   const saved = said(input)
-  if (!saved) return items
+  if (!saved) {
+    const passed = confirmed(input, items)
+    if (passed.length) {
+      const record = passed[0].saved
+      grant(input, record, passed.map((one) => ({ item: one.item, via: one.via,
+        scope: (record.scopes || {})[one.item] || '' })))
+    }
+    const cleared = new Set(passed.map((one) => one.item))
+    return items.filter((item) => !cleared.has(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.
@@ -328,21 +373,34 @@ function unauthorizedNow(input, items) {
 }
 
 // Lo que quedó frenado, para que la confirmación del mensaje siguiente apruebe exactamente eso y nada más.
-// Devuelve si hay una persona a quien preguntarle.
+// Devuelve `false` si no hay persona a quien preguntarle, y si la hay, qué de lo frenado no quedó
+// esperando: qué dice el bloqueo con eso, en `REFUSED` (approval.js).
+//
+// Si el último mensaje de la persona niega o frena, lo que se ataje después no queda esperando: ya contestó
+// que no antes de que el agente lo intentara, y un aviso del runner en el medio no cambia eso. Desde que
+// confirmar no exige una palabra (caso 184), dejarlo pendiente hacía que un «seguí con lo tuyo» aprobara
+// el `.env` o el push que ella acababa de prohibir. Se mira el mensaje, y no sólo el ítem, porque un push
+// no se nombra como un archivo.
 //
-// Si el mensaje en curso niega o frena, lo que se ataje en su turno no queda esperando: la persona ya
-// contestó que no antes de que el agente lo intentara. Desde que confirmar no exige una palabra (caso 184),
-// dejarlo pendiente hacía que un «seguí con lo tuyo» aprobara el `.env` o el push que ella acababa de
-// prohibir. Se mira el mensaje y no el ítem porque un push no se nombra como un archivo.
+// Pero el mensaje se mira en su primera cláusula, que es donde está la respuesta: lo que viene después
+// puede negar otra cosa, y «dale, fijate si esto no es un defecto» dejaba sin anotar lo que ella estaba
+// aprobando (caso 188). Lo que niega nombrando el ítem se respeta en cualquier cláusula —«dale, pero no el
+// .env»—. Queda afuera la prohibición que no nombra nada después de la coma, «dale, pero no toques nada
+// más»: ninguna lectura de palabras la separa de una negación sobre otro tema.
 function hold(input, items) {
   const saved = present(input)
   if (!saved) return false
   try {
-    const text = saved.text || ''
-    const open = NEGATION.test(text) || HALT.test(text) ? [] : items
+    const spoken = String(saved.spoken ?? saved.text ?? '')
+    const head = spoken.split(CLAUSE)[0]
+    const dropped = NEGATION.test(head) || HALT.test(head)
+      ? items
+      : items.filter((item) => mentions(spoken, item).denied
+        || (item.startsWith('push ') && refusesPush(spoken)))
+    const open = items.filter((item) => !dropped.includes(item))
     saved.pending = [...new Set([...saved.pending, ...open])]
     fs.writeFileSync(recordPath(input.session_id), JSON.stringify(saved))
-    return true
+    return { dropped }
   } catch { return false }
 }
 

package/engine/hooks/files.js

@@ -1,12 +1,11 @@
 'use strict'
 
-// Los guards que juzgan lo que está por escribirse: un secreto, un archivo generado, una migración,
-// una prueba que se apaga, el motor de la dependencia. Todos leen el contenido entrante y no el disco
-// —lo que ya estaba no lo escribió este cambio— y son el grupo `pre-files` del registro.
+// Los guards que juzgan lo que está por escribirse: un secreto, un archivo generado, una prueba que se
+// apaga, el motor de la dependencia. Todos leen el contenido entrante y no el disco —lo que ya estaba no
+// lo escribió este cambio— y son el grupo `pre-files` del registro, junto con `migrations.js`.
 
 const fs = require('node:fs')
 const path = require('node:path')
-const { spawnSync } = require('node:child_process')
 const {
   patchOf, filesOf, contentOf, cwdOf, block, configOf, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT,
@@ -20,33 +19,10 @@ const { hasTasks } = require('../planning/state')
 const { TEMPLATE_PREFIXES } = require('../core/ownership')
 
 // 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.
+// angosta: vale para esa ruta y para ninguna otra, a diferencia de la variable, que apaga el guard hasta
+// que cierre la sesión.
 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.
-//
-// **`HEAD` y no el índice**: un archivo apenas `git add`eado no viajó a ninguna parte, y `git ls-files`
-// lo daría por historial. Y **resolver la raíz es una pregunta aparte** de si el archivo está en `HEAD`:
-// las dos fallan con 128 y confundirlas repite el error que este caso arregla —decidir por la respuesta
-// equivocada—. Sin raíz resoluble se degrada a la conducta de antes, que bloquea de más, porque cuando
-// no se puede saber ése es el lado correcto para equivocarse. Es la degradación que `check` ya declara
-// cuando no puede resolver el repositorio de un servicio. Caso 086.
-function alreadyShipped(file) {
-  if (!fs.existsSync(file)) return ''
-  const cwd = path.dirname(file)
-  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
-  if (top.status !== 0) {
-    return 'existe, y acá no hay repositorio con el que saber si ya viajó a otra copia'
-  }
-  const rel = path.relative(top.stdout.trim(), file).split(path.sep).join('/')
-  return spawnSync('git', ['cat-file', '-e', `HEAD:${rel}`], { cwd }).status === 0
-    ? 'ya está en el historial del repositorio'
-    : ''
-}
-
-
 // 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) {
@@ -102,7 +78,7 @@ function secretsRead(input) {
   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)}`)
+      + `pedíselo a una persona.\n${AP.HOW('OPS_SECRETS_READ_OVERRIDE', [file], input, [file], { durable: true })}`)
   }
 }
 
@@ -243,13 +219,13 @@ function planFirst(input) {
   // Se lista recién acá, después de las dos salidas de arriba: quien tiene su plan sale por la primera y
   // no paga esta lectura, que es la misma razón por la que `hasTasks` se pregunta donde se pregunta.
   const foreign = readWips(planning).filter((one) => one.complete + one.pending > 0)
-  const estado = wip ? `WIP tiene la tarea ${wip.task} y ningún paso` : 'WIP está en IDLE'
+  const state = wip ? `WIP tiene la tarea ${wip.task} y ningún paso` : 'WIP está en IDLE'
   const why = foreign.length
     ? `hay plan escrito, pero bajo otro id: ${foreign.map((one) => `${one.runner} (${one.task})`).join(', ')}.\n`
       + 'Si ese plan es tuyo, volvé a su id con `export CAUCE_RUNNER=<id>` —`ops runners <planning>` los lista '
       + 'con su tarea y su avance— y repetí el cambio. Si vas a trabajar en paralelo, montá tu propio árbol '
       + 'con `ops worktree <planning> <tarea>`, que te devuelve el id hecho.\n'
-    : `${estado}, así que el plan todavía no está escrito.\n`
+    : `${state}, 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'
   for (const raw of filesOf(input)) {
@@ -278,80 +254,6 @@ function workspaceBoundary(input) {
   }
 }
 
-// Qué archivos son migraciones para este proyecto. La ruta la fija el motor —`migrations/`, `migration/`
-// o `migrate/`, que es donde las ponen todas las herramientas— y **la extensión la declara el proyecto**,
-// con `sql` de default.
-//
-// Sin esto el guard sólo veía `.sql`, así que en TypeORM, Prisma, Django, Rails o Alembic no miraba nada:
-// ni frenaba el SQL destructivo, ni protegía una migración existente de ser reescrita. Y no lo decía —
-// aparecía cableado y en verde—. Medido en una instancia real: 64 migraciones `.sql` cubiertas y **409
-// TypeORM `.ts` invisibles** (caso 077).
-//
-// No se amplía el default a `.ts`/`.py`/`.rb` por su cuenta: eso reintroduciría el falso positivo del
-// caso 039 —un archivo de lenguaje que menciona `DROP TABLE` en un comentario o en un string— por otra
-// puerta. Declararlo es opt-in porque el que sabe si sus migraciones son de lenguaje es el proyecto, y
-// porque así el costo lo elige quien lo paga.
-//
-// La extensión inválida no se descarta en silencio: descartarla dejaría al proyecto creyendo que declaró
-// una cobertura que no tiene, que es exactamente el defecto que este helper vino a cerrar. La valida
-// `validateOpsConfig`, y acá se ignora lo que no pasa ese filtro porque el guard no es el lugar donde se
-// enseña a escribir la configuración.
-const DEFAULT_MIGRATION_EXTENSIONS = ['sql']
-
-function migrationPattern(input) {
-  const root = opsRoot(input)
-  const declared = root ? (configOf(root).migrations || {}).extensions : null
-  const extensions = (Array.isArray(declared) ? declared : DEFAULT_MIGRATION_EXTENSIONS)
-    .filter((one) => typeof one === 'string' && /^[a-z0-9]+$/.test(one))
-  const usable = extensions.length ? extensions : DEFAULT_MIGRATION_EXTENSIONS
-  return new RegExp(`(?:^|/)(?:migrations?|migrate)/.*\\.(?:${usable.join('|')})$`, 'i')
-}
-
-function migrations(input) {
-  if (process.env.OPS_MIGRATIONS_OVERRIDE === '1') return
-  // Cada rama cierra su propio límite. Cuando el `\b` estaba al final del grupo se aplicaba a las tres, y
-  // la de `delete` termina a propósito en `;`: después de un punto y coma no hay límite de palabra, así que
-  // `DELETE FROM pedidos;` —la forma que tiene en cualquier migración— pasaba y sólo frenaba la variante sin
-  // punto y coma. `drop column` y `drop constraint` faltaban: pierden datos y garantías igual que `drop table`.
-  const destructiveSql = new RegExp(
-    String.raw`\bdrop\s+(?:table|database|schema|column|constraint)\b` +
-      String.raw`|\btruncate\b` +
-      String.raw`|\bdelete\s+from\s+\S+\s*(?:;|$)`,
-    'i',
-  )
-  // Las dos condiciones deciden sobre el mismo alcance, y por eso comparten el filtro. El bloqueo por
-  // SQL destructivo corría antes de este bucle, o sea sobre el contenido y sin mirar la ruta que ya
-  // tenía a mano: frenaba un ADR que citaba la migración o un comentario que advertía que eso no se
-  // hace, y encima afirmaba «La migración contiene…» sobre un archivo que no lo era. Un guard que
-  // frena donde no corresponde enseña a apagarlo, que es la salida más ancha que hay.
-  //
-  // El mensaje nombra el archivo por lo mismo: un falso positivo se lee igual que un bloqueo correcto
-  // mientras no diga sobre qué está decidiendo.
-  //
-  // El precio de compartir el filtro es que una migración escrita fuera de un directorio con ese nombre
-  // deja de frenarse. Es deliberado: el otro chequeo ya vivía con esa convención, y dos condiciones de
-  // la misma función con dos alcances distintos es lo que hizo falta arreglar acá.
-  const esMigracion = migrationPattern(input)
-  for (const raw of filesOf(input)) {
-    const normalized = raw.replace(/\\/g, '/')
-    if (!esMigracion.test(normalized)) continue
-    if (approved(input, normalized)) continue
-    if (destructiveSql.test(contentOf(input))) {
-      block(`${raw} contiene SQL destructivo.\n${AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized], 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
-    // la salida angosta, que hasta 0.79.0 sólo tenía el bloqueo hermano: éste es el que aparece en el
-    // flujo normal de escribir una migración, así que era justo el que no podía quedarse sin decirla.
-    const file = path.resolve(cwdOf(input), raw)
-    const shipped = alreadyShipped(file)
-    if (shipped) {
-      block(`${raw} ${shipped}. Crea una nueva en vez de reescribirla.\n`
-        + AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized], input))
-    }
-  }
-}
-
 // Hace falta un guard aparte porque `workspace-boundary` no lo cubre: `node_modules/` cae dentro de
 // la raíz declarada, así que editar el motor le parece legítimo.
 //
@@ -381,5 +283,5 @@ function engineWrites(input) {
 module.exports = {
   credential, patternNames,
   secrets, secretsRead, integrationSnapshot, generated, testEvidence, planFirst, workspaceBoundary,
-  migrations, engineWrites,
+  engineWrites,
 }

package/engine/hooks/input.js

@@ -3,23 +3,75 @@
 // Cómo un guard lee lo que el runner le mandó, y cómo se niega. Es una sola pregunta —qué hay en la
 // entrada y cómo se interpreta— y la comparten las tres familias de guards, así que vive acá y no en
 // ninguna de ellas: copiada, una copia dejaría de reconocer un formato y su guard permitiría todo en
-// silencio, que es la falla que ninguna prueba verde delata.
+// silencio, que es la falla que ninguna prueba verde delata. `readInput` lo usa además el puente de
+// Antigravity, que tenía su copia y la tenía rota así (caso 198).
 
 const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const { writableOutsideRoots } = require('../config/paths')
 
+// Cuánto se espera el primer byte de stdin. El runner escribe su JSON al lanzar el hook, así que en el
+// camino real ya está en el búfer cuando Node termina de arrancar: el plazo sólo cubre una máquina
+// cargada, y dos segundos le sobran. Lo que agota el plazo es un stdin heredado que nadie va a escribir
+// —una terminal, un pipe o un socket abiertos— y ahí cada segundo de más es un segundo colgado. Fijo y
+// no configurable: una variable que lo estire no arregla nada que el runner necesite (caso 190).
+const FIRST_BYTE_MS = 2000
+
+// Cómo se invoca a mano quien lee. Es lo único del mensaje que cambia entre un guard y el puente de
+// Antigravity, que lee con esta misma función pero recibe otro JSON y se lanza con otro comando.
+const GUARD_USAGE = 'pasale el JSON del hook —printf \'%s\' \'{"tool_input":{"command":"…"}}\' | guard-….sh—'
+
+const noInput = (waitMs, usage) => `no llegó nada por stdin en ${waitMs} ms: stdin está abierto y nadie escribe`
+  + ' (una terminal, o un pipe o un socket que no se cierran). Un guard que no sabe qué juzgar no autoriza.'
+  + ` Para invocarlo a mano, ${usage} o correlo sin entrada con </dev/null.`
+
 // Sin stdin no hay nada que leer y los guards caen a las variables de entorno; con stdin ilegible sí
 // hay algo y no se entiende, que es otra cosa. Devolver `{}` ahí dejaba a cada guard sin comando ni
 // archivos, o sea permitiendo todo, y en silencio.
-function readInput() {
-  let raw = ''
-  try { raw = fs.readFileSync(0, 'utf8') } catch { /* sin stdin */ }
-  if (!raw.trim()) return {}
-  try { return JSON.parse(raw) } catch (error) {
-    block(`la entrada del hook no es JSON válido (${error.message}).`)
-  }
+//
+// Hay un tercer estado, y es el del caso 190: stdin abierto que no manda nada. Leerlo sincrónico
+// esperaba hasta que el otro extremo cerrara —horas, en la corrida que lo encontró— sin que el guard
+// llegara a correr. Se lee asíncrono porque es la única forma de ponerle plazo a un socket: reabrir el 0
+// con `O_NONBLOCK` falla con `ENXIO` sobre un socket, que era el descriptor del colgado original.
+//
+// El plazo es sobre el primer byte y no sobre la lectura: un `Write` grande llega en tramos, y cortarlo
+// a mitad de camino bloquearía una escritura legítima. Agotado, **bloquea**: tratarlo como entrada vacía
+// dejaba pasar todo lo que no estuviera en `OPS_HOOK_COMMAND`, que es un guard apagado sin rastro (R27).
+function readInput(stream = process.stdin, waitMs = FIRST_BYTE_MS, usage = GUARD_USAGE) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    const timer = setTimeout(() => {
+      stream.destroy()
+      reject(blocked(noInput(waitMs, usage)))
+    }, waitMs)
+    // Llegado el primer byte, el plazo cambia de sentido: si pasa sin nada nuevo y lo recibido ya es un JSON
+    // entero, el documento está completo aunque quien escribió no haya cerrado el pipe, y esperar el cierre
+    // colgaba al guard igual que sin datos. Un JSON a medias sigue esperando: un `Write` grande puede llegar
+    // en tramos con pausas, y cortarlo bloquearía una escritura legítima.
+    let idle
+    stream.on('data', (chunk) => {
+      clearTimeout(timer)
+      clearTimeout(idle)
+      chunks.push(chunk)
+      idle = setTimeout(() => {
+        let parsed
+        try { parsed = JSON.parse(Buffer.concat(chunks).toString('utf8')) } catch { return }
+        stream.destroy()
+        resolve(parsed)
+      }, waitMs)
+    })
+    stream.on('error', () => { clearTimeout(timer); clearTimeout(idle); resolve({}) })
+    stream.on('end', () => {
+      clearTimeout(timer)
+      clearTimeout(idle)
+      const raw = Buffer.concat(chunks).toString('utf8')
+      if (!raw.trim()) return resolve({})
+      try { resolve(JSON.parse(raw)) } catch (error) {
+        reject(blocked(`la entrada del hook no es JSON válido (${error.message}).`))
+      }
+    })
+  })
 }
 
 // El cuerpo de un heredoc es entrada estándar: no se ejecuta, se escribe. Juzgarlo como comando frenaba
@@ -87,10 +139,14 @@ function cwdOf(input) {
   return path.resolve(String(cwd))
 }
 
-function block(message) {
+function blocked(message) {
   const error = new Error(message)
   error.blocked = true
-  throw error
+  return error
+}
+
+function block(message) {
+  throw blocked(message)
 }
 
 // La configuración de la raíz ops. Un guard que no puede leerla bloquea: `findOpsRoot` sólo devuelve
@@ -262,7 +318,7 @@ function opsRoot(input) {
 }
 
 module.exports = {
-  readInput, commandOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
+  readInput, FIRST_BYTE_MS, commandOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
   gitDirectory, isCommit, withoutGitGlobals, stagedFiles, stagedForCommit,
   findOpsRoot, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT, unquoted,

package/engine/hooks/migrations.js

@@ -0,0 +1,93 @@
+'use strict'
+
+// El guard `migrations`: no reescribir una migración que ya viajó y no aplicar un borrado sin que una
+// persona lo apruebe. Qué archivo es una migración, qué parte aplica y qué cuenta como destruir lo decide
+// `core/migrations`, que `check` también lee.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { spawnSync } = require('node:child_process')
+const { filesOf, contentOf, patchOf, cwdOf, block, configOf, opsRoot } = require('./input')
+const AP = require('./approval')
+const M = require('../core/migrations')
+
+// 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.
+//
+// **`HEAD` y no el índice**: un archivo apenas `git add`eado no viajó a ninguna parte, y `git ls-files`
+// lo daría por historial. Y **resolver la raíz es una pregunta aparte** de si el archivo está en `HEAD`:
+// las dos fallan con 128 y confundirlas repite el error que este caso arregla —decidir por la respuesta
+// equivocada—. Sin raíz resoluble se degrada a la conducta de antes, que bloquea de más, porque cuando
+// no se puede saber ése es el lado correcto para equivocarse. Es la degradación que `check` ya declara
+// cuando no puede resolver el repositorio de un servicio. Caso 086.
+function alreadyShipped(file) {
+  if (!fs.existsSync(file)) return ''
+  const cwd = path.dirname(file)
+  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' })
+  if (top.status !== 0) {
+    return 'existe, y acá no hay repositorio con el que saber si ya viajó a otra copia'
+  }
+  const rel = path.relative(top.stdout.trim(), file).split(path.sep).join('/')
+  return spawnSync('git', ['cat-file', '-e', `HEAD:${rel}`], { cwd }).status === 0
+    ? 'ya está en el historial del repositorio'
+    : ''
+}
+
+const approved = (input, file) => !AP.pending(opsRoot(input), [file], input).length
+
+// El `Edit` trae lo que reemplaza; el archivo en disco dice dónde cae (caso 185). Se lo lee sólo para
+// ubicar el fragmento: lo que ya estaba no se juzga.
+function editOf(input, file) {
+  const fields = input.tool_input || {}
+  if (typeof fields.old_string !== 'string' || typeof fields.content === 'string') return {}
+  let disk = null
+  try { disk = fs.readFileSync(file, 'utf8') } catch { /* sin archivo se juzga el fragmento */ }
+  return { disk, old: fields.old_string, all: fields.replace_all === true }
+}
+
+function migrations(input) {
+  if (process.env.OPS_MIGRATIONS_OVERRIDE === '1') return
+  // Las dos condiciones deciden sobre el mismo alcance, y por eso comparten el filtro. El bloqueo por
+  // SQL destructivo corría antes de este bucle, o sea sobre el contenido y sin mirar la ruta que ya
+  // tenía a mano: frenaba un ADR que citaba la migración o un comentario que advertía que eso no se
+  // hace, y encima afirmaba «La migración contiene…» sobre un archivo que no lo era. Un guard que
+  // frena donde no corresponde enseña a apagarlo, que es la salida más ancha que hay.
+  //
+  // El precio de compartir el filtro es que una migración escrita fuera de las carpetas declaradas deja de
+  // frenarse. Es deliberado: el otro chequeo ya vivía con esa convención, y dos condiciones de la misma
+  // función con dos alcances distintos es lo que hizo falta arreglar acá.
+  const root = opsRoot(input)
+  const isMigration = M.pattern(root ? configOf(root) : {})
+  // Un parche trae varios archivos en un sobre: cada uno se juzga por su sección, no por el sobre entero.
+  const sections = M.patchSections(patchOf(input))
+  for (const raw of filesOf(input)) {
+    const normalized = raw.replace(/\\/g, '/')
+    if (!isMigration.test(normalized)) continue
+    if (approved(input, normalized)) continue
+    const file = path.resolve(cwdOf(input), raw)
+    // El mensaje nombra el archivo y la sentencia: un falso positivo se lee igual que un bloqueo correcto
+    // mientras no diga sobre qué está decidiendo. Y cuando la migración se partió, dice que la reversión
+    // no se juzgó, para que quien lo lea no busque la sentencia en el bloque equivocado.
+    const section = sections.get(raw)
+    const scope = section
+      ? M.judgedPatch(normalized, section)
+      : M.judged(normalized, contentOf(input), editOf(input, file))
+    const found = M.destructive(scope.text)
+    if (found) {
+      const where = scope.label ? ` en el bloque que aplica (la reversión, \`${scope.label}\`, no se juzga)` : ''
+      block(`${raw} contiene ${found.kind}${where}: \`${found.what}\`.\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
+    // la salida angosta, que hasta 0.79.0 sólo tenía el bloqueo hermano: éste es el que aparece en el
+    // flujo normal de escribir una migración, así que era justo el que no podía quedarse sin decirla.
+    const shipped = alreadyShipped(file)
+    if (shipped) {
+      block(`${raw} ${shipped}. Crea una nueva en vez de reescribirla.\n`
+        + AP.HOW('OPS_MIGRATIONS_OVERRIDE', [normalized], input))
+    }
+  }
+}
+
+module.exports = { migrations }

package/engine/hooks/push.js

@@ -113,12 +113,14 @@ function liveMessage(live, input) {
 
 function workMessage(items, input) {
   const lines = items.filter((item) => item.startsWith('push '))
-  const chat = CHAT.hold(input, items)
-  const how = chat
+  const held = CHAT.hold(input, items)
+  const dropped = held ? held.dropped : []
+  const chat = held && dropped.length < items.length
+  const how = (dropped.length ? AP.REFUSED(dropped, input) : '') + (chat
     ? 'Decile a la persona qué se frenó y pedile que lo confirme con sus palabras: si lo que contesta es un '
       + 'sí, reintentá el mismo push y pasa; si duda, pregunta o dice que no, no reintentes. '
       + '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.'
+    : '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('')

package/engine/hooks/run.js

@@ -13,6 +13,7 @@ const { readInput, block, opsRoot } = require('./input')
 const shell = require('./shell')
 const { verify } = require('./verify')
 const files = require('./files')
+const { migrations } = require('./migrations')
 const chat = require('./chat')
 const { secretsShell } = require('./secrets-shell')
 const { opsConfig, opsConfigShell } = require('./ops-config')
@@ -50,7 +51,7 @@ const guards = {
   generated: files.generated,
   'workspace-boundary': files.workspaceBoundary,
   engine: files.engineWrites,
-  migrations: files.migrations,
+  migrations,
   'integration-snapshot': files.integrationSnapshot,
   'test-evidence': files.testEvidence,
   'plan-first': files.planFirst,
@@ -145,8 +146,10 @@ const hookMetadata = [
   {
     name: 'migrations',
     event: 'PreToolUse · files',
-    purpose: 'Protege migraciones existentes y bloquea SQL destructivo, sobre las extensiones que el '
-      + 'proyecto declare en migrations.extensions — sólo .sql si no declara ninguna.',
+    purpose: 'Protege migraciones existentes y bloquea SQL destructivo o el borrado con la API del ORM en la '
+      + 'parte que aplica —no en su reversión—, sobre las extensiones y carpetas que el proyecto declare en '
+      + 'migrations.extensions y migrations.paths — sólo .sql bajo migrations/, migration/ o migrate/ si no '
+      + 'declara nada.',
   },
   {
     name: 'integration-snapshot',
@@ -194,11 +197,13 @@ function executeAll(names, input) {
   for (const name of resolve(names)) execute(name, input)
 }
 
+// Asíncrono sólo por la lectura de stdin, que necesita un plazo (`input.js`); los guards siguen siendo
+// sincrónicos y `executeAll` también, así que quien los llama directo no cambia.
 if (require.main === module) {
-  try { executeAll(process.argv.slice(2), readInput()) } catch (error) {
+  readInput().then((input) => executeAll(process.argv.slice(2), input)).catch((error) => {
     console.error(`BLOQUEADO: ${error.message}`)
     process.exit(error.blocked ? 2 : 1)
-  }
+  })
 }
 
 module.exports = {