@ingeniomaps/cauce 0.98.0 → 0.99.0

package/engine/automation/registration.js

@@ -0,0 +1,89 @@
+'use strict'
+
+// La copia que el runner ejecuta, cuando no es la del workspace. `agy` corre la que registra
+// `agy plugin install`, una por usuario y no por proyecto, así que el plugin del workspace puede estar
+// perfecto mientras el runner ejecuta el de otro proyecto, de otra versión o roto. `doctor` sondeaba sólo
+// el del workspace y decía «operativo» con cada llamada del runner fallando (caso 201).
+//
+// El runner declara dónde vive esa copia —`activation.registered` en su manifiesto—, y sin esa
+// declaración esto no dice nada: no hay copia aparte que mirar.
+
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const { spawnSync } = require('node:child_process')
+
+function registeredCopy(runner) {
+  const declared = runner.activation && runner.activation.registered
+  return declared ? declared.replace(/^~(?=\/|$)/, os.homedir()) : ''
+}
+
+// Los archivos del plugin, relativos a su carpeta: los que el adaptador entrega bajo ella, más su
+// configuración de hooks.
+function pluginFiles(paths, runner, pluginDir) {
+  const targets = [...(runner.artifacts || []).map((item) => path.resolve(paths.install, item.target)),
+    paths.configTarget]
+  return [...new Set(targets)]
+    .filter((file) => file.startsWith(`${pluginDir}${path.sep}`))
+    .map((file) => path.relative(pluginDir, file))
+}
+
+// Lanza cada comando de la configuración registrada como lo lanza el runner: el texto literal, desde la
+// carpeta del plugin. Así se ve el wiring que no resuelve, que ejecutando el puente directo no aparece.
+// Con tope: la copia registrada puede ser vieja o estar rota, y una que no contesta colgaba a `doctor`. Diez
+// segundos sobran para una copia sana —arranca y contesta en menos de uno— y con una que no contesta ya
+// alcanza para el diagnóstico, así que el sondeo corta ahí en vez de esperar el tope una vez por evento.
+const LAUNCH_LIMIT_MS = 10000
+
+function launch(dir, event, command) {
+  const payload = event === 'pre-shell' ? { toolCall: { args: { CommandLine: 'ls' } } } : {}
+  const input = JSON.stringify(payload)
+  const result = spawnSync('sh', ['-c', command],
+    { cwd: dir, input, encoding: 'utf8', timeout: LAUNCH_LIMIT_MS, killSignal: 'SIGKILL' })
+  if (result.error && result.error.code === 'ETIMEDOUT') return `no respondió en ${LAUNCH_LIMIT_MS / 1000} s`
+  let response = {}
+  try { response = JSON.parse((result.stdout || '').trim()) } catch { response = {} }
+  const healthy = event === 'stop' ? 'stop' : 'allow'
+  if (response.decision === healthy && !response.reason) return ''
+  const stderr = (result.stderr || '').split('\n').find((line) => /Error|error/.test(line)) || ''
+  return response.reason || (response.decision ? `respondió ${response.decision}` : stderr.trim() || 'sin respuesta')
+}
+
+// Qué impide que la copia registrada sea esta instalación funcionando. Vacío si el runner no declara una
+// copia aparte o si todavía no hay ninguna registrada —eso lo dice `activated`—.
+function registrationProblems(paths, runner) {
+  const dir = registeredCopy(runner)
+  if (!dir || !fs.existsSync(dir)) return []
+  const bridge = (runner.artifacts || []).find((item) => item.target.endsWith('hook.js'))
+  if (!bridge) return []
+  const pluginDir = path.dirname(path.resolve(paths.install, bridge.target))
+  const differ = pluginFiles(paths, runner, pluginDir).filter((file) => {
+    const ours = path.join(pluginDir, file)
+    const theirs = path.join(dir, file)
+    if (!fs.existsSync(ours)) return false
+    return !fs.existsSync(theirs) || !fs.readFileSync(ours).equals(fs.readFileSync(theirs))
+  })
+  const problems = []
+  if (differ.length) {
+    const shown = differ.length > 5 ? [...differ.slice(0, 5), `y ${differ.length - 5} más`] : differ
+    problems.push(`${runner.command} ejecuta ${dir}, que no es esta instalación: difiere(n) ${shown.join(', ')}. `
+      + `Corré desde ${paths.install}: ${runner.activation.hint}`)
+  }
+  let config = {}
+  try { config = JSON.parse(fs.readFileSync(path.join(dir, path.basename(paths.configTarget)), 'utf8')) } catch {
+    return problems
+  }
+  const commands = [...new Set(JSON.stringify(config).match(/"command":"([^"]*hook\.js [a-z-]+)"/g) || [])]
+    .map((entry) => entry.slice(11, -1))
+  for (const command of commands) {
+    const event = command.split(' ').pop()
+    const failure = launch(dir, event, command)
+    if (failure) {
+      problems.push(`la copia registrada no responde a ${event} lanzada como la lanza ${runner.command}: ${failure}`)
+    }
+    if (/^no respondió/.test(failure)) break
+  }
+  return problems
+}
+
+module.exports = { registrationProblems }

package/engine/cli/validate.js

@@ -26,6 +26,7 @@ const O = require('../core/ownership')
 const TR = require('../core/trails')
 const OB = require('../core/onboarding')
 const C = require('../config/validate')
+const MG = require('../core/migrations')
 const CP = require('../config/paths')
 const AG = require('../agents/catalog')
 const RL = require('../automation/rules')
@@ -62,6 +63,7 @@ function check(dir, cli) {
       if (!raw.includes('{{')) {
         errors.push(...C.validateOpsConfig(config))
         warnings.push(...C.configWarnings(config))
+        warnings.push(...MG.coverageWarnings(R.reposFor(path.dirname(configPath), '.'), config))
         if (Array.isArray(config.workspaceRoots)) {
           for (const workspace of config.workspaceRoots) {
             if (workspace && workspace.name && workspace.path
@@ -108,6 +110,7 @@ function check(dir, cli) {
   // corre en los cuatro carriles, incluidos los que saltean Ready (caso 140).
   warnings.push(...PC.unverifiableAcceptance(milestones))
   warnings.push(...R.coverageWarnings(path.resolve(root, '..'), done))
+  errors.push(...PC.surfaceWithoutTests(done.entries, R.commitFiles(path.resolve(root, '..')), new Set(adopted)))
   // Sin `RECURRING.md` no dice una palabra: una instancia que actualiza y no declara trabajo recurrente
   // no tiene por qué enterarse de que el contrato existe. Vencida avisa y no frena — lo que frena vive
   // en `HUMAN_ACTIONS.md`, y un aviso que salta siempre se termina apagando.

package/engine/cli/wiring.js

@@ -283,7 +283,7 @@ function automation(action, rootArg, runnerName, cli) {
     if (!runner.capabilities.nativeHooks) {
       console.log(`  ${runnerName} no expone hooks nativos; aplica guards como prechecks.`)
     }
-    const result = A.doctor(root, runnerName)
+    const result = A.doctor(root, runnerName, console, { afterInstall: true })
     if (result.errors.length) fail(`${runnerName}: instalación incompleta`, REFUSED)
     console.log(`✓ ${runnerName}: adaptador operativo (${result.warnings.length} advertencia(s))`)
     return

package/engine/config/validate.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { PATH_SHAPE, EXTENSION_SHAPE } = require('../core/migrations')
+
 const MODES = ['embedded', 'sidecar', 'toolkit']
 
 // Campos que existieron y se retiraron. Se nombran en vez de caer en «propiedad desconocida» porque
@@ -69,18 +71,35 @@ function validateMigrations(migrations, errors) {
     return
   }
   for (const key of Object.keys(migrations)) {
-    if (key !== 'extensions') errors.push(`ops.config.json: migrations.${key} no está permitido`)
-  }
-  if (!('extensions' in migrations)) return
-  const declaradas = migrations.extensions
-  if (!Array.isArray(declaradas) || !declaradas.length) {
-    errors.push('ops.config.json: migrations.extensions debe listar al menos una extensión, o no estar')
-    return
+    if (!['extensions', 'paths'].includes(key)) errors.push(`ops.config.json: migrations.${key} no está permitido`)
+  }
+  if ('extensions' in migrations) {
+    const declared = migrations.extensions
+    if (!Array.isArray(declared) || !declared.length) {
+      errors.push('ops.config.json: migrations.extensions debe listar al menos una extensión, o no estar')
+    } else {
+      for (const one of declared) {
+        if (typeof one !== 'string' || !EXTENSION_SHAPE.test(one)) {
+          errors.push(`ops.config.json: migrations.extensions "${one}" debe ser la extensión sin el punto `
+            + 'y en minúscula, como "sql" o "ts"')
+        }
+      }
+    }
   }
-  for (const one of declaradas) {
-    if (typeof one !== 'string' || !/^[a-z0-9]+$/.test(one)) {
-      errors.push(`ops.config.json: migrations.extensions "${one}" debe ser la extensión sin el punto `
-        + 'y en minúscula, como "sql" o "ts"')
+  // Las carpetas, por lo mismo que las extensiones y con una razón más: el guard las busca dentro de la
+  // ruta que recibe, que puede ser relativa, así que una absoluta o una que sale con `..` no nombraría
+  // nada que pudiera encontrar (caso 196).
+  if ('paths' in migrations) {
+    const paths = migrations.paths
+    if (!Array.isArray(paths) || !paths.length) {
+      errors.push('ops.config.json: migrations.paths debe listar al menos una carpeta, o no estar')
+      return
+    }
+    for (const one of paths) {
+      if (typeof one !== 'string' || !PATH_SHAPE.test(one)) {
+        errors.push(`ops.config.json: migrations.paths ${JSON.stringify(one)} debe ser una carpeta relativa, `
+          + 'sin barra al principio ni al final y sin «.» ni «..», como "migrations" o "alembic/versions"')
+      }
     }
   }
 }

package/engine/core/migrations.js

@@ -0,0 +1,275 @@
+'use strict'
+
+// Qué es una migración para un proyecto, qué parte de ella aplica y qué cuenta como destruir. Lo preguntan
+// el guard `migrations`, que juzga cada escritura, y `check`, que mira si lo declarado alcanza a algún
+// archivo; la respuesta tiene que ser la misma en los dos, y por eso vive una sola vez acá.
+
+const path = require('node:path')
+const { spawnSync } = require('node:child_process')
+
+// 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.
+const DEFAULT_EXTENSIONS = ['sql']
+
+// Las carpetas se declaran por lo mismo que las extensiones: ninguna lista del motor alcanza a Alembic,
+// cuya carpeta es el argumento de `alembic init` y puede moverse con `version_locations` (caso 196). El
+// default son los tres nombres que el motor usaba antes, así que quien no declara nada no ve diferencia.
+const DEFAULT_PATHS = ['migrations', 'migration', 'migrate']
+
+// Una carpeta relativa, de segmentos que no empiezan con punto: así no hay `..`, `.` ni ruta absoluta, y
+// lo que entra en la expresión regular no trae metacaracteres salvo el punto, que se escapa al usarla.
+const PATH_SHAPE = /^[A-Za-z0-9_-][A-Za-z0-9._-]*(?:\/[A-Za-z0-9_-][A-Za-z0-9._-]*)*$/
+const EXTENSION_SHAPE = /^[a-z0-9]+$/
+
+// Lo inválido no se descarta en silencio: descartarlo dejaría al proyecto creyendo que declaró una
+// cobertura que no tiene. Lo 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.
+function declared(config, key, shape, fallback) {
+  const value = ((config && config.migrations) || {})[key]
+  const usable = (Array.isArray(value) ? value : []).filter((one) => typeof one === 'string' && shape.test(one))
+  return usable.length ? usable : fallback
+}
+
+function pattern(config) {
+  const extensions = declared(config, 'extensions', EXTENSION_SHAPE, DEFAULT_EXTENSIONS)
+  const folders = declared(config, 'paths', PATH_SHAPE, DEFAULT_PATHS).map((one) => one.replace(/\./g, '\\.'))
+  return new RegExp(`(?:^|/)(?:${folders.join('|')})/.*\\.(?:${extensions.join('|')})$`, 'i')
+}
+
+// Dónde empieza la reversión, por formato. Cada marcador es el que su herramienta reconoce y no uno
+// parecido, porque partir donde la herramienta no parte deja sin juzgar algo que sí corre:
+//
+// - goose (`internal/sqlparser/parser.go` de pressly/goose, `main`): la línea empieza con `--` sin
+//   espacio antes, y la anotación se compara con `strings.EqualFold`, así que `--+goose down` vale.
+// - dbmate (`pkg/dbmate/migration.go` de amacneil/dbmate, `main`): `(?m)^--\s*migrate:down(\s*$|\s+\S+)`,
+//   sensible a mayúsculas.
+//
+// El `Up` también se reconoce porque devuelve al lado que aplica: lo que venga después de él se juzga.
+const SQL_MARKERS = [
+  { up: /^--\s*\+goose\s*up\s*$/i, down: /^--\s*\+goose\s*down\s*$/i, label: '-- +goose Down' },
+  { up: /^--\s*migrate:up(?:\s*$|\s+\S+)/, down: /^--\s*migrate:down(?:\s*$|\s+\S+)/, label: '-- migrate:down' },
+]
+
+// El método de reversión de cada herramienta de lenguaje: `downgrade()` de Alembic, `down` de Rails
+// (también el `self.down` de las versiones viejas), `down()` de TypeORM y `exports.down` o `export function
+// down` de Knex. Se lo reconoce al principio de la línea, así que una llamada a `this.down(...)` dentro de
+// `up` no cuenta.
+const LANGUAGE_HEADERS = [
+  { header: /^(\s*)(?:async\s+)?def\s+downgrade\s*\(/, label: 'downgrade()' },
+  { header: /^(\s*)def\s+(?:self\.)?down\b/, label: 'down' },
+  { header: /^(\s*)(?:(?:public|protected|private)\s+)?(?:async\s+)?down\s*\(/, label: 'down()' },
+  { header: /^(\s*)(?:module\.)?exports\.down\s*=/, label: 'exports.down' },
+  { header: /^(\s*)export\s+(?:async\s+)?function\s+down\s*\(|^(\s*)export\s+const\s+down\s*=/, label: 'down()' },
+]
+
+// Las herramientas golang-migrate y sqlx guardan la reversión en otro archivo, `{version}_{title}.down.{extension}`
+// (`MIGRATIONS.md` de golang-migrate/migrate), y ése es reversión entera.
+const DOWN_FILE = /\.down\.[^./]+$/i
+
+const indent = (line) => line.match(/^\s*/)[0].length
+
+// Qué líneas aplican: una lista de booleanos, uno por línea, y el marcador que parte. `null` si no hay nada
+// que partir, para que quien pregunta juzgue el texto entero: sin marcador reconocido se degrada al
+// comportamiento de antes en vez de fallar abierto. Los marcadores son comentarios y no aplican.
+function sqlMask(lines) {
+  const markers = SQL_MARKERS.filter((one) => lines.some((line) => one.up.test(line) || one.down.test(line)))
+  if (!markers.length) return null
+  let applies = true
+  const mask = lines.map((line) => {
+    if (markers.some((one) => one.up.test(line))) {
+      applies = true
+      return false
+    }
+    if (markers.some((one) => one.down.test(line))) {
+      applies = false
+      return false
+    }
+    return applies
+  })
+  return { mask, label: markers[0].label }
+}
+
+// En una migración de lenguaje el bloque termina donde la indentación vuelve a la del encabezado: la línea
+// que lo cierra —`}`, `end`, `};`— queda del lado que aplica, y da igual porque no destruye nada. Es la
+// forma en que las herramientas generan sus migraciones; lo que se aparta de ella acorta el bloque en vez de
+// alargarlo, así que un archivo con formato raro se juzga de más y no de menos. El borde que queda abierto
+// es escribir `up` en la misma línea que el encabezado de `down`, y eso no lo genera ninguna.
+function languageMask(lines) {
+  let label = ''
+  let depth = null
+  const mask = lines.map((line) => {
+    if (depth !== null) {
+      if (!line.trim() || indent(line) > depth) return false
+      depth = null
+    }
+    const found = LANGUAGE_HEADERS.find((one) => one.header.test(line))
+    if (!found) return true
+    label = found.label
+    depth = indent(line)
+    return false
+  })
+  return label ? { mask, label } : null
+}
+
+function applyMask(file, lines) {
+  if (DOWN_FILE.test(file)) return { mask: lines.map(() => false), label: path.basename(file) }
+  return /\.sql$/i.test(file) ? sqlMask(lines) : languageMask(lines)
+}
+
+// Lo que hay que juzgar de una escritura: el texto de las líneas que aplican y el marcador que partió, o
+// el texto entero sin marcador si no había nada que partir.
+//
+// En un `Edit` el guard no ve el archivo, sólo el fragmento. Se reconstruye el archivo como va a quedar
+// —`old` reemplazado en `disk`— y se juzga la parte del fragmento que cae del lado que aplica, así que un
+// fragmento que mueve un marcador se lee en su lugar y no suelto. Sin `disk` o sin `old` adentro se juzga
+// el fragmento entero, como antes.
+function judged(file, text, edit = {}) {
+  const { disk, old, all } = edit
+  let result = String(text)
+  let spans = [[0, result.length]]
+  if (old && typeof disk === 'string' && disk.includes(old)) {
+    const at = disk.indexOf(old)
+    const pieces = all ? disk.split(old) : [disk.slice(0, at), disk.slice(at + old.length)]
+    result = pieces[0]
+    spans = []
+    for (const piece of pieces.slice(1)) {
+      spans.push([result.length, result.length + String(text).length])
+      result += String(text) + piece
+    }
+  } else if (old) return { text: String(text), label: '' }
+  const lines = result.split('\n')
+  const split = applyMask(file, lines.map((line) => line.replace(/\r$/, '')))
+  if (!split && spans.length === 1 && spans[0][0] === 0 && spans[0][1] === result.length) {
+    return { text: result, label: '' }
+  }
+  const kept = []
+  let at = 0
+  lines.forEach((line, index) => {
+    const [from, to] = [at, at + line.length]
+    at = to + 1
+    if (split && !split.mask[index]) return
+    for (const [start, end] of spans) {
+      if (Math.max(start, from) <= Math.min(end, to)) {
+        kept.push(result.slice(Math.max(start, from), Math.min(end, to)))
+      }
+    }
+  })
+  return { text: kept.join('\n'), label: split ? split.label : '' }
+}
+
+// Las secciones de un `apply_patch`, por archivo: la línea `*** Add|Update|Delete File: <ruta>` y lo que
+// sigue hasta la cabecera del próximo archivo o `*** End Patch`. Cada línea conserva su prefijo —`+`
+// agregada, `-` quitada, ` ` contexto— porque de él depende qué se juzga. `@@`, `*** Move to:` y
+// `*** End of File` son del formato y no contenido, y no cortan la sección: cortarla ahí dejaba sin juzgar
+// lo que venía después, y pasaba lo que el guard viejo, que juzgaba el sobre entero, frenaba.
+function patchSections(patch) {
+  const sections = new Map()
+  let current = null
+  for (const line of String(patch).split('\n')) {
+    const header = line.match(/^\*\*\* (Add|Update|Delete) File:\s*(.+)$/)
+    if (header) {
+      current = { kind: header[1].toLowerCase(), lines: [] }
+      sections.set(header[2].trim(), current)
+    } else if (/^\*\*\* End Patch\s*$/.test(line)) current = null
+    else if (current && !line.startsWith('@@') && !line.startsWith('*** ')) {
+      current.lines.push({ op: line[0] || ' ', text: line.slice(1) })
+    }
+  }
+  return sections
+}
+
+// Lo que hay que juzgar de un archivo del parche, con el mismo contrato que `judged` (caso 199). Un archivo
+// nuevo es su contenido entero sin el prefijo, y se parte como un `Write`. Una modificación es el lado que va a
+// quedar —contexto y agregado—, partido con lo que el hunk trae, y de él se juzga sólo lo agregado: lo quitado
+// no destruye nada y el contexto ya estaba. Si el hunk no trae ningún marcador, no se sabe de qué lado cae y se
+// juzga todo lo agregado, como antes.
+function judgedPatch(file, section) {
+  if (section.kind === 'delete') return { text: '', label: '' }
+  if (section.kind === 'add') return judged(file, section.lines.map((line) => line.text).join('\n'))
+  const after = section.lines.filter((line) => line.op !== '-')
+  const split = applyMask(file, after.map((line) => line.text.replace(/\r$/, '')))
+  const kept = after.filter((line, index) => line.op === '+' && (!split || split.mask[index]))
+  return { text: kept.map((line) => line.text).join('\n'), label: split ? split.label : '' }
+}
+
+// Lo que destruye escrito en SQL. 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 DESTRUCTIVE_SQL = 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',
+)
+
+// Lo que destruye escrito con la API de la herramienta (caso 193). Son los nombres que la documentación
+// pública de cada una define, comprobados el 2026-09-23 y no más: Alembic (`ops.html`), Rails
+// (`active_record_migrations.md`), TypeORM (`migrations/09-api.md`), Knex (`schema-builder.md`) y Django
+// (`ref/migration-operations`). La lista envejece nombrando: lo que no está sigue pasando, igual que antes.
+// Sensible a mayúsculas porque la API lo es, y así `DeleteModel` no se confunde con prosa.
+const DESTRUCTIVE_API = new RegExp(
+  String.raw`\b(?:drop_table|drop_column|remove_columns?|drop_join_table` +
+    String.raw`|dropTable|dropTableIfExists|dropColumns?|DeleteModel|RemoveField)\b`,
+)
+
+// Qué destruye en `text`, o vacío: el fragmento que lo delata y de qué clase es, para que el mensaje pueda
+// nombrar la sentencia y no sólo el archivo.
+function destructive(text) {
+  const sql = String(text).match(DESTRUCTIVE_SQL)
+  if (sql) return { kind: 'SQL destructivo', what: sql[0].replace(/\s+/g, ' ').toUpperCase() }
+  const api = String(text).match(DESTRUCTIVE_API)
+  return api ? { kind: 'un borrado destructivo', what: api[0] } : null
+}
+
+// Lo declarado en `migrations` que no alcanza a ningún archivo del producto: una extensión o una carpeta
+// que el guard promete mirar y no mira nada. Es lo que el 077 y el 196 tienen en común —cobertura
+// declarada que no cubre, en silencio—, y va en `check` y no en el guard porque recorre el repositorio y el
+// guard corre en cada escritura (R26).
+//
+// Sólo mira lo que el proyecto declaró: sin declarar, el default no promete nada que alguien haya elegido.
+// Lee `git ls-files` de cada repositorio de las raíces, que es barato y deja afuera lo generado; sin
+// repositorio no dice nada, como el resto de los avisos que preguntan a git.
+function coverageWarnings(repos, config) {
+  const migrations = (config && config.migrations) || {}
+  const askExtensions = Array.isArray(migrations.extensions)
+  const askPaths = Array.isArray(migrations.paths)
+  if (!askExtensions && !askPaths) return []
+  const files = repos.flatMap((repo) => {
+    const listed = spawnSync('git', ['ls-files', '-z'], { cwd: repo, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 })
+    return listed.status === 0 ? listed.stdout.split('\0').filter(Boolean) : []
+  })
+  if (!files.length) return []
+  const matcher = pattern(config)
+  const covered = files.filter((file) => matcher.test(file))
+  const warnings = []
+  if (askExtensions) {
+    for (const one of declared(config, 'extensions', EXTENSION_SHAPE, [])) {
+      if (covered.some((file) => file.toLowerCase().endsWith(`.${one}`))) continue
+      warnings.push(`ops.config.json: migrations.extensions "${one}" no alcanza a ningún archivo bajo `
+        + `${declared(config, 'paths', PATH_SHAPE, DEFAULT_PATHS).join(', ')}: el guard no mira ninguna `
+        + 'migración con esa extensión. Si viven en otra carpeta, declarala en migrations.paths')
+    }
+  }
+  if (askPaths) {
+    for (const one of declared(config, 'paths', PATH_SHAPE, [])) {
+      const only = pattern({ migrations: { ...migrations, paths: [one] } })
+      if (files.some((file) => only.test(file))) continue
+      warnings.push(`ops.config.json: migrations.paths "${one}" no alcanza a ningún archivo con las extensiones `
+        + `${declared(config, 'extensions', EXTENSION_SHAPE, DEFAULT_EXTENSIONS).join(', ')}`)
+    }
+  }
+  return warnings
+}
+
+module.exports = {
+  PATH_SHAPE, EXTENSION_SHAPE, pattern, judged, judgedPatch, patchSections, destructive, coverageWarnings,
+}

package/engine/core/repos.js

@@ -34,7 +34,7 @@ function reposFor(opsRoot, service) {
     .filter(Boolean)
     // Dos raíces del mismo repositorio son un solo repositorio: lo ambiguo es a cuál pertenece el
     // servicio, no cuántas rutas lo contienen.
-    .filter((repo, index, todos) => todos.indexOf(repo) === index)
+    .filter((repo, index, all) => all.indexOf(repo) === index)
 }
 
 // El repositorio del servicio cuando no hay duda. Sin ninguno o con varios devuelve vacío, y quien
@@ -84,7 +84,7 @@ function unrecordedCommits(repo, since, recorded) {
   // historial reescrito o un `commit --date` la cuenta daba cero sobre un repositorio lleno.
   const log = git(repo, 'log', '--no-merges', '--date=short', '--format=%h %ad %s')
   if (log.status !== 0) return []
-  const conocidos = new Set([...recorded].map((sha) => String(sha).slice(0, 7)))
+  const known = new Set([...recorded].map((sha) => String(sha).slice(0, 7)))
   // El hash y la fecha se leen partiendo por espacios y no por columna: `%h` mide 7 por default y git lo
   // sube solo cuando el repositorio crece —en éste mide 8—, así que una posición fija leía un espacio en
   // vez de la fecha y ningún commit pasaba el filtro. El aviso quedaba mudo sin decirlo, que es la peor
@@ -92,7 +92,7 @@ function unrecordedCommits(repo, since, recorded) {
   return log.stdout.split('\n').map((line) => line.trim()).filter(Boolean)
     .map((line) => ({ line, sha: line.split(/\s+/)[0], date: line.split(/\s+/)[1] }))
     .filter((one) => one.date >= since)
-    .filter((one) => !conocidos.has(one.sha.slice(0, 7)))
+    .filter((one) => !known.has(one.sha.slice(0, 7)))
     .map((one) => one.line)
 }
 
@@ -153,4 +153,18 @@ function unrecordedHumanActions(opsRoot, rows) {
     .map((row) => `HUMAN_ACTIONS.md: ${row.task} figura resuelta y ningún commit la registró`)
 }
 
-module.exports = { reposFor, repoOf, lastCommit, coverageWarnings, unrecordedHumanActions }
+// Qué archivos tocó un commit, buscado en todos los repositorios declarados: una entrada de DONE nombra
+// el sha y no el repositorio. Devuelve null si ninguno lo conoce, y quien pregunta decide qué significa.
+// `--root` es para que el primer commit de un repositorio también liste lo suyo.
+function commitFiles(opsRoot) {
+  const repos = reposFor(opsRoot, '.')
+  return (sha) => {
+    for (const repo of repos) {
+      const shown = git(repo, 'diff-tree', '--no-commit-id', '--name-only', '-r', '--root', sha)
+      if (shown.status === 0) return shown.stdout.split('\n').map((line) => line.trim()).filter(Boolean)
+    }
+    return null
+  }
+}
+
+module.exports = { reposFor, repoOf, lastCommit, coverageWarnings, unrecordedHumanActions, commitFiles }

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,18 +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).
-  const ask = chat
-    ? 'Decile a la persona qué se frenó y por qué, y pedile que lo confirme con sus palabras: un «dale» '
+  // 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. 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. '
+      + 'respuesta que niega, frena o pregunta. '
+  const ask = chat
+    ? 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 `
@@ -128,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
@@ -153,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 }