@ingeniomaps/cauce 0.97.0 → 0.99.0

package/engine/hooks/approval.js

@@ -79,6 +79,17 @@ function where(input) {
   return relative && !relative.startsWith('..') && !path.isAbsolute(relative) ? relative : file
 }
 
+// Lo que el último mensaje de la persona negaba no quedó esperando su confirmación, así que un «dale» no
+// lo aprobaría: ofrecerlo sería mandarla a contestar para volver a frenar (caso 188). Lo que sí lo pasa es
+// pedirlo nombrándolo, que es una orden y no una confirmación.
+function REFUSED(items, input = {}) {
+  return `Lo último que dijo la persona niega o frena ${items.join(', ')}, así que no quedó esperando su `
+    + 'confirmación y un sí no lo aprobaría: no reintentes. '
+    + (input.agent_id
+      ? 'Devolvele el bloqueo a quien te lanzó. '
+      : 'Si lo quiere, que lo pida en el chat nombrándolo. ')
+}
+
 // Cómo se toma la salida angosta, dicho una vez porque lo dicen todos los bloqueos que la tienen. Lleva
 // las líneas exactas porque cada guard coteja la ruta en la forma que tiene a mano —absoluta la que llega
 // de un Write, relativa al repositorio la que sale del índice— y una línea en la otra forma no pega: sin
