@ingeniomaps/cauce 0.98.0 → 0.99.0

package/CHANGELOG.md

@@ -14,6 +14,103 @@ 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.99.0] - 2026-09-24
+
+### Agregado
+
+- **`migrations.paths` en `ops.config.json`**: las carpetas donde viven tus migraciones, por ejemplo
+  `["migrations", "alembic/versions"]`. Si la declarás, reemplaza el default (`migrations`, `migration`,
+  `migrate`), que no alcanzaba a Alembic. `check` avisa la extensión o la carpeta declarada que no alcanza
+  a ningún archivo: una cobertura que declaraste y no cubre nada.
+
+### Cambiado
+
+- **`check` falla si una entrada de DONE tiene `tests:` todo `n/a` y su commit toca algo que no sea un
+  documento (`.md`, `.txt`, `.adoc`) o una imagen (`.png`, `.jpg`, `.jpeg`, `.gif`, `.svg`, `.webp`).** Es lo que vuelve creíble el `n/a` de arriba: lo demás se ejecuta y se prueba. Rige
+  para lo cerrado desde el 2026-09-24, así que tu historia anterior no se pone en rojo al actualizar.
+
+### Corregido
+
+- **Un aviso de una tarea de fondo ya no le borra a la persona lo que dijo.** Si un guard frenaba algo en el
+  turno de un aviso de un subagente, eso no quedaba esperando tu confirmación, y tu «dale» siguiente no
+  aprobaba nada. Ahora lo frenado espera tu respuesta aunque el aviso llegue antes que ella, y tu negativa
+  —«no toques el `.env`»— sigue valiendo después de un aviso sin depender del texto que el aviso traiga.
+
+- **Una negación sobre otra cosa ya no te hace perder un bloqueo.** «dale, fijate si esto no es un
+  defecto» dejaba lo frenado sin anotar, y tu «confirmo» siguiente no aprobaba nada. Ahora la respuesta se
+  lee en la primera parte del mensaje, y lo que negás nombrándolo —«dale, pero no el .env»— sigue sin
+  pasar, igual que un push si en cualquier parte decís que no se publique —«no hagas push todavía»—. Cuando algo no queda esperando tu confirmación, el bloqueo lo dice y te indica que lo pidas
+  nombrándolo, en vez de ofrecerte un «dale» que no iba a servir.
+
+- **Si lo que se frenó lo hacía un subagente, tu confirmación le llega.** Dentro de trabajo delegado —Build en
+  cada `autobuild`— el bloqueo no ofrecía el chat: decías que sí y el reintento volvía a frenar con el mismo
+  mensaje, y la única salida era pegar la línea en `planning/.ops-approval`. Ahora el subagente devuelve el
+  bloqueo para que te lo pregunten, y lo que confirmes pasa aunque lo reintente otro subagente. Sólo eso: un
+  pedido tuyo que nombraba algo sigue valiendo para el agente con el que hablás, no para un subagente.
+
+- **Sin nadie en el chat, el bloqueo ya no le ordena al agente que se escriba la aprobación.** Decía «Aprobalo
+  pegando tal cual en…», y el agente lo leía como una orden que su contrato le prohíbe. Ahora dice que las
+  líneas las pega una persona, y al agente qué hacer mientras tanto.
+
+- **El gate de commit reconoce el código de sqlc donde lo pongas.** Sólo aceptaba el generado bajo una
+  carpeta `sqlc/` o `generated/`, así que un `out` como `internal/platform/pgdb/` pedía aprobación en cada
+  commit que tocaba una consulta aunque hubieras regenerado. Ahora reconoce `*.sql.go` en cualquier carpeta.
+  Y ve una consulta en cualquier carpeta `queries/` —`api/db/queries/` en un monorepo—, que antes se
+  commiteaba sin su generado sin que nada avisara; eso sólo si el repositorio tiene `sqlc.yaml`, `sqlc.yml`
+  o `sqlc.json`. Si frena, dice qué buscó. Límite: con `output_files_suffix` el generado no se reconoce.
+
+- **Un guard invocado a mano ya no se queda colgado.** Lanzado fuera del runner —a mano, desde un script o
+  en segundo plano— con stdin abierto y sin datos, esperaba hasta que el otro extremo cerrara: horas, sin
+  llegar a correr. Ahora, si en 2 s no llega nada, bloquea y explica cómo invocarlo: con el JSON del hook
+  por stdin, o sin entrada con `</dev/null`. Lo que manda el runner se lee entero, así que una escritura
+  grande no se corta, y un JSON completo se juzga aunque quien lo mandó no cierre stdin.
+
+- **Una tarea cuyo entregable es un documento o una decisión escrita ya puede cerrarse en `autobuild`.**
+  Paraba en `verify-hollow` pidiendo pruebas imposibles. Ahora Verify declara esos criterios sin superficie
+  ejecutable, llegan a Done como `tests: n/a — <razón>`, y QA comprueba que el documento exista y cubra lo
+  que la aceptación enumera. Con causas mezcladas, el rebote pide sólo las pruebas que de verdad faltan, y
+  Done recibe de Verify qué prueba cubre cada criterio en vez de componerlo de memoria.
+
+- **Una condición marcada `(fuera de verify: <razón>)` ya no llega a Verify ni a QA.** Era la salida que
+  `check` recomienda, y la corrida paraba igual; ahora viaja a Done para quedar cumplida en `tests:`, `qa:`
+  o `commit:`.
+
+- **El guard de migraciones ya no frena la reversión honesta.** Buscaba en todo el archivo, así que el
+  `DROP TABLE` del `-- +goose Down` frenaba cada tabla nueva y una migración sin `Down` pasaba. Ahora, en
+  goose y dbmate, juzga sólo el bloque que aplica; un `*.down.sql` es reversión entera; corregir el `Down`
+  con una edición también pasa; y el mensaje dice en qué bloque está lo que frena.
+
+- **Si declarás `migrations.extensions`, el guard ve también el borrado escrito con la API del ORM**, no
+  sólo el SQL crudo: `op.drop_table`/`drop_column` (Alembic), `drop_table`, `remove_column(s)` y
+  `drop_join_table` (Rails), `dropTable`/`dropColumn(s)` (TypeORM), `dropTable(IfExists)`/`dropColumn`
+  (Knex) y `DeleteModel`/`RemoveField` (Django). La reversión —`downgrade()`, `down`— no se juzga.
+
+- **El puente de Antigravity ya no deja pasar lo que no puede leer.** Ante un JSON ilegible respondía
+  `allow`: un `git push --force` al que le faltaba una llave pasaba. Y con stdin abierto se colgaba. Ahora
+  lee con el mismo lector que los guards: lo ilegible se niega en `pre-shell` y `pre-files`, si en 2 s no
+  llega nada niega y dice cómo invocarlo a mano, y en `stop` deja cerrar con el motivo a la vista. Sin
+  entrada (`</dev/null`) sigue permitiendo, como antes.
+
+- **El puente de Antigravity niega una llamada que no sabe describir.** Leía cada campo por un nombre fijo,
+  así que una llamada con otra forma —un campo renombrado en una actualización del runner— llegaba vacía a
+  los guards y pasaba: todos apagados sin avisar. Ahora un `pre-shell` sin comando o un `pre-files` sin
+  archivo se niegan, y el motivo nombra los campos que sí llegaron.
+
+- **El gate de commit reconoce una especificación OpenAPI por lo que declara, no por la carpeta.** Cualquier
+  `.yaml` bajo `api/`, `openapi/` o `spec/` pedía regenerar el cliente: una config de sqlc, un compose o un
+  fixture ahí frenaban cada commit. Ahora cuenta el que declara `openapi:` o `swagger:`, o un fragmento de una
+  carpeta que tiene uno.
+
+- **En Codex, el guard de migraciones juzga cada archivo del parche por separado.** Un `apply_patch` llegaba
+  como un solo sobre: los marcadores de goose y dbmate venían con el `+` del parche y no partían, así que la
+  reversión honesta volvía a frenar, y un `DROP TABLE` citado en otro archivo del mismo parche frenaba la
+  migración. Ahora cada archivo se juzga por su sección, y en una modificación sólo lo agregado.
+
+- **`automation doctor` de Antigravity mira la copia que `agy` ejecuta de verdad.** `agy` corre la que registrás
+  con `agy plugin install`, una por usuario, y `doctor` miraba la del workspace: decía «operativo» mientras `agy`
+  ejecutaba el plugin de otro proyecto o uno roto, y frenaba cada comando. Ahora compara las dos, lanza la
+  registrada como la lanza `agy`, y si difiere te dice qué comando corre para registrar esta instalación.
+
 ## [0.98.0] - 2026-09-17
 
 ### Cambiado

