@ingeniomaps/cauce 0.97.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/args.js

@@ -7,7 +7,7 @@
 // Banderas que consumen el argumento siguiente: su valor no es un posicional.
 const VALUED_FLAGS = new Set([
   '--name', '--mode', '--fixture', '--period', '--record', '--runner', '--integration',
-  '--task', '--promote', '--hito',
+  '--task', '--promote', '--hito', '--reason',
 ])
 
 // Qué acepta cada comando, y a la vez qué comandos existen. Una bandera desconocida se rechaza en vez
@@ -36,7 +36,7 @@ const FLAGS = {
   integration: ['--fixture'],
   secrets: [],
   automation: ['--force'],
-  learn: ['--flow', '--proposal', '--applied', '--archived', '--period'],
+  learn: ['--flow', '--proposal', '--applied', '--archived', '--period', '--reason'],
   evaluate: ['--cases', '--json', '--bench', '--force', '--record', '--flow'],
   flow: ['--json'],
 }

package/engine/cli/catalog.js

@@ -91,14 +91,14 @@ function learn(agent, cli) {
     // y lo que se hacía era mergear el PR sin firmar — que deja el documento diciendo «sin aplicar»
     // para siempre, indistinguible de una que espera trabajo.
     if (cli.has('--archived')) {
-      const result = L.archive(opsRoot(), agent, cli.value('--period'), kind)
+      const result = L.archive(opsRoot(), agent, cli.value('--period'), kind, cli.value('--reason') || '')
       const relative = path.relative(opsRoot(), result.file)
-      // Los dos archivados no son lo mismo y el mensaje lo dice: uno es una decisión —se miró y no
-      // cambia nada— y el otro es tirar un andamio que nadie llegó a llenar. Afirmar el primero sobre
-      // el segundo le cuenta a quien archiva que hubo una revisión que no hubo.
-      const porque = result.blank
-        ? 'nadie decidió el cambio y el documento quedó con el molde'
-        : 'se miró y no cambia nada'
+      // Los dos archivados no son lo mismo y el mensaje lo dice: uno es una decisión, con su motivo, y
+      // el otro es tirar un andamio que nadie llegó a llenar. Afirmar el primero sobre el segundo le
+      // cuenta a quien archiva que hubo una revisión que no hubo.
+      const porque = result.reason
+        ? `descartada — ${result.reason}`
+        : 'nadie decidió el cambio y el documento quedó con el molde'
       return console.log(result.already
         ? `= ${relative} ya estaba archivada`
         : `✓ ${relative} queda archivada: ${porque}`)
@@ -110,13 +110,13 @@ function learn(agent, cli) {
         ? `= ${relative} ya estaba aplicada`
         : `✓ ${relative} queda aplicada: no se vuelve a aplicar`)
     }
-    // Un recorrido no tiene informe semanal: su propuesta se compone de los veredictos de sus propias
-    // corridas y nunca lee `learning/reports/`. La forma desnuda —la que para un cargo abre el informe
-    // de la semana— no tiene entonces qué abrir acá, y `prepareReport` lo decía resolviendo con el
+    // Un recorrido no tiene informe de investigación: su propuesta se compone de los veredictos de sus
+    // propias corridas y nunca lee `learning/reports/`. La forma desnuda —la que para un cargo abre su
+    // informe— no tiene entonces qué abrir acá, y `prepareReport` lo decía resolviendo con el
     // `kind` por defecto: «no existe agents/<tipo>/<slug>/SKILL.md», que manda a crear un cargo que no
     // falta. Negarse nombrando el comando que sí corresponde es lo que cierra R13.
     if (kind === 'flow' && !cli.has('--proposal')) {
-      fail(`${agent} es un recorrido: aprende de sus corridas, no de informes semanales.\n`
+      fail(`${agent} es un recorrido: aprende de sus corridas, no de informes de investigación.\n`
         + `  Abrí la propuesta con "ops learn ${agent} --flow --proposal".`, USAGE)
     }
     // `--period` es para consolidar a mano un mes que no es el de hoy. El ciclo automático no lo
@@ -137,7 +137,7 @@ function learn(agent, cli) {
     if (typeof result.reports === 'number') {
       console.log(kind === 'flow'
         ? `  ${result.reports} corrida(s) consolidada(s), ${result.findings} hallazgo(s)`
-        : `  ${result.reports} informe(s) semanal(es) incluidos`)
+        : `  ${result.reports} informe(s) de investigación incluidos`)
     }
     // Lo lee quien automatiza el ciclo para no pedir una firma por un documento que no decide nada, y
     // también quien lo corre a mano: sin esta línea el archivo se ve terminado y no lo está. Se pregunta

package/engine/cli/ops.js

@@ -180,7 +180,8 @@ function usage() {
   ops automation doctor <ops-root> claude|codex|gemini|antigravity
   ops automation install <ops-root> claude|codex|gemini|antigravity
   ops automation uninstall <ops-root> claude|codex|gemini|antigravity
-  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied|--archived [--period <AAAA-MM>]]
+  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied [--period <AAAA-MM>]]
+  ops learn <agent|flow> [--flow] --archived [--period <AAAA-MM>] [--reason <motivo>]
   ops evaluate <agent|flow> [--flow] [--cases [--json]] [--bench [caso]] [--record [AAAA-MM-DD]]
   ops agents list [ops-root] [--own|--system] [--json]
   ops agents fork <cargo> [ops-root]

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 }