@@ -94,7 +105,9 @@ function where(input) {
 // que tiene a mano no sirve para pegar —por qué, en `secrets-shell.js` (caso 118)—. Lo frenado se anota
 // igual, así que el «dale» sigue cubriendo todo.
 function HOW(variable, lines, input, pasteable = lines) {
-  const chat = CHAT.hold(input, lines)
+  const held = CHAT.hold(input, lines)
+  const dropped = held ? held.dropped : []
+  const chat = held && dropped.length < lines.length
   const stuck = lines.filter((one) => !pasteable.includes(one))
   // El alcance del «dale» va con la oferta y no después. La rama del pegado ya decía el suyo —«valen para
   // ese conjunto»— y la del chat no decía ninguno, siendo la que se ofrece primero. Las dos mitades que
@@ -103,16 +116,34 @@ function HOW(variable, lines, input, pasteable = lines) {
   // siguientes** es la dirección permisiva, la que nadie nota porque lo que no ocurre es un bloqueo.
   // `check` la muestra al final de la corrida —es lo que trajo el 117—, y al concederla no la decía nadie
   // (caso 170).
+  // Un subagente no puede esperar la respuesta —su turno termina antes—, así que lo que le toca es
+  // devolver el bloqueo: preguntar lo hace quien lo lanzó, y el reintento pasa aunque vuelva a ser delegado
+  // (caso 186).
+  const lead = input.agent_id
+    ? 'Sos un subagente y no podés esperar la respuesta: devolvele a quien te lanzó qué se frenó y por qué, '
+      + 'para que se lo pregunte a la persona. Si ella lo confirma, el mismo cambio pasa aunque lo reintente '
+      + 'un subagente. '
+    : 'Decile a la persona qué se frenó y por qué, y pedile que lo confirme con sus palabras: un «dale» '
+      + 'alcanza, pero no hace falta esa palabra. Si lo que contesta es un sí, reintentá el mismo cambio y '
+      + 'pasa; si duda, pregunta o dice que no, no reintentes. Juzgarlo te toca a vos: el guard sólo frena la '
+      + 'respuesta que niega, frena o pregunta. '
   const ask = chat
-    ? 'Decile a la persona qué se frenó y por qué, y esperá: si contesta «dale», reintentá el mismo cambio y '
-      + 'pasa. Ese «dale» cubre lo que se frenó y nada más —algo nuevo vuelve a frenar— y sigue valiendo en '
-      + 'los mensajes siguientes hasta que ella lo niegue. '
+    ? lead + 'Esa confirmación cubre lo que se frenó y nada más —algo nuevo vuelve a frenar— y sigue valiendo '
+      + 'en los mensajes siguientes hasta que ella lo niegue. '
     : ''
+  const refused = dropped.length ? REFUSED(dropped, input) : ''
+  // Sin chat la salida es la misma, y también se dice como cosa de ella: el imperativo que el párrafo de
+  // arriba sacó de la rama con chat seguía acá, y es lo único que ve quien no tiene a nadie en el chat
+  // (caso 194). A quien corre el guard le toca otra cosa, y se le dice cuál. Vale también cuando hay persona
+  // pero no se le ofrece contestar, porque su último mensaje negaba todo lo frenado.
   const paste = pasteable.length
-    ? (chat ? 'Si prefiere aprobarlo a mano, que pegue ella tal cual en' : 'Aprobalo pegando tal cual en')
+    ? (chat ? 'Si prefiere aprobarlo a mano, que pegue ella' : 'Esto lo aprueba una persona: que pegue ella')
+      + ' tal cual en'
       + ` ${where(input)} estas líneas:\n`
       + pasteable.map((line) => `  ${line}\n`).join('')
       + 'Valen para ese conjunto y dejan de valer en cuanto cambie. '
+      + (chat ? '' : 'Vos no lo escribas —un guard lo frena—: decí qué se frenó y dónde, y reintentá cuando '
+        + 'esté; si sos un subagente, devolvele el bloqueo a quien te lanzó. ')
     : ''
   const unresolved = stuck.length
     ? `Por archivo no hay línea que pegar para ${stuck.join(', ')}: la ruta llegó con una expansión del shell `
@@ -126,7 +157,7 @@ function HOW(variable, lines, input, pasteable = lines) {
     ? `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
+  return ask + refused + paste + unresolved + off
 }
 
 // Las dos exenciones que sobreviven a un bloqueo, para que `check` las muestre juntas: la lista que una
@@ -151,4 +182,4 @@ function warnings(root) {
   return out
 }
 
-module.exports = { APPROVAL, lines, read, pending, pendingNow, where, HOW, warnings }
+module.exports = { APPROVAL, lines, read, pending, pendingNow, where, HOW, REFUSED, warnings }

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,17 +159,19 @@ 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(' '))
   })
 }
 
-// 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')
+// Quien contesta a un bloqueo que quedó pendiente lo confirma con sus palabras, y juzgar si lo que dijo
+// es un sí le toca al agente que lo lee. Antes el guard exigía que el mensaje **empezara** con una de once
+// formas —«dale», «sí», «ok»…—, así que «listo», «claro», «confirmo» o «bueno dale» volvían a frenar lo
+// que la persona acababa de aprobar (caso 184). Lo único que el guard sigue decidiendo es la dirección
+// segura: un mensaje que niega, que arranca frenando o que pregunta no aprueba nada. Si eso se equivoca,
+// el costo es volver a preguntar; si se equivocara al revés, un «no» o un «¿para qué sirve?» ejecutaría lo
+// que la persona no aprobó.
+const HALT = /^\s*(?:par[aá]|deten\p{L}*|esper[aá]|cancel\p{L}*|stop|wait|hold on)(?![\p{L}])/iu
+const refuses = (text) => NEGATION.test(text) || HALT.test(text) || /[?¿]/.test(text)
 
 // 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í
@@ -175,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 && YES.test(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.
@@ -191,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 */ }
 }
 
@@ -219,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
 }
@@ -270,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,
   })))
 }
@@ -296,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.
@@ -322,15 +372,35 @@ function unauthorizedNow(input, items) {
   return items.filter((item) => !cleared.has(item))
 }
 
-// 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.
+// Lo que quedó frenado, para que la confirmación del mensaje siguiente apruebe exactamente eso y nada más.
+// 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.
+//
+// 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 {
-    saved.pending = [...new Set([...saved.pending, ...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,
@@ -24,29 +23,6 @@ const { TEMPLATE_PREFIXES } = require('../core/ownership')
 // 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) {
@@ -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,