package/automatization/hooks/README.md

@@ -12,7 +12,8 @@ Los hooks convierten invariantes comprobables en gates mecánicos. La base recom
 - cierre de sesión con planning o integraciones inválidas;
 - modificación del protocolo durante una tarea de producto.
 - escrituras fuera de las raíces declaradas del workspace;
-- reescritura de migraciones y SQL destructivo;
+- reescritura de migraciones y borrado destructivo —SQL o la API del ORM— en la parte que aplica, no en su
+  reversión; qué carpetas y extensiones son migraciones lo declara `migrations` en `ops.config.json`;
 - publicación, instalaciones globales y drift entre manifests y lockfiles.
 
 La lógica portable vive en `engine/hooks/run.js`; los `guard-*.sh` son entradas ejecutables comunes. Cada
@@ -84,7 +85,10 @@ guards lo leen:
 
 No cuenta cuando no hay persona —CI, o un aviso del runner como el de un subagente que terminó—, cuando lo
 que pidió es un recorrido de Cauce (`/autobuild`, `$flow`…), ni en la llamada de un subagente, que Claude
-marca con `agent_id`. En Claude y Codex cada llamada trae el identificador del mensaje que la originó;
+marca con `agent_id`: a un subagente no le llega lo que ella pidió ni lo que se le concedió antes. Sí le
+llega su confirmación a un bloqueo, que nombra exactamente lo frenado: el bloqueo de un subagente le pide
+devolverlo a quien lo lanzó para que se lo pregunte, y lo que ella confirme pasa aunque lo reintente otro
+subagente. En Claude y Codex cada llamada trae el identificador del mensaje que la originó;
 Gemini no lo manda, y ahí vale el último mensaje. El registro vive en el temporal del sistema, uno por
 sesión, y los guards de límites lo cuidan junto con `planning/.ops-approval`: el registro no lo escribe
 nunca una herramienta, y en la aprobación sólo entran las líneas que la persona nombró en ese mismo

