@ingeniomaps/cauce 0.98.0 → 0.99.1

package/engine/hooks/secrets-shell.js

@@ -67,7 +67,8 @@ function secretsShell(input) {
   if (!left.length) return
   block(`el comando lee ${left.join(', ')}, que 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', left, input, left.filter((one) => !UNRESOLVED.test(one))))
+    + AP.HOW('OPS_SECRETS_READ_OVERRIDE', left, input, left.filter((one) => !UNRESOLVED.test(one)),
+      { durable: true }))
 }
 
 module.exports = { secretsShell }

package/engine/hooks/self-approval.js

@@ -6,8 +6,8 @@
 //
 // Lo preguntan los dos guards de límites —el que mira un `Write` y el que mira el destino de un comando—,
 // que ya son los que deciden dónde puede caer una escritura. La persona edita el archivo a mano, que ningún
-// hook ve, o se lo pide al agente nombrándolo en el chat. El registro del chat no lo escribe nunca una
-// herramienta.
+// hook ve, o se lo pide al agente en el chat: nombrándolo, o confirmando el bloqueo que le mostró qué iba a
+// escribir. El registro del chat no lo escribe nunca una herramienta.
 //
 // **Nombrar el archivo autoriza el archivo, no lo que se escribe adentro**, y hasta 0.83.0 eso era todo lo
 // que se comprobaba: la persona pedía agregar una ruta inocua, el agente escribía `push origin main`, y esa
@@ -34,6 +34,12 @@ const UNASKED = (file, missing) => `${file} es la aprobación de una persona y e
   + 'Escribí sólo lo que ella nombró en su mensaje. Si hacen falta las otras, decile cuáles y por qué, y '
   + 'pedile que lo confirme con sus palabras: si lo que contesta es un sí, reintentá la misma escritura y pasa.'
 
+// Lo mismo que `UNASKED`, para cuando además el archivo no se nombró: ninguna de las líneas está pedida.
+const UNNAMED = (file, lines) => `${file} es la aprobación de una persona, y escribírsela es aprobarse solo. `
+  + 'Esta escritura agrega:\n' + lines.map((line) => `  ${line}\n`).join('')
+  + 'Decile qué querés dejar aprobado y por qué, y pedile que lo confirme con sus palabras: si lo que contesta '
+  + 'es un sí, reintentá la misma escritura y pasa. Si no, que lo edite ella.'
+
 // **Por shell se frena toda escritura.** Es la misma decisión que toma `ops-config`, y por qué un comando
 // no se puede comparar está escrito allá. Lo que la trae hasta acá es que el contenido es lo único que
 // separa la línea que la persona pidió de la que el agente se escribe solo.
@@ -49,15 +55,31 @@ function approvalRoot(input, file) {
 }
 
 // Lo que las dos vías deciden igual: el registro del chat no se escribe nunca, y la aprobación sólo si la
-// persona la nombró en su mensaje.
+// persona la nombró en su mensaje o confirmó el bloqueo que la frenaba.
 //
 // Se pregunta sin conceder: una concesión que sobreviviera al mensaje convertiría «agregá src/x.js a
 // .ops-approval» en permiso para escribirle después cualquier otra línea, que es aprobarse solo por la
 // puerta de al lado.
-function common(input, file) {
-  if (file === CHAT.DIR || file.startsWith(`${CHAT.DIR}${path.sep}`)) return CHAT_RECORD(file)
-  if (!approvalRoot(input, file)) return ''
-  return CHAT.authorized(input, [file]).length ? '' : SELF(file)
+const named = (input, file) => CHAT.authorized(input, [file]).length > 0
+const chatRecord = (file) => file === CHAT.DIR || file.startsWith(`${CHAT.DIR}${path.sep}`)
+
+// Lo que esta escritura agrega al archivo. **Lo que ya estaba en disco no se vuelve a nombrar**: esta
+// escritura no lo agrega, y exigirlo obligaría a repetir el archivo entero para sumar una línea. Quitar
+// tampoco se pregunta: una aprobación más corta autoriza menos.
+function added(input, root) {
+  const filed = new Set(AP.read(root))
+  return AP.lines(contentOf(input)).filter((line) => !filed.has(line))
+}
+
+// El archivo sin nombrar frenaba sin anotar nada, así que la salida que el propio mensaje ofrecía
+// —confirmar el bloqueo— no aprobaba nada: el «dale» siguiente volvía a frenar igual, y la persona sólo
+// podía destrabarlo con la frase exacta que nombra el archivo con un verbo (caso 202). Se anota el archivo
+// con las líneas que trae, que es lo que la confirmación va a aprobar y lo que el mensaje le muestra.
+function unnamed(input, root, file) {
+  const lines = added(input, root)
+  const held = lines.length ? CHAT.hold(input, [file, ...lines]) : false
+  if (!held || held.dropped.length) return SELF(file)
+  return UNNAMED(file, lines)
 }
 
 // Una línea de push no se pregunta como una ruta: `mentions` compara también el basename, así que para
@@ -67,10 +89,6 @@ const isPush = (line) => /^push\s+\S+\s+\S+$/.test(line)
 
 // Por qué no se puede escribir este contenido, o vacío.
 //
-// **Lo que ya estaba en disco no se vuelve a nombrar**: esta escritura no lo agrega, y exigirlo obligaría a
-// repetir el archivo entero para sumar una línea. Quitar tampoco se pregunta: una aprobación más corta
-// autoriza menos.
-//
 // **Un fragmento sí se juzga, al revés que en `ops.config.json`.** Allá el archivo entrante se compara
 // entero porque una llave cambia de sentido según lo que la rodea, y un `Edit` manda un pedazo; acá cada
 // línea vale por sí sola, así que el pedazo que llega es exactamente lo que se agrega. Lo que no se puede
@@ -80,12 +98,11 @@ const isPush = (line) => /^push\s+\S+\s+\S+$/.test(line)
 // Y se pregunta sin heredar lo que la sesión concedió antes: una línea acá la leen todos los guards y llega
 // hasta la rama viva, así que tiene que ser la que la persona dijo en el mensaje en curso.
 function unasked(input, root, file) {
-  const filed = new Set(AP.read(root))
-  const added = AP.lines(contentOf(input)).filter((line) => !filed.has(line))
-  const pushes = CHAT.authorized(input, added.filter(isPush), { asked: CHAT.ordersPush, inherit: false })
-  const paths = CHAT.authorized(input, added.filter((line) => !isPush(line)), { inherit: false })
+  const lines = added(input, root)
+  const pushes = CHAT.authorized(input, lines.filter(isPush), { asked: CHAT.ordersPush, inherit: false })
+  const paths = CHAT.authorized(input, lines.filter((line) => !isPush(line)), { inherit: false })
   const cleared = new Set([...pushes, ...paths].map((one) => one.item))
-  const missing = added.filter((line) => !cleared.has(line))
+  const missing = lines.filter((line) => !cleared.has(line))
   if (!missing.length) return ''
   // El archivo se anota junto con las líneas: sin él, el «dale» aprobaría las líneas y el guard volvería a
   // frenar por el archivo, que en ese mensaje ya nadie nombra.
@@ -95,17 +112,17 @@ function unasked(input, root, file) {
 
 // Por qué el agente no puede escribir en `file` con la herramienta de edición, o vacío.
 function selfApproval(input, file) {
-  const stop = common(input, file)
-  if (stop) return stop
+  if (chatRecord(file)) return CHAT_RECORD(file)
   const root = approvalRoot(input, file)
-  return root ? unasked(input, root, file) : ''
+  if (!root) return ''
+  return named(input, file) ? unasked(input, root, file) : unnamed(input, root, file)
 }
 
 // Lo mismo para el destino de un comando, o vacío.
 function selfApprovalShell(input, file) {
-  const stop = common(input, file)
-  if (stop) return stop
-  return approvalRoot(input, file) ? BY_COMMAND(file) : ''
+  if (chatRecord(file)) return CHAT_RECORD(file)
+  if (!approvalRoot(input, file)) return ''
+  return named(input, file) ? BY_COMMAND(file) : SELF(file)
 }
 
 module.exports = { selfApproval, selfApprovalShell }

package/engine/hooks/verify.js

@@ -144,33 +144,90 @@ function commitTree(dir, input) {
   return { root: temp, temp, env: { pnpm_config_verify_deps_before_run: 'false' } }
 }
 
+// Dónde viven la consulta de sqlc y su generado lo declara cada proyecto en su config (`queries:` y
+// `gen.go.out`), y acá no se lee: no hay parser de YAML y no se agrega uno para un guard. Lo que se usa
+// en su lugar son dos hechos que no dependen del layout.
+//
+// La consulta se busca en `queries/` a cualquier profundidad —un monorepo la tiene en `api/db/queries/`
+// (caso 192)—, y sólo cuenta si el repositorio tiene un `sqlc.yaml`, `sqlc.yml` o `sqlc.json`, los tres
+// nombres que sqlc busca: sin esa condición, desanclar el patrón frenaría consultas de un reporte o
+// fixtures que nadie genera, y cada freno falso se resuelve aprobándolo. Un `queries:` con otro nombre de
+// carpeta sigue sin verse.
+//
+// El generado se reconoce por el nombre del archivo, no por su carpeta: sqlc escribe `<consulta>.sql.go`
+// donde diga `out`, y esperar una carpeta `sqlc/` frenaba al que la llamó de otro modo (caso 187). La
+// carpeta queda como respaldo. `.ts` o `.py` no: esos generadores son plugins y su nombre no se comprobó.
+const SQL_SOURCE = /(?:^|\/)queries\/.*\.sql$/i
+const SQL_GENERATED = /\.sql\.go$|(?:^|\/)(?:sqlc|generated)(?:\/|.*\.(?:go|ts|js|py)$)/i
+function usesSqlc(dir) {
+  // `top` porque `dir` puede ser un subdirectorio y el índice se pregunta entero; `glob` para que `**/`
+  // alcance también la raíz. Se lee el índice y no el disco: una config sin trackear no es del proyecto.
+  // Si git no contesta se asume que sí: un guard que no pudo mirar no afloja.
+  const listed = run('git', ['-C', dir, 'ls-files', '--',
+    ...['yaml', 'yml', 'json'].map((ext) => `:(top,glob)**/sqlc.${ext}`)], dir)
+  return !listed.ok || Boolean(listed.output.trim())
+}
+
+// Una especificación OpenAPI se reconoce por lo que declara y no por la carpeta: `api/` guarda también la
+// config de sqlc, un compose o fixtures, y cada uno pedía regenerar un cliente que no existe (caso 197). La
+// carpeta queda como filtro barato antes de leer nada. Un fragmento de una especificación partida con `$ref`
+// no declara nada, así que cuenta si su carpeta de primer nivel tiene en el índice una raíz que sí lo haga.
+// Se lee el índice y no el disco, que es lo que el commit graba. Si git no contesta, dispara: un guard que
+// no pudo mirar no afloja.
+const OPENAPI_CANDIDATE = /^(?:(?:openapi|api|spec)\/(?:.*\/)?[^/]+|openapi|swagger)\.ya?ml$/i
+const OPENAPI_ROOT = /^(?:openapi|swagger)\s*:/m
+
+function declaresOpenApi(dir, file) {
+  // Un archivo borrado figura como cambio y ya no está en el índice: lo que era se lee en `HEAD`.
+  for (const revision of ['', 'HEAD']) {
+    const shown = run('git', ['-C', dir, 'show', `${revision}:${file}`], dir)
+    if (shown.ok) return OPENAPI_ROOT.test(shown.output.slice(0, 4096))
+  }
+  return true
+}
+
+function changedOpenApiSpec(dir, staged) {
+  const candidates = staged.filter((file) => OPENAPI_CANDIDATE.test(file))
+  if (candidates.some((file) => declaresOpenApi(dir, file))) return true
+  // Una sola búsqueda en el índice por todas las carpetas, y no un `git show` por archivo: un `spec/` con
+  // cientos de fixtures costaba cientos de procesos por commit. `git grep` sale con 1 si no encuentra nada, y
+  // con cualquier otro código no pudo mirar, que dispara igual.
+  const folders = [...new Set(candidates.filter((file) => file.includes('/')).map((file) => file.split('/')[0]))]
+  if (!folders.length) return false
+  const found = run('git', ['-C', dir, 'grep', '--cached', '-l', '-E', '^(openapi|swagger)[[:space:]]*:', '--',
+    ...folders.flatMap((folder) => [`:(top,glob)${folder}/**/*.yaml`, `:(top,glob)${folder}/**/*.yml`])], dir)
+  if (found.ok) return Boolean(found.output.trim())
+  return found.status !== 1
+}
+
 function verify(input) {
   if (process.env.OPS_SKIP_VERIFY === '1') return
   const command = commandOf(input)
   if (!isCommit(command)) return
   const { dir, staged } = stagedForCommit(command, cwdOf(input))
-  const changedOpenApi = staged.some((file) => /^(?:openapi|api|spec)(?:\/.*)?\/[^/]+\.ya?ml$/i.test(file))
-    || staged.some((file) => /^(?:openapi|swagger)\.ya?ml$/i.test(file))
-  const changedSqlSource = staged.some((file) => /^(?:db\/queries|queries)\/.*\.sql$/i.test(file))
+  const changedOpenApi = changedOpenApiSpec(dir, staged)
+  const changedSqlSource = staged.some((file) => SQL_SOURCE.test(file)) && usesSqlc(dir)
   const hasApiGenerated = staged.some((file) => /(?:^|\/)[^/]*(?:generated|\.gen)\.(?:go|ts|js|py)$/i.test(file))
-  const hasSqlGenerated = staged.some((file) => /(?:^|\/)(?:sqlc|generated)(?:\/|.*\.(?:go|ts|js|py)$)/i.test(file))
+  const hasSqlGenerated = staged.some((file) => SQL_GENERATED.test(file))
   // Acá lo aprobado es el conjunto staged entero: decir «autorizo commitear exactamente estas rutas»
   // es lo que un gate en rojo necesita, y cambia en cuanto se stagea una más. La lista sale del índice
   // y no de una regla, que es lo que la vuelve una operación y no un permiso.
-  const sinAprobar = AP.pendingNow(opsRoot(input), staged, input)
-  const aprobado = !sinAprobar.length
-  if (changedOpenApi && !hasApiGenerated && !aprobado) {
+  const unapproved = AP.pendingNow(opsRoot(input), staged, input)
+  const approved = !unapproved.length
+  if (changedOpenApi && !hasApiGenerated && !approved) {
     block('Cambió una fuente OpenAPI/Swagger sin incluir código regenerado. Ejecuta el generador y '
-      + `stagea su salida.\n${AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input)}`)
+      + `stagea su salida.\n${AP.HOW('OPS_SKIP_VERIFY', unapproved, input)}`)
   }
-  if (changedSqlSource && !hasSqlGenerated && !aprobado) {
-    block('Cambió una consulta SQL fuente sin artefactos regenerados. Ejecuta el generador.\n'
-      + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
+  if (changedSqlSource && !hasSqlGenerated && !approved) {
+    block('Cambió una consulta SQL fuente sin artefactos regenerados: busqué en el índice un `*.sql.go`, '
+      + 'o algo bajo una carpeta `sqlc/` o `generated/`, y no hay ninguno. Si corriste `sqlc generate`, '
+      + 'stageá lo que escribió; si su `output_files_suffix` le cambia el nombre, esto no lo reconoce.\n'
+      + AP.HOW('OPS_SKIP_VERIFY', unapproved, input))
   }
   if (!staged.some((file) => /\.(?:ts|tsx|js|jsx|mjs|cjs|go|py|html|css|scss|prisma)$/.test(file))) return
   const { root, temp, env } = commitTree(dir, input)
   try {
-    verifyGates(root, dir, sinAprobar, env, input)
+    verifyGates(root, dir, unapproved, env, input)
   } finally {
     if (temp) fs.rmSync(temp, { recursive: true, force: true })
   }
@@ -201,7 +258,7 @@ const ERROR_LINE = /error|err[_!]|fail|abort|not found|cannot|no such/i
 const FAILED_TEST = /^(?:✖|not ok\b|--- FAIL:|● |× |\d+\) |FAILED )/
 const PASSED_TEST = /^(?:✔|ok\b|--- PASS:)|::\S+ PASSED\b/
 const MAX_LINE = 160
-function fallo(gate, result) {
+function failure(gate, result) {
   // La línea que empieza con `>` es el eco del script que npm y pnpm imprimen antes de correrlo, así
   // que lleva el comando entero y no dice nada de qué falló. Descartarla es lo que hace que la primera
   // coincidencia sea el error y no el comando — con el eco adentro, un script que **menciona** una
@@ -228,7 +285,7 @@ function howItReads(failures) {
     + 'una suite, así que mirá si llegaron a ejecutarse antes de aprobar esto como un rojo conocido.'
 }
 
-function verifyGates(root, dir, sinAprobar, env, input) {
+function verifyGates(root, dir, unapproved, env, input) {
   const ops = opsRoot(input)
   const failures = []
   if (fs.existsSync(path.join(root, 'package.json'))) {
@@ -240,19 +297,19 @@ function verifyGates(root, dir, sinAprobar, env, input) {
       if (!pkg.scripts || !pkg.scripts[script]) continue
       const result = run(pm, ['run', script], root, env)
       EV.record(ops, script, result.status, result.ms)
-      if (!result.ok) failures.push(fallo(script, result))
+      if (!result.ok) failures.push(failure(script, result))
     }
   } else if (fs.existsSync(path.join(root, 'go.mod'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^ci:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['ci'], root, env)
       EV.record(ops, 'make ci', result.status, result.ms)
-      if (!result.ok) failures.push(fallo('make ci', result))
+      if (!result.ok) failures.push(failure('make ci', result))
     } else {
       for (const args of [['test', './...'], ['build', './...']]) {
         const result = run('go', args, root, env)
         EV.record(ops, `go ${args[0]}`, result.status, result.ms)
-        if (!result.ok) failures.push(fallo(`go ${args[0]}`, result))
+        if (!result.ok) failures.push(failure(`go ${args[0]}`, result))
       }
     }
   } else if (fs.existsSync(path.join(root, 'pyproject.toml')) || fs.existsSync(path.join(root, 'requirements.txt'))) {
@@ -260,16 +317,16 @@ function verifyGates(root, dir, sinAprobar, env, input) {
     if (fs.existsSync(makefile) && /^test:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['test'], root, env)
       EV.record(ops, 'make test', result.status, result.ms)
-      if (!result.ok) failures.push(fallo('make test', result))
+      if (!result.ok) failures.push(failure('make test', result))
     }
   }
-  if (!failures.length || !sinAprobar.length) return
+  if (!failures.length || !unapproved.length) return
   // Se dice sobre qué corrió cuando no fue el árbol: un fallo que no se reproduce escribiendo el mismo
   // comando a mano se lee como que el guard miente, y lo que pasó es que midió lo que se va a grabar.
-  const donde = root === dir ? '' : '\nCorrió sobre el índice, que es lo que el commit graba: si en tu '
+  const where = root === dir ? '' : '\nCorrió sobre el índice, que es lo que el commit graba: si en tu '
     + 'directorio pasa, es que en disco tenés algo que no está staged.'
-  block(`Verify falló en ${path.basename(dir)}: ${howItReads(failures)}\nNo se commitea en rojo.${donde}\n`
-    + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
+  block(`Verify falló en ${path.basename(dir)}: ${howItReads(failures)}\nNo se commitea en rojo.${where}\n`
+    + AP.HOW('OPS_SKIP_VERIFY', unapproved, input))
 }
 
 module.exports = { verify }

package/engine/planning/acceptance.js

@@ -0,0 +1,18 @@
+'use strict'
+
+// El lado del motor de `automatization/shared/acceptance.js`: lo evalúa en vez de copiarlo. El archivo
+// declara constantes sueltas porque así lo incluye un recorrido, y un fragmento así no se puede
+// `require`; evaluado aparte da los mismos valores que recibe el recorrido renderizado.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const vm = require('node:vm')
+
+const SOURCE = path.join(__dirname, '..', '..', 'automatization', 'shared', 'acceptance.js')
+
+const { acceptanceConditions, OUT_OF_VERIFY, NON_EXECUTABLE } = vm.runInNewContext(
+  `${fs.readFileSync(SOURCE, 'utf8')}\n;({ acceptanceConditions, OUT_OF_VERIFY, NON_EXECUTABLE })`,
+  {}, { filename: SOURCE },
+)
+
+module.exports = { acceptanceConditions, OUT_OF_VERIFY, NON_EXECUTABLE }

package/engine/planning/contracts.js

@@ -4,6 +4,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const P = require('./parser')
 const { PLACEHOLDERS } = require('../core/onboarding')
+const { acceptanceConditions, OUT_OF_VERIFY, NON_EXECUTABLE } = require('./acceptance')
 
 const TEST_TRACE = /^(?:n\/a\s*[—-]\s*.+|(?:A|C\d+)\s*(?:→|->)\s*\S.+)$/i
 const DECISION_TRACE = /\[(?:fuente|supuesto):\s*[^\]]+\]/i
@@ -40,12 +41,13 @@ function validDecisionTrace(value) {
 // sha. La salida explícita existe porque hay tareas que no producen commit —abrir una fila en
 // HUMAN_ACTIONS, registrar un informe—, y forzarlas a llenar el campo produce un sha inventado, que es
 // peor que la ausencia: parece evidencia.
+// Se corta en cada `|`, y en un `;` sólo cuando detrás viene un sha: el `;` aparece también dentro del
+// paréntesis final —`(api@main; sin footer Task:)`— y cortar ahí convertiría una nota en un commit que
+// falta. Cada tramo responde por sí mismo; validar sólo el primero dejaba pasar la mitad sin artefacto.
+const commitParts = (value) => String(value || '').trim().split(/\s*(?:\||;(?=\s*[0-9a-f]{7,40}\s))\s*/)
+
 function validCommitTrace(value) {
-  // Se corta en cada `|`, y en un `;` sólo cuando detrás viene un sha: el `;` aparece también dentro del
-  // paréntesis final —`(api@main; sin footer Task:)`— y cortar ahí convertiría una nota en un commit que
-  // falta. Cada tramo responde por sí mismo; validar sólo el primero dejaba pasar la mitad sin artefacto.
-  return String(value || '').trim().split(/\s*(?:\||;(?=\s*[0-9a-f]{7,40}\s))\s*/)
-    .every((part) => COMMIT_TRACE.test(part.trim()))
+  return commitParts(value).every((part) => COMMIT_TRACE.test(part.trim()))
 }
 
 // Los criterios que la evidencia realmente rastrea. `n/a — razón` no rastrea ninguno a propósito: es
@@ -118,8 +120,8 @@ function doneEntryErrors(entry, epics = []) {
 // Un carril declara **cuánta ceremonia** merecía la tarea; `n/a` en `review:` dice que la revisión no
 // corrió. `express` es el único que no convoca revisor, así que en los otros tres esa combinación es la
 // ADR incumplida, escrita en el propio registro.
-const CONVOCAN_REVISOR = ['directo', 'lite', 'full']
-const SIN_REVISION = /^n\/a\b/i
+const REVIEWED_LANES = ['directo', 'lite', 'full']
+const NO_REVIEW = /^n\/a\b/i
 
 // Lo que el registro puede decir sobre la ceremonia, y lo que todavía no. Los dos campos avisan en vez de
 // fallar por lo que dice `doneEntryErrors`, y cuentan en vez de listar porque al principio son todas: lo
@@ -134,22 +136,22 @@ const SIN_REVISION = /^n\/a\b/i
 // completo, pero eso lo sabe el recorrido y no la entrada. Avisar sobre lo que hay que deducir es lo que
 // llena de ruido un aviso que después nadie mira.
 function doneCeremonyWarnings(done, adopted = new Set()) {
-  const propias = done.entries.filter((entry) => !adopted.has(entry.slug))
+  const own = done.entries.filter((entry) => !adopted.has(entry.slug))
   const warnings = []
-  const sinLane = propias.filter((entry) => !entry.lane)
-  if (sinLane.length) {
-    warnings.push(`planning/done: ${sinLane.length} entrada(s) sin lane:, así que no se puede comprobar `
+  const withoutLane = own.filter((entry) => !entry.lane)
+  if (withoutLane.length) {
+    warnings.push(`planning/done: ${withoutLane.length} entrada(s) sin lane:, así que no se puede comprobar `
       + 'sobre el registro que la ceremonia que recibieron fue la que su superficie pedía (OPS-006)')
   }
-  const sinReview = propias.filter((entry) => !entry.review)
-  if (sinReview.length) {
-    warnings.push(`planning/done: ${sinReview.length} entrada(s) sin review:, que es la dimensión con la `
+  const withoutReview = own.filter((entry) => !entry.review)
+  if (withoutReview.length) {
+    warnings.push(`planning/done: ${withoutReview.length} entrada(s) sin review:, que es la dimensión con la `
       + 'que OPS-006 dice que se mide si el carril elegido fue el correcto')
   }
-  const saltadas = propias.filter((entry) => CONVOCAN_REVISOR.includes(entry.lane)
-    && entry.review && SIN_REVISION.test(entry.review))
-  if (saltadas.length) {
-    warnings.push(`planning/done: ${saltadas.map((entry) => entry.slug).join(', ')} declara(n) un carril `
+  const skipped = own.filter((entry) => REVIEWED_LANES.includes(entry.lane)
+    && entry.review && NO_REVIEW.test(entry.review))
+  if (skipped.length) {
+    warnings.push(`planning/done: ${skipped.map((entry) => entry.slug).join(', ')} declara(n) un carril `
       + 'que convoca revisor y una revisión que no corrió: el carril reduce ceremonia, nunca evidencia')
   }
   return warnings
@@ -165,14 +167,6 @@ const POST_VERIFY = [
   [/\bel reclamo\b|\bclaims\//i, 'el reclamo'],
 ]
 
-// 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
-
 // Una condición de aceptación que nombra el registro en vez del producto no se puede cumplir nunca: se
 // comprueba en Verify, que corre antes que Commit y que Done. El recorrido lo detecta —y hace bien—, pero
 // recién ahí: en la corrida que originó esto fueron 1,2 M de tokens y once agentes para terminar con el
@@ -194,11 +188,11 @@ function unverifiableAcceptance(milestones = []) {
   const warnings = []
   for (const milestone of milestones) {
     for (const task of milestone.tasks || []) {
-      for (const condition of String(task.acceptance || '').split(';').map((one) => one.trim())) {
-        if (!condition || OUT_OF_VERIFY.test(condition)) continue
-        const nombra = POST_VERIFY.filter(([pattern]) => pattern.test(condition))
-        if (!nombra.length) continue
-        warnings.push(`BACKLOG ${task.slug}: una condición nombra ${nombra.map(([, what]) => what).join(', ')}`
+      for (const condition of acceptanceConditions(task.acceptance)) {
+        if (OUT_OF_VERIFY.test(condition)) continue
+        const names = POST_VERIFY.filter(([pattern]) => pattern.test(condition))
+        if (!names.length) continue
+        warnings.push(`BACKLOG ${task.slug}: una condición nombra ${names.map(([, what]) => what).join(', ')}`
           + ', que existe después de Verify, así que no se puede comprobar cuando se la comprueba. Eso va '
           + 'en tests:, qa: o commit: de su entrada de DONE, que ya lo exigen; si de verdad va acá, '
           + 'declaralo con "(fuera de verify: <razón>)"')
@@ -208,6 +202,44 @@ function unverifiableAcceptance(milestones = []) {
   return warnings
 }
 
+// `tests: n/a` dice que la tarea no produjo nada que se ejecute, y quien lo escribe es el mismo que quiere
+// cerrar: desde el 189 el recorrido lo emite cuando Verify declara `no-surface`, que es la palabra de un
+// modelo. Lo que la vuelve creíble es mirar qué tocó el commit, y eso no lo decide nadie. Se juzga el n/a
+// entero y no el mixto: en una tarea que rastrea algún criterio con su prueba, el código del commit es el
+// de esos criterios y no dice nada del que se declaró sin superficie.
+//
+// `filesOf` devuelve los archivos de un sha, o null si ningún repositorio lo conoce. Ahí calla, igual que
+// el resto de lo que pregunta a git desde `check`: un sha que no se encuentra no es superficie, y avisarlo
+// sería inventar el hallazgo. Lo adoptado queda afuera por lo mismo que en el resto de DONE: se escribió
+// antes de que el contrato lo pidiera.
+//
+// Y rige desde que existe. Una entrada cerrada antes con `tests: n/a` sobre código no violó nada que se le
+// hubiera pedido, y frenarla ahora pondría `check` en rojo con el `upgrade` —y con él al guard que lo corre
+// antes de cada commit— por algo que nadie puede corregir sin reescribir evidencia. Es la misma razón por
+// la que se exime lo adoptado, aplicada a lo que ya estaba cerrado cuando la regla llegó.
+const NOT_APPLICABLE = /^n\/a\s*[—-]/i
+const SURFACE_SINCE = '2026-09-24'
+
+function surfaceWithoutTests(entries, filesOf, adopted = new Set()) {
+  const errors = []
+  for (const entry of entries) {
+    const traces = splitTraces(entry.tests)
+    if (adopted.has(entry.slug) || !traces.length || !traces.every((one) => NOT_APPLICABLE.test(one))) continue
+    if (!(String(entry.fecha || '') >= SURFACE_SINCE)) continue
+    for (const sha of commitParts(entry.commit).map((part) => (part.match(/^([0-9a-f]{7,40})\s/) || [])[1])) {
+      if (!sha) continue
+      const surface = (filesOf(sha) || [])
+        .filter((file) => !NON_EXECUTABLE.includes(path.extname(file).toLowerCase()))
+      if (!surface.length) continue
+      const shown = surface.length > 5 ? [...surface.slice(0, 5), `y ${surface.length - 5} más`] : surface
+      errors.push(`${entry.source} ${entry.slug}: tests: n/a dice que no hay superficie ejecutable y el commit `
+        + `${sha} toca ${shown.join(', ')}; sólo ${NON_EXECUTABLE.join(', ')} cuentan como no ejecutables, `
+        + 'así que esos criterios se rastrean con su prueba')
+    }
+  }
+  return errors
+}
+
 function duplicates(values) {
   return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))]
 }
@@ -260,22 +292,22 @@ function dependencyErrors(milestones, done) {
   // Recorrido en profundidad con el camino a cuestas: al reencontrar un slug que sigue en el camino,
   // ese camino **es** el ciclo, y nombrarlo entero es lo que lo hace reparable — decir sólo que hay uno
   // deja el trabajo de encontrarlo del lado de quien lee.
-  const estado = new Map()
-  const visitar = (slug, camino) => {
-    if (estado.get(slug) === 'listo') return
-    const desde = camino.indexOf(slug)
-    if (desde >= 0) {
-      const ciclo = [...camino.slice(desde), slug]
-      errors.push(`BACKLOG: ciclo de dependencias ${ciclo.join(' → ')}`)
+  const state = new Map()
+  const visit = (slug, trail) => {
+    if (state.get(slug) === 'listo') return
+    const from = trail.indexOf(slug)
+    if (from >= 0) {
+      const cycle = [...trail.slice(from), slug]
+      errors.push(`BACKLOG: ciclo de dependencias ${cycle.join(' → ')}`)
       return
     }
     for (const dep of queued.get(slug) || []) {
       // La que se depende a sí misma ya tiene su error, más claro que un ciclo de un solo paso.
-      if (dep !== slug && queued.has(dep)) visitar(dep, [...camino, slug])
+      if (dep !== slug && queued.has(dep)) visit(dep, [...trail, slug])
     }
-    estado.set(slug, 'listo')
+    state.set(slug, 'listo')
   }
-  for (const slug of queued.keys()) visitar(slug, [])
+  for (const slug of queued.keys()) visit(slug, [])
   return [...new Set(errors)]
 }
 
@@ -397,10 +429,10 @@ function validateState({
     // ofreciendo. `**slug: de qué se trata**` es la que sale natural, porque esta tabla la lee una
     // persona. Sin esto la ausencia no deja rastro, que es la forma de R15 aplicada a un mecanismo.
     if (backlogSlugs.has(row.task)) continue
-    const casi = [...backlogSlugs].find((slug) => new RegExp(`\\b${slug}\\b`).test(row.task))
-    if (casi) {
-      errors.push(`HUMAN_ACTIONS: la fila "${row.task}" nombra a ${casi} y no bloquea nada, porque el `
-        + `motor bloquea por la primera columna exacta. Dejá "${casi}" sola ahí y contá el resto en la `
+    const near = [...backlogSlugs].find((slug) => new RegExp(`\\b${slug}\\b`).test(row.task))
+    if (near) {
+      errors.push(`HUMAN_ACTIONS: la fila "${row.task}" nombra a ${near} y no bloquea nada, porque el `
+        + `motor bloquea por la primera columna exacta. Dejá "${near}" sola ahí y contá el resto en la `
         + 'acción, o nombrá la épica o el recorrido si lo que se frena no es esa tarea')
     }
   }
@@ -435,6 +467,7 @@ module.exports = {
   doneEntryErrors,
   doneCeremonyWarnings,
   unverifiableAcceptance,
+  surfaceWithoutTests,
   validCommitTrace,
   validDecisionTrace,
   validTestTrace,

package/engine/schemas/ops-config.schema.json

@@ -118,6 +118,15 @@
             "pattern": "^[a-z0-9]+$"
           },
           "minItems": 1
+        },
+        "paths": {
+          "type": "array",
+          "description": "Carpetas donde viven las migraciones, relativas y sin «.» ni «..»: el guard las reconoce en cualquier lugar de la ruta, así que \"alembic/versions\" también alcanza a \"api/alembic/versions\". Declararlas reemplaza el default [\"migrations\", \"migration\", \"migrate\"], y `check` avisa la que no alcanza a ningún archivo.",
+          "items": {
+            "type": "string",
+            "pattern": "^[A-Za-z0-9_-][A-Za-z0-9._-]*(?:/[A-Za-z0-9_-][A-Za-z0-9._-]*)*$"
+          },
+          "minItems": 1
         }
       }
     },

package/package.json

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

package/template/AGENTS.md

@@ -114,13 +114,22 @@ preguntando, no pasa. **Con los gates de un commit se pregunta cada vez**, como
 stack y los lockfiles no heredan lo que autorizaste en un mensaje anterior, porque cada commit es otra
 operación. Y `plan-first` no te pide un plan cuando el cambio lo pediste vos: el plan es para el trabajo que va
 por tareas. Funciona en Claude Code, Codex y Gemini, que le avisan a Cauce cuando mandás un mensaje; en
-Antigravity, y cuando nadie está en el chat —CI, un recorrido, un subagente—, queda el archivo de abajo.
+Antigravity, y cuando nadie está en el chat —CI, un recorrido—, queda el archivo de abajo. Si lo frenado
+lo hacía un subagente, tu confirmación le llega igual; un pedido tuyo que lo nombraba, no: ése vale sólo
+para el agente con el que hablás.
 
 **Sin chat, la salida de todos ellos es la misma**: escribir en `planning/.ops-approval` las rutas que
 autorizás, una por línea, con `#` para lo que no sea una ruta. En sidecar es el `planning/` de la
 instancia y no una carpeta al lado de tus proyectos; el bloqueo dice la ruta exacta. Es un solo archivo
 para todos los guards, porque lo que escribís son rutas y quién las mira lo decide qué guard esté
-juzgando esa ruta. Lo escribís vos: si el agente intenta escribírselo, un guard lo frena.
+juzgando esa ruta. Lo escribís vos, o el agente con tu confirmación: si intenta escribírselo solo, un
+guard lo frena y te muestra qué iba a agregar.
+
+**Una lectura que necesitás siempre se aprueba una vez.** El «dale» dura la sesión. Cuando el agente se
+frena leyendo una credencial —el token con el que una regla tuya manda autenticar—, te pregunta además si
+querés dejarla aprobada para siempre; si esa es tu intención, escribe la ruta en ese archivo, con quién lo
+aprobó y para qué, y ninguna sesión vuelve a preguntarlo. `check` la sigue nombrando mientras exista, como
+toda exención; se revoca borrando la línea.
 
 | lo que te frena | qué ruta aprobás |
 |---|---|

package/template/planning/PROTOCOL.md

@@ -16,7 +16,8 @@ invariantes.
   reclamo, `done/` o la evidencia registrada pide algo que todavía no existe cuando se la mira, y su lugar
   son los campos `tests:`, `qa:` y `commit:` de DONE, que ya lo exigen. `check` lo avisa sobre la cola. Si
   aun así corresponde dejarla ahí, se declara en la propia condición con `(fuera de verify: <razón>)` —la
-  misma salida explícita que `(sin partir: …)` y que `n/a — razón`— y deja de avisarse.
+  misma salida explícita que `(sin partir: …)` y que `n/a — razón`— y deja de avisarse. El recorrido la
+  saca de lo que manda a Verify y a QA, y la lleva a Done para que quede cumplida en esos campos.
 - DONE: un archivo por tarea cerrada, `done/<slug>.md`, con su entrada `[x]` y los campos `acept:`,
   `fecha:` en AAAA-MM-DD, `done:`, `qa:`, `tests:`, `commit:` y `lane:`. `lane:` repite el carril con el
   que la tarea corrió —`express`, `directo`, `lite`, `full`— o `sin clasificar` si su línea no lo
@@ -28,7 +29,10 @@ invariantes.
   que convoca revisor con una revisión que no corrió es la ADR incumplida, escrita en el propio registro. La fecha es la del cierre, y es lo que
   ordena una evidencia que ya no depende de su posición dentro de un archivo. `tests:` enlaza cada criterio
   mediante `CN → prueba`; usa `A → prueba` cuando no hay épica o `n/a — razón` si no existe una
-  superficie ejecutable. `decisions:` es opcional y, si aparece, cita `[fuente: ...]` o
+  superficie ejecutable. Un `tests:` que sea todo `n/a` es un error de `check` si su `commit:` toca algún
+  archivo que no sea un documento (`.md`, `.txt`, `.adoc`) o una imagen (`.png`, `.jpg`, `.jpeg`, `.gif`,
+  `.svg`, `.webp`): lo demás se ejecuta y se prueba, también lo que no tiene extensión, como un `Makefile`.
+  Rige para lo cerrado desde el 2026-09-24; lo anterior no se juzga con ella. `decisions:` es opcional y, si aparece, cita `[fuente: ...]` o
   `[supuesto: ...]`. `commit:` apunta a `<sha> <asunto>`, o a `n/a — razón` cuando la tarea no
   produce commit.
 - Acción humana: fila `| tarea | estado | origen | acción y condición de desbloqueo |`, con el estado