package/automatization/runners/antigravity/README.md

@@ -19,7 +19,10 @@ usuario y no por workspace. De ahí salen tres consecuencias que conviene tener
 - Registrar desde otro proyecto reemplaza el plugin del anterior.
 
 Volvé a registrar cada vez que `automation install` cambie el wiring o el proyecto se mueva de lugar;
-`agy plugin validate .agents/plugins/cauce` comprueba la copia del repo antes de registrarla.
+`agy plugin validate .agents/plugins/cauce` comprueba la copia del repo antes de registrarla. Si te
+olvidás, `automation doctor` lo dice: compara la copia registrada con la del workspace y la lanza como
+la lanza `agy`, desde su carpeta, así que una copia de otro proyecto o de otra versión es un error con el
+comando que lo corrige. Al instalar es una advertencia, porque registrar es justo el paso que sigue.
 
 El plugin aporta hooks `PreToolUse` y `Stop`, reglas Cauce y los cinco recorridos —`/cauce:onboard`,
 `/cauce:flow`, `/cauce:autobuild`, `/cauce:integration-sync` y `/cauce:integration-promote`— más el

package/automatization/runners/antigravity/hook.js

@@ -4,13 +4,6 @@
 const fs = require('node:fs')
 const path = require('node:path')
 
-function readInput() {
-  try {
-    const raw = fs.readFileSync(0, 'utf8')
-    return raw.trim() ? JSON.parse(raw) : {}
-  } catch { return {} }
-}
-
 // Dónde quedó la raíz ops respecto de la carpeta que Antigravity abre. Lo completa
 // `automation install`, que es el único momento en que se sabe: en modo sidecar la raíz ops es un
 // hermano de los repos de producto, y ninguna búsqueda hacia arriba la encuentra. Sin esto el bridge
@@ -78,18 +71,39 @@ function findRoot(input, markers = MARKERS) {
   throw new Error('No se encontró una raíz Cauce desde el workspace de Antigravity.')
 }
 
-function runtimeAt(root) {
+function engineAt(root, file) {
   const candidates = [
-    path.join(root, 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', 'run.js'),
-    path.join(root, 'engine', 'hooks', 'run.js'),
-    path.join(root, '..', 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', 'run.js'),
+    path.join(root, 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', file),
+    path.join(root, 'engine', 'hooks', file),
+    path.join(root, '..', 'node_modules', '@ingeniomaps', 'cauce', 'engine', 'hooks', file),
   ]
   // Copia de `packagePath`; su porqué vive allá. Son tres los que la repiten y el motor los nombra.
-  const runtime = candidates.find(fs.existsSync)
+  return candidates.find(fs.existsSync) || ''
+}
+
+function runtimeAt(root) {
+  const runtime = engineAt(root, 'run.js')
   if (!runtime) throw new Error('No se encontró el runtime engine/hooks/run.js.')
   return require(runtime)
 }
 
+// La entrada se lee con el lector del motor y no con uno propio: el puente tenía su copia, y la copia se
+// colgaba con stdin abierto y convertía un JSON ilegible en `allow` (caso 198). Lo que no se puede usar para
+// encontrarlo es la entrada misma, que todavía no se leyó: se busca como `findRoot` sin entrada —la raíz que
+// `install` dejó escrita y, si no resuelve, desde donde corre el puente—. Sólo la declarada dejaba sin
+// lector, negando cada llamada, a un proyecto movido que los guards sí encontraban. Sin ninguna, se niega.
+function inputReader(markers = MARKERS) {
+  let root = ''
+  try { root = findRoot({}, markers) } catch { /* sin raíz no hay motor: lo dice el error de abajo */ }
+  const reader = root && engineAt(root, 'input.js')
+  if (!reader) {
+    throw new Error('No se encontró engine/hooks/input.js, con el que se lee la entrada, ni en la raíz que '
+      + `automation install declaró (${declaredRoot(markers) || 'ninguna'}) ni desde ${process.cwd()}. `
+      + 'Reinstalá el runner.')
+  }
+  return require(reader)
+}
+
 // La carpeta que el runner abrió, deducida de la raíz: en sidecar la raíz ops es su hija, y en modo
 // embebido son la misma.
 function workspaceOf(root, markers) {
@@ -134,6 +148,47 @@ function respond(value) {
   process.stdout.write(`${JSON.stringify(value)}\n`)
 }
 
+function refusal(event, message, blocking) {
+  const reason = `Cauce: ${message}`
+  if (event !== 'stop') return { decision: 'deny', reason }
+  // Un guard que bloquea marca su error con `blocked` (engine/hooks/run.js); cualquier otro es que el
+  // puente no llegó a juzgar nada. En `stop` los dos devolvían `continue`, y eso ata al agente: la
+  // raíz que no resuelve no se arregla sola, así que cada intento de cerrar repite el mismo error.
+  // El bloqueo sigue dando `continue` —es el mecanismo funcionando—; la falla deja cerrar y avisa.
+  return blocking ? { decision: 'continue', reason } : { decision: 'stop', reason }
+}
+
+// Lo que cada evento tiene que traer para que sus guards juzguen algo. `normalize` lee campos por nombre y
+// convierte en `''` el que no encuentra, así que una llamada con otra forma —un campo renombrado en una
+// actualización de Antigravity— llegaba vacía a los guards, ninguno frenaba y el puente respondía `allow`:
+// todos los guards apagados sin rastro (caso 200). Cerrado por defecto: sin lo que el evento juzga, se niega
+// y se dice qué llegó, que es lo que hace falta para enseñarle la forma nueva a `normalize`.
+//
+// Una entrada vacía no es una llamada con otra forma: no describe ninguna, y es como se invoca a mano, con
+// `OPS_HOOK_COMMAND` u `OPS_HOOK_FILE` (caso 198).
+const DESCRIBED_BY = {
+  'pre-shell': { field: 'command', names: 'CommandLine' },
+  'pre-files': { field: 'file_path', names: 'TargetFile ni AbsolutePath' },
+}
+
+// Un archivo sin su contenido tampoco se puede juzgar: los guards que miran qué se escribe —secretos,
+// migraciones— verían un texto vacío. Basta que el campo esté; vacío es un archivo vacío.
+const CONTENT_FIELDS = ['CodeContent', 'ReplacementContent', 'ReplacementChunks']
+
+function undescribed(event, input, normalized) {
+  const need = DESCRIBED_BY[event]
+  if (!need || !Object.keys(input).length) return ''
+  const fields = (input.toolCall && input.toolCall.args) || {}
+  const args = Object.keys(fields)
+  const missing = !normalized.tool_input[need.field] ? need.names
+    : event === 'pre-files' && !CONTENT_FIELDS.some((field) => field in fields)
+      ? 'CodeContent, ReplacementContent ni ReplacementChunks' : ''
+  if (!missing) return ''
+  const received = args.length ? `toolCall.args trae ${args.join(', ')}` : `llegó ${Object.keys(input).join(', ')}`
+  return `la llamada no trae ${missing}, así que no hay nada que juzgar y no se autoriza (${received}). Si `
+    + 'Antigravity cambió el formato de sus llamadas, el puente tiene que aprenderlo en normalize().'
+}
+
 function evaluate(event, input) {
   try {
     const root = findRoot(input)
@@ -141,23 +196,30 @@ function evaluate(event, input) {
     const hooks = runtimeAt(root)
     const normalized = normalize(input, root)
     if (!hooks.hookGroups[event]) throw new Error(`Evento Antigravity desconocido: ${event || '(vacío)'}`)
+    const missing = undescribed(event, input, normalized)
+    if (missing) throw new Error(missing)
     hooks.executeAll([event], normalized)
     return event === 'stop' ? { decision: 'stop' } : { decision: 'allow' }
   } catch (error) {
-    const reason = `Cauce: ${error.message}`
-    if (event !== 'stop') return { decision: 'deny', reason }
-    // Un guard que bloquea marca su error con `blocked` (engine/hooks/run.js); cualquier otro es que el
-    // puente no llegó a juzgar nada. En `stop` los dos devolvían `continue`, y eso ata al agente: la
-    // raíz que no resuelve no se arregla sola, así que cada intento de cerrar repite el mismo error.
-    // El bloqueo sigue dando `continue` —es el mecanismo funcionando—; la falla deja cerrar y avisa.
-    return error.blocked ? { decision: 'continue', reason } : { decision: 'stop', reason }
+    return refusal(event, error.message, error.blocked)
   }
 }
 
-function main() {
-  respond(evaluate(process.argv[2], readInput()))
+async function main(event = process.argv[2]) {
+  let input
+  try {
+    const engine = inputReader()
+    const usage = 'pasale el JSON de Antigravity —printf \'%s\' '
+      + `'{"toolCall":{"args":{"CommandLine":"…"}}}' | node hook.js ${event || '<evento>'}—`
+    input = await engine.readInput(process.stdin, engine.FIRST_BYTE_MS, usage)
+  } catch (error) {
+    // El lector del motor marca `blocked` lo que no pudo leer, porque para un guard eso es bloquear. Acá
+    // es el puente sin nada que juzgar, y en `stop` eso deja cerrar: reintentar no arregla la entrada.
+    return respond(refusal(event, error.message, false))
+  }
+  respond(evaluate(event, input))
 }
 
 if (require.main === module) main()
 
-module.exports = { evaluate, findRoot, normalize }
+module.exports = { evaluate, findRoot, normalize, inputReader }

package/automatization/runners/antigravity/manifest.json

@@ -52,6 +52,7 @@
   "roleSkills": ".agents/plugins/cauce/skills",
   "activation": {
     "hint": "agy plugin install .agents/plugins/cauce",
+    "registered": "~/.gemini/config/plugins/cauce",
     "verify": [
       "plugin",
       "list"

package/automatization/shared/acceptance.js

@@ -0,0 +1,26 @@
+// Cómo se lee una aceptación, compartido por las dos puntas que la juzgan: `check`, que avisa sobre la
+// cola, y `autobuild`, que la manda a Verify. Vive acá y no en el motor porque el recorrido no puede hacer
+// `require` —se renderiza con `{{INCLUDE:}}`— y el motor sí puede leer este archivo: lo carga
+// `engine/planning/acceptance.js`. Escrito dos veces, una copia dejaba de reconocer lo que la otra pedía
+// escribir, que es exactamente el caso 195: `check` ofrecía una marca que el recorrido no conocía.
+
+// Una condición por tramo separado con `;`, el grano con el que Verify contrasta —su `uncovered` enumera
+// criterios— y con el que `check` avisa.
+const acceptanceConditions = (acceptance) => String(acceptance || '').split(';')
+  .map((one) => one.trim()).filter(Boolean)
+
+// La salida explícita, con la forma que el repositorio ya usa dos veces: `(sin partir: …)` para el umbral
+// de R17 y `n/a — razón` para `tests:` y `commit:`. Acá vale lo mismo que allá —«como lleva su razón
+// escrita se lee en el propio artefacto sin que nadie la cruce»— y por eso no se intenta adivinar si la
+// prosa excluye a Verify. Adivinarlo es lo que no se puede: la única aceptación real que nombra el commit
+// lo hace justamente para decir que no es condición de Verify, y cualquier lista de frases que la
+// reconociera enseñaría a escribir esa frase exacta para silenciar el aviso.
+const OUT_OF_VERIFY = /\(fuera de verify:\s*[^)]+\)/i
+
+// Lo que no se ejecuta, y por eso lo único que un criterio `no-surface` puede haber producido (caso 189).
+// Es la lista a favor y no la de lo ejecutable a propósito (R27): un `.sql` de migración, un workflow en
+// YAML, un `Dockerfile`, un `Makefile` o un `.json` de configuración se ejecutan sin parecer código, y una
+// lista de lo ejecutable dejaría afuera lo que venga después. Ampliarla es un cambio con su razón al lado.
+// Las imágenes entraron porque un ADR suele traer su diagrama, y sin ellas ese commit contaba como código.
+// Lo que no tiene extensión sigue contando como ejecutable: `Makefile` y `Dockerfile` no la tienen.
+const NON_EXECUTABLE = ['.md', '.txt', '.adoc', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp']

package/automatization/workflows/autobuild.js

@@ -28,6 +28,7 @@ export const meta = {
 
 {{INCLUDE:shared/workflow-root.js}}
 {{INCLUDE:shared/inbox.js}}
+{{INCLUDE:shared/acceptance.js}}
 const CONFIG = `${ROOT}/ops.config.json`
 const P = `${ROOT}/planning`
 const ORG = `${ROOT}/organization`
@@ -190,19 +191,28 @@ const REVIEWED = { ...DECISION, required: [...DECISION.required, 'rules'],
 // menos —o que ni existe— sale verde igual, y el guard de verify tampoco lo ve porque también mira exit
 // codes. Por eso `uncovered` se contrasta contra la aceptación leyendo el fuente, no la salida (R9).
 const VERIFY = {
-  type: 'object', additionalProperties: false, required: ['passed', 'commands', 'details', 'uncovered'],
+  type: 'object', additionalProperties: false, required: ['passed', 'commands', 'details', 'uncovered', 'covered'],
   properties: {
     passed: { type: 'boolean' }, details: { type: 'string' },
-    // Dos causas que se leen igual en el resultado y piden cosas opuestas: a una le falta trabajo que
-    // el propio recorrido puede hacer, a la otra le falta una decisión que no es suya. Sin separarlas,
-    // la corrida frena por las dos y una persona termina resolviendo lo que se resolvía solo.
+    // Tres causas que se leen igual en el resultado y piden cosas distintas: a una le falta trabajo que
+    // el propio recorrido puede hacer, a otra le falta una decisión que no es suya, y la tercera no tiene
+    // prueba posible porque su entregable no se ejecuta —un ADR, una política—. Sin separarlas, la corrida
+    // frena por las tres, una persona resuelve lo que se resolvía solo y la tarea de decisión no cierra
+    // nunca (caso 189). `reason` es lo que Done escribe en `tests: n/a — <razón>`.
     uncovered: { type: 'array', items: { type: 'object', additionalProperties: false,
       required: ['criterion', 'cause'],
       properties: {
         criterion: { type: 'string' },
-        cause: { type: 'string', enum: ['missing-test', 'ambiguous'] },
+        cause: { type: 'string', enum: ['missing-test', 'ambiguous', 'no-surface'] },
+        reason: { type: 'string' },
       },
     } },
+    // El mapeo que Verify arma al contrastar y del que sale `tests: CN → prueba`. Sin viajar, Done lo
+    // componía de memoria (hallazgo del 189).
+    covered: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['criterion', 'test'],
+      properties: { criterion: { type: 'string' }, test: { type: 'string' } },
+    } },
     commands: { type: 'array', items: { type: 'object', required: ['cmd', 'exitCode'], properties: {
       cmd: { type: 'string' }, exitCode: { type: 'integer' }, note: { type: 'string' },
       ranTests: { type: 'boolean' },
@@ -582,13 +592,13 @@ while (rounds++ < MAX_TASKS) {
   // por eso perder la carrera no es un error: se relee y se sigue con la que quedó libre.
   if (!planning.claimed && !planning.wipActive) {
     phase('Claim')
-    const reserva = await write(
+    const claim = await write(
       `Corré "node tools/ops.js claim ${P} ${task.id}" desde ${ROOT}. No escribas ningún archivo vos: lo ` +
       `escribe el comando. claimed=true sólo con exit 0; si falla porque la tomó otro, claimed=false y ` +
       `copiá el mensaje en details.`,
       { schema: CLAIM, label: `claim:${task.id}` },
     )
-    if (!reserva || !reserva.claimed) {
+    if (!claim || !claim.claimed) {
       planning = await readContext()
       if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
       // Perder la carrera es legítimo y se ve en que la cola pasa a ofrecer **otra** tarea: quien la
@@ -607,7 +617,7 @@ while (rounds++ < MAX_TASKS) {
       if (planning.hasTask && planning.slug === task.id && !planning.claimed) {
         return stop('claim-stuck', `${task.id} sigue siendo la próxima tarea y no se pudo reclamar. `
           + `context la ofrece y claim la rechaza, así que repetir no cambia nada. `
-          + `El reclamo contestó: ${(reserva && reserva.details) || '(sin detalle)'}`)
+          + `El reclamo contestó: ${(claim && claim.details) || '(sin detalle)'}`)
       }
       // Con qué sigue, que es lo que cambia respecto de lo que esperaba quien autorizó la corrida: se
       // pidió un hito y se va a construir otra tarea de ese hito. Sin decirlo, el cambio sólo aparece al
@@ -721,12 +731,12 @@ while (rounds++ < MAX_TASKS) {
 
   const planRejected = async (reason, unit, found) => {
     const detail = found.join('; ') || 'sin condiciones nombradas'
-    const nota = await registerHuman(
+    const note = await registerHuman(
       `Registrá ${unit.id} en ${HUMAN}: nadie pudo escribir un plan que sobreviva a la crítica. `
       + `Motivo: ${detail}. La acción humana es revisar si la unidad son dos resultados con vidas `
       + `distintas y partirla, o dejarla entera con la razón escrita.`, 'plan-human', unit.id)
     await releaseBlocked()
-    return stop(reason, `${detail}${nota}`)
+    return stop(reason, `${detail}${note}`)
   }
 
   if (!planning.wipActive) {
@@ -741,11 +751,11 @@ while (rounds++ < MAX_TASKS) {
       )
       if (!ready) return stop('agent-unavailable', 'Ready no devolvió resultado')
       if (!ready.ready) {
-        const nota = await registerHuman(
+        const note = await registerHuman(
           `Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
           'ready-human', task.id)
         await releaseBlocked()
-        return stop('not-ready', `${ready.reason}${nota}`)
+        return stop('not-ready', `${ready.reason}${note}`)
       }
       if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
     }
@@ -1045,11 +1055,11 @@ while (rounds++ < MAX_TASKS) {
     if (filed.length) {
       // La nota que devuelve viaja al hecho: sin ella la entrega afirma una fila que el disco no tiene,
       // que es el caso 087 entrando por otra puerta.
-      const nota = await registerHuman(`Registrá en ${HUMAN} una fila por cada decisión que la revisión de `
+      const note = await registerHuman(`Registrá en ${HUMAN} una fila por cada decisión que la revisión de `
         + `${task.id} dejó abierta, con qué la cierra y quién puede tomarla. La primera columna nunca es `
         + `${task.id} —el porqué es el mismo que en Build—: va la épica, el hito o el recorrido al que `
         + `alcanza. No inventes responsables ni fechas: ${JSON.stringify(filed)}`, 'review-human')
-      decidedNote = `${nota}`
+      decidedNote = `${note}`
     }
     reviewFact = `${review.verdict} por ${cast.review}, sobre ${review.consulted.join(', ')}`
       + (filed.length ? ` · ${filed.length} decisión(es) registrada(s)${decidedNote}` : '')
@@ -1083,11 +1093,25 @@ while (rounds++ < MAX_TASKS) {
   }
 
   phase('Verify')
+  // Lo declarado `(fuera de verify: …)` se separa acá y no se le explica a Verify: la aceptación es texto
+  // conocido antes de preguntar, y dejar que el modelo reconozca la marca en la respuesta es apostar a que
+  // enumere los criterios con el mismo corte. `check` ofrecía la marca y el recorrido la mandaba igual,
+  // así que la condición terminaba en `uncovered` y la corrida en `verify-hollow` (caso 195).
+  const conditions = acceptanceConditions(task.acceptance)
+  const outOfVerify = conditions.filter((one) => OUT_OF_VERIFY.test(one))
+  const checkable = outOfVerify.length
+    ? conditions.filter((one) => !OUT_OF_VERIFY.test(one)).join('; ')
+      || 'ninguna: todas se declararon fuera de verify'
+    : task.acceptance
   const VERIFY_ASK = `${asRole(cast.verify)}Abrí el fuente de los tests que la tarea agregó o cambió y ` +
     `contrastá cada criterio ` +
     `de aceptación contra sus aserciones: en uncovered va el criterio que ningún test codifica, con su causa ` +
     `—missing-test si el test falta o no asercia la propiedad, ambiguous si el criterio no dice qué habría ` +
-    `que aserciar—. Un test que pasa sin aserciarla no la cubre. Después corré los gates reales de ${task.service}. ` +
+    `que aserciar, no-surface si se cumple en un artefacto que no se ejecuta, como un documento o una ` +
+    `decisión escrita, y con reason diciendo cuál—. no-surface vale sólo si la tarea no tocó ningún archivo ` +
+    `que no termine en ${NON_EXECUTABLE.join(', ')}; con cualquier otro en el diff es missing-test. En ` +
+    `covered va cada criterio que un test sí codifica, con el nombre de ese test. ` +
+    `Un test que pasa sin aserciarla no la cubre. Después corré los gates reales de ${task.service}. ` +
     // Descubrir la puerta es trabajo de modelo repetido en cada tarea sobre una respuesta que no cambia,
     // y encima adivinable: el proyecto la declara en `verify` y ahí deja de adivinarse. Cuando no la
     // declara se vuelve a descubrir, que es lo que pasaba siempre.
@@ -1100,7 +1124,7 @@ while (rounds++ < MAX_TASKS) {
     `Leé los exit codes de verdad. ` +
     `passed=true exige comandos corridos y ninguna regresión causada por la tarea. Marcá ranTests en el ` +
     `comando que haya corrido las pruebas, sea cual sea su nombre. ` +
-    `Aceptación: ${task.acceptance}.`
+    `Aceptación: ${checkable}.`
   let verified = await run(VERIFY_ASK, { schema: VERIFY, label: 'verify' })
   if (!verified) return stop('agent-unavailable', 'Verify no devolvió resultado')
   // Un criterio que nadie sabe cómo aserciar no es trabajo que falta sino una definición que falta, y
@@ -1108,14 +1132,18 @@ while (rounds++ < MAX_TASKS) {
   // hacer parar a una persona por eso le cobra una interrupción por algo que se resolvía solo.
   const ambiguous = verified.uncovered.find((entry) => entry.cause === 'ambiguous')
   if (ambiguous) {
-    const nota = await registerHuman(
+    const note = await registerHuman(
       `Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
       `que aserciar, y hace falta la decisión que lo fija.`, 'verify-human', task.id)
-    return stop('acceptance-ambiguous', `${ambiguous.criterion}${nota}`)
+    return stop('acceptance-ambiguous', `${ambiguous.criterion}${note}`)
   }
-  if (verified.uncovered.length) {
+  // Lo que no tiene superficie no frena ni rebota: viaja a Done, que lo escribe como `tests: n/a`. Se filtra
+  // por exclusión y no por `missing-test` para que una causa que no se conozca siga frenando (R27). Que
+  // el modelo no lo use para cerrar sin pruebas lo sostiene `check`, que mira qué tocó el commit.
+  const lacking = () => verified.uncovered.filter((entry) => entry.cause !== 'no-surface')
+  if (lacking().length) {
     await run(`${asRole(cast.build)}Escribí sólo las pruebas que faltan en ${task.id}, con el mismo rojo ` +
-      `previo, y no toques el código de producción: ${verified.uncovered.map((e) => e.criterion).join('; ')}`,
+      `previo, y no toques el código de producción: ${lacking().map((e) => e.criterion).join('; ')}`,
       { label: 'missing-tests' })
     verified = await run(VERIFY_ASK, { schema: VERIFY, label: 'verify' })
     if (!verified) return stop('agent-unavailable', 'la segunda pasada de Verify no devolvió resultado')
@@ -1127,21 +1155,29 @@ while (rounds++ < MAX_TASKS) {
   if (build.redFirst.length && !ranTests) {
     return stop('verify-untested', `${task.id} escribió pruebas y ningún gate corrió una`)
   }
-  if (verified.uncovered.length) {
-    return stop('verify-hollow', `sin test que lo codifique: ${verified.uncovered.map((e) => e.criterion).join('; ')}`)
+  if (lacking().length) {
+    return stop('verify-hollow', `sin test que lo codifique: ${lacking().map((e) => e.criterion).join('; ')}`)
   }
+  const noSurface = verified.uncovered.filter((entry) => entry.cause === 'no-surface')
+  const covered = verified.covered || []
+  // Toda la tarea sin superficie: no hay comportamiento que ejercitar, y saltear QA en silencio dejaría sin
+  // mirar lo único que se puede mirar, que el documento esté y diga lo que la aceptación enumera.
+  const onlyDocument = noSurface.length > 0 && !covered.length
 
   // QA ejercita comportamiento, y lo mecánico no lo cambia: el valor literal que la aceptación nombra
   // ya lo comprobó Verify contra el test, y en `directo` además lo mira el revisor que nombra el cast.
   let qa = { passed: true, evidence: 'carril mecánico: la aceptación queda comprobada en Verify' }
   if (!mechanical) {
     phase('QA')
-    qa = await run(
-      `${asRole(cast.qa)}${lite
+    qa = await run(onlyDocument
+      ? `${asRole(cast.qa)}${task.id} no tiene superficie ejecutable: comprobá que el documento existe y cubre ` +
+        `cada elemento que la aceptación enumera, y en evidence decí cuáles encontraste y dónde. ` +
+        `Aceptación: ${checkable}.`
+      : `${asRole(cast.qa)}${lite
         ? 'Hacé la comprobación de aceptación real más barata'
         : 'Ejercitá el comportamiento real que ve quien lo usa'} para ` +
       `${task.id}. Las pruebas unitarias solas no son QA. Levantá el mínimo runtime necesario y bajalo ` +
-      `después. Aceptación: ${task.acceptance}.`,
+      `después. Aceptación: ${checkable}.`,
       { schema: QA, label: 'qa' },
     )
     if (!qa) return stop('agent-unavailable', 'QA no devolvió resultado')
@@ -1169,7 +1205,14 @@ while (rounds++ < MAX_TASKS) {
     `"node tools/ops.js release ${P} ${task.id}". En decisions no nombres una fase ni un cargo ` +
     `que no figure en estos hechos. Hechos: lane=${planning.lane || 'sin clasificar'}; ` +
     `review=${reviewFact}; fases=${ran.join(' → ')}; build=${build.summary}; ` +
-    `verify=${JSON.stringify(verified.commands)}; qa=${qa.evidence}; commit=${commit.hash || commit.reason}.`,
+    `verify=${JSON.stringify(verified.commands)}; cubiertos=${JSON.stringify(covered)}; ` +
+    (noSurface.length ? `sin-superficie=${JSON.stringify(noSurface.map(({ criterion, reason }) => ({
+      criterion, reason: reason || 'no se ejecuta' })))}; ` : '') +
+    (outOfVerify.length ? `fuera-de-verify=${JSON.stringify(outOfVerify)}; ` : '') +
+    `qa=${qa.evidence}; commit=${commit.hash || commit.reason}. En tests rastreá cada criterio con la ` +
+    `prueba que cubiertos le asigna` +
+    (noSurface.length ? ', y los de sin-superficie con tests: n/a — <razón>' : '') +
+    (outOfVerify.length ? '; cada condición de fuera-de-verify queda cumplida en tests, qa o commit' : '') + '.',
     { label: 'done' },
   )
   completed.push(task.id)

package/engine/automation/index.js

@@ -25,6 +25,7 @@ const {
 // Qué le falta a la superficie de automatización, que no comparte ayudantes con los tres verbos que
 // escriben. Se reexporta para que sus consumidores sigan pidiéndoselo a este módulo.
 const { check } = require('./check')
+const { registrationProblems } = require('./registration')
 
 // Ejecuta el puente del runner tal como él lo invoca, y desde otra carpeta. Instalado no es lo mismo que
 // operativo: un bridge que el runner no puede lanzar —porque su ruta es relativa y el cwd es otro, o
@@ -48,7 +49,12 @@ function probeBridge(paths, runner) {
   const launchDirs = [paths.install, path.dirname(script)]
   for (const event of hookEvents) {
     for (const cwd of launchDirs) {
-      const payload = JSON.stringify({ toolCall: { args: { CommandLine: 'ls', Cwd: paths.install } } })
+      // Una llamada inocua para el evento que la juzga, y ninguna para los demás: un `pre-files` con un
+      // comando no describe ningún archivo, y el puente niega lo que no sabe describir (caso 200). La
+      // entrada vacía es la forma legítima de no describir nada, y ejercita igual el arranque y la raíz.
+      const payload = JSON.stringify(event === 'pre-shell'
+        ? { toolCall: { args: { CommandLine: 'ls', Cwd: paths.install } } }
+        : {})
       const result = spawnSync(process.execPath, [script, event], { cwd, input: payload, encoding: 'utf8' })
       let response = {}
       try { response = JSON.parse((result.stdout || '').trim()) } catch { response = {} }
@@ -68,7 +74,9 @@ function probeBridge(paths, runner) {
   return problems
 }
 
-function doctor(root, name, output = console) {
+// `afterInstall` es la llamada con la que cierra `install`: ahí una copia registrada vieja es el paso que sigue
+// —registrar lo que se acaba de instalar—, no una instalación rota, así que se avisa en vez de fallar.
+function doctor(root, name, output = console, { afterInstall = false } = {}) {
   const runner = runnerManifest(root, name)
   const paths = runnerPaths(root, name, runner)
   const errors = []
@@ -151,6 +159,7 @@ function doctor(root, name, output = console) {
   }
   // Un puente que no responde niega cada llamada del runner: es error, no advertencia.
   for (const problem of probeBridge(paths, runner)) errors.push(problem)
+  for (const problem of registrationProblems(paths, runner)) (afterInstall ? warnings : errors).push(problem)
 
   const executable = spawnSync(
     'sh',