@ingeniomaps/cauce 0.68.0 → 0.70.0

package/engine/core/repos.js

@@ -0,0 +1,67 @@
+'use strict'
+
+// En qué repositorio vive un servicio, y cuándo se movió por última vez una rama. Vive acá porque lo
+// preguntan dos cosas que no se conocen entre sí —preparar un árbol de trabajo y juzgar si un reclamo
+// sigue vivo— y la resolución tiene que ser la misma en las dos: escrita dos veces, una copia envejece
+// y las dos respuestas dejan de coincidir sin que nada falle.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { spawnSync } = require('node:child_process')
+
+const git = (cwd, ...args) => spawnSync('git', args, { cwd, encoding: 'utf8' })
+
+// Los repositorios cuyo árbol contiene el servicio, resuelto como lo resuelve `check` para juzgar si
+// existe. Devuelve la raíz git de cada uno, que no siempre es la raíz declarada: `workspaceRoots` puede
+// apuntar a un subdirectorio.
+//
+// Devuelve una lista y no el primero porque con varias raíces la respuesta puede ser ambigua: un
+// `service: .` existe en todas, y un `src` puede existir en dos. Elegir el primero da una respuesta
+// plausible y equivocada —un árbol de trabajo en el repositorio que no era— sin que nada lo diga.
+function reposFor(opsRoot, service) {
+  let config = {}
+  try {
+    config = JSON.parse(fs.readFileSync(path.join(opsRoot, 'ops.config.json'), 'utf8'))
+  } catch { return [] }
+  return (Array.isArray(config.workspaceRoots) ? config.workspaceRoots : [])
+    .filter((one) => one && one.path)
+    .map((one) => path.resolve(opsRoot, one.path))
+    .filter((root) => fs.existsSync(path.join(root, service || '.')))
+    .map((root) => {
+      const top = git(root, 'rev-parse', '--show-toplevel')
+      return top.status === 0 ? top.stdout.trim() : ''
+    })
+    .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)
+}
+
+// El repositorio del servicio cuando no hay duda. Sin ninguno o con varios devuelve vacío, y quien
+// pregunta decide qué decir: para `check` es la degradación ya declarada —mirar sólo la fecha—, y para
+// `worktree` es un error que tiene que nombrar los candidatos.
+function repoOf(opsRoot, service) {
+  const repos = reposFor(opsRoot, service)
+  return repos.length === 1 ? repos[0] : ''
+}
+
+// La fecha del último commit **propio** de una rama, en AAAA-MM-DD, o vacío si no tiene ninguno. Vacío no
+// es un error: una tarea recién tomada todavía no tiene rama, la rama recién creada no tiene commits, y
+// un proyecto puede nombrar sus ramas de otra forma. Quien pregunta decide qué hacer con la ausencia.
+//
+// Lo que hay que excluir es el tronco. Una rama nueva hereda su historia entera, así que preguntar por su
+// último commit a secas devuelve el del tronco y **toda rama parece haber avanzado el día que se creó** —
+// que es justo lo contrario de lo que esta función existe para medir. El tronco es la rama en la que está
+// el árbol principal: los worktrees se crean desde ahí y ahí se queda.
+function lastCommit(repo, branch) {
+  if (!repo) return ''
+  const actual = git(repo, 'rev-parse', '--abbrev-ref', 'HEAD')
+  const tronco = actual.status === 0 ? actual.stdout.trim() : ''
+  const args = tronco && tronco !== branch
+    ? ['log', '-1', '--format=%cs', branch, '--not', tronco, '--']
+    : ['log', '-1', '--format=%cs', branch, '--']
+  const shown = git(repo, ...args)
+  return shown.status === 0 ? shown.stdout.trim() : ''
+}
+
+module.exports = { reposFor, repoOf, lastCommit }

package/engine/hooks/files.js

@@ -12,6 +12,7 @@ const {
 } = require('./input')
 const AP = require('./approval')
 const { readWip } = require('../planning/parser')
+const { runner } = require('../planning/claims')
 const { hasTasks } = require('../planning/state')
 const { TEMPLATE_PREFIXES } = require('../core/ownership')
 
@@ -138,7 +139,7 @@ function planFirst(input) {
   const root = opsRoot(input)
   if (!root) return
   const planning = path.join(root, 'planning')
-  const wip = readWip(planning)
+  const wip = readWip(planning, runner())
   if (wip && wip.complete + wip.pending > 0) return
   // Una instancia recién creada no tiene de dónde sacar una tarea: `onboard` deja el roadmap vacío y
   // dice que alguien lo llene. Exigir el plan ahí es un candado delante de la puerta, y la salida que
@@ -149,7 +150,7 @@ function planFirst(input) {
   if (!hasTasks(planning)) return
   const estado = wip ? `WIP tiene la tarea ${wip.task} y ningún paso` : 'WIP está en IDLE'
   const why = `${estado}, así que el plan todavía no está escrito.\n`
-    + 'Escribí en planning/WIP.md la tarea y su plan aprobado —pasos numerados, cada uno con un estado '
+    + 'Escribí en tu planning/wip/<runner>.md la tarea y su plan aprobado —pasos numerados, cada uno con un estado '
     + 'verificable— y volvé al cambio. Si esto no es trabajo de una tarea, aprobá la ruta.\n'
     + AP.HOW('OPS_PLAN_FIRST_OVERRIDE')
   for (const raw of filesOf(input)) {

package/engine/planning/adoption.js

@@ -96,7 +96,7 @@ function report({ done, epics = [], adopted = [] }) {
   for (const slug of slugs) {
     const entry = done.entries.find((candidate) => candidate.slug === slug)
     if (!entry) {
-      warnings.push(`${BASELINE}: ${slug} no está en DONE.md; sacalo de la lista`)
+      warnings.push(`${BASELINE}: ${slug} no está en done/; sacalo de la lista`)
     } else if (!PC.doneEntryErrors(entry, epics).length) {
       warnings.push(`${BASELINE}: ${slug} ya cumple el contrato; retiralo poniéndole \`#~\` delante`)
     }

package/engine/planning/claims.js

@@ -0,0 +1,153 @@
+'use strict'
+
+// Quién tomó qué. Un archivo por tarea reclamada: crearlo es reclamar, borrarlo es soltar.
+//
+// El nombre del archivo es el slug de la tarea, y de ahí sale la única propiedad que importa: dos
+// personas en tareas distintas no tocan el mismo archivo nunca, y dos que reclaman la misma chocan en
+// git — que es exactamente donde el choque significa algo y donde conviene verlo.
+//
+// El plan de la ejecución no vive acá. Eso es `wip/<runner>.md`, que es local y cambia en cada paso; acá va lo
+// poco que el resto del equipo necesita saber, que cambia dos veces por tarea. Son dos responsabilidades
+// distintas y por eso son dos archivos: el reclamo evita que dos runners tomen la misma tarea, y el WIP
+// evita que un runner lleve dos.
+
+const fs = require('node:fs')
+const { spawnSync } = require('node:child_process')
+const path = require('node:path')
+const P = require('./parser')
+
+const DIR = 'claims'
+const DATE = /^\d{4}-\d{2}-\d{2}$/
+
+// Tres días **sin ninguna señal de avance**, que no es lo mismo que tres días desde que se tomó. El
+// tiempo transcurrido solo no distingue una tarea larga de una abandonada, y equivocarse en esa
+// distinción es caro en los dos sentidos: apurar a alguien que está trabajando, o dejar bloqueada para
+// siempre la tarea de quien se fue.
+//
+// Lo que sí distingue es si la rama de la tarea se movió. Con esa señal, tres días sin un solo commit no
+// es una tarea larga: es una que se detuvo, y el aviso manda a mirar y no a soltar.
+const STALE_DAYS = 3
+
+// Quién soy. Sale de la identidad de git porque ya está configurada, es por máquina y es la que va a
+// terminar en el commit igual: pedir una segunda identidad sólo para esto sería un dato más que puede
+// quedar desincronizado. `CAUCE_OWNER` la pisa donde no la haya —un contenedor de CI, por ejemplo—.
+//
+// Sin identidad no se puede reclamar, y eso es correcto: un reclamo anónimo no le dice a nadie a quién
+// preguntarle.
+function owner(root) {
+  if (process.env.CAUCE_OWNER) return process.env.CAUCE_OWNER.trim()
+  const result = spawnSync('git', ['config', 'user.email'], { cwd: root, encoding: 'utf8' })
+  return result.status === 0 ? (result.stdout || '').trim() : ''
+}
+
+// Qué runner soy, que no es lo mismo que quién soy. En una máquina con varios agentes la identidad de
+// git es la misma para todos —`git config user.email` no distingue una sesión de otra—, así que si lo
+// que decide «esto es mío» fuera el owner, el segundo agente tomaría por propia la tarea del primero y
+// los dos construirían lo mismo. La unidad es el árbol de trabajo: uno por agente.
+//
+// `CAUCE_RUNNER` es la vía explícita y la que deja `ops worktree`. Sin ella se deduce del árbol donde
+// corre el proceso, que acierta cuando el agente invoca desde el suyo y falla —devolviendo el mismo id
+// para todos— cuando invoca desde una instancia sidecar compartida. Esa falla no queda en silencio:
+// `claim` se niega a darle una segunda tarea a un runner que ya tiene una, y ese es el mensaje que
+// manda a poner la variable.
+function runner() {
+  if (process.env.CAUCE_RUNNER) return process.env.CAUCE_RUNNER.trim()
+  const result = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' })
+  return result.status === 0 ? (result.stdout || '').trim() : process.cwd()
+}
+
+// La rama donde vive el trabajo de una tarea. La escriben `worktree` al crearla y `check` al buscar si
+// se movió, y son la misma o el segundo mira una rama que nadie usa.
+const branchOf = (slug) => `task/${slug}`
+
+function file(root, slug) {
+  return path.join(root, DIR, `${slug}.md`)
+}
+
+function read(root) {
+  let names = []
+  try { names = fs.readdirSync(path.join(root, DIR)) } catch { return [] }
+  return names.filter((name) => name.endsWith('.md') && name !== 'README.md').sort()
+    .map((name) => {
+      const field = P.frontmatter(P.read(path.join(root, DIR, name)))
+      return {
+        slug: name.replace(/\.md$/, ''),
+        task: field('task'),
+        owner: field('owner'),
+        runner: field('runner'),
+        started: field('started'),
+        service: field('service'),
+        at: `${DIR}/${name}`,
+      }
+    })
+}
+
+// El cuerpo de un reclamo. Es corto a propósito: todo lo que crezca acá vuelve a viajar por git en cada
+// cambio, que es de lo que este archivo vino a separarse.
+function content({ task, owner, runner: from, started, service }) {
+  return `---\ntask: ${task}\nowner: ${owner}\nrunner: ${from}\nstarted: ${started}\n`
+    + `service: ${service || ''}\n---\n\nTomada. El plan vive en el \`wip/\` de quien la tomó.\n`
+}
+
+function validate({ claims, milestones, done }) {
+  const errors = []
+  const queued = new Set(milestones.flatMap((milestone) => milestone.tasks).map((task) => task.slug))
+  for (const claim of claims) {
+    const at = `${claim.at}`
+    // El nombre del archivo es lo que hace única la reserva, así que un frontmatter que dice otra cosa
+    // reclama una tarea y bloquea otra. Es la única forma en que este contrato puede mentir.
+    if (claim.task !== claim.slug) {
+      errors.push(`${at}: declara task "${claim.task}" y el archivo reserva ${claim.slug}`)
+    }
+    if (!claim.owner) errors.push(`${at}: falta owner`)
+    if (!claim.runner) errors.push(`${at}: falta runner`)
+    if (!DATE.test(claim.started)) errors.push(`${at}: started debe ser AAAA-MM-DD`)
+    if (!queued.has(claim.slug) && !done.set.has(claim.slug)) {
+      errors.push(`${at}: ${claim.slug} no existe en BACKLOG ni DONE`)
+    }
+  }
+  return errors
+}
+
+const days = (from, to) => Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`))
+  / 86400000)
+
+// `activity` mapea el slug de una tarea a la fecha del último commit de su rama. Llega de afuera porque
+// resolverlo exige git y la configuración del proyecto, y este módulo se prueba sin ninguna de las dos.
+// Vacío es un estado legítimo —una tarea recién tomada no tiene rama— y entonces la única señal que
+// queda es cuándo se tomó.
+function warnings({ claims, done, today, activity = new Map() }) {
+  const lines = []
+  for (const claim of claims) {
+    if (done.set.has(claim.slug)) {
+      lines.push(`${claim.at}: ${claim.slug} ya está en DONE; soltala con \`ops release\``)
+      continue
+    }
+    if (!DATE.test(claim.started)) continue
+    const commit = activity.get(claim.slug) || ''
+    const ultima = commit && commit > claim.started ? commit : claim.started
+    const quieta = days(ultima, today)
+    if (quieta > STALE_DAYS) {
+      const senal = commit
+        ? `último commit hace ${days(commit, today)} días`
+        : 'la rama de la tarea no tiene commits'
+      lines.push(`${claim.at}: ${claim.slug} sin avanzar hace ${quieta} días `
+        + `(${claim.owner}, tomada hace ${days(claim.started, today)}; ${senal}); mirá si sigue viva`)
+    }
+  }
+  // Dos tareas del mismo servicio pueden tocar los mismos archivos, y eso no se puede saber antes de
+  // hacerlas. Lo único que se puede es decirlo a tiempo de que hablen, así que avisa y nunca frena:
+  // frenar serializaría a un equipo entero sobre un servicio, que es peor que la colisión que evita.
+  const byService = new Map()
+  for (const claim of claims.filter((one) => one.service && !done.set.has(one.slug))) {
+    byService.set(claim.service, [...(byService.get(claim.service) || []), claim])
+  }
+  for (const [service, group] of byService) {
+    if (group.length < 2) continue
+    lines.push(`${group.length} tareas tomadas sobre ${service} `
+      + `(${group.map((one) => `${one.slug} · ${one.owner}`).join('; ')}); pueden tocar los mismos archivos`)
+  }
+  return lines
+}
+
+module.exports = { DIR, STALE_DAYS, owner, runner, branchOf, file, read, content, validate, warnings }

package/engine/planning/contracts.js

@@ -8,7 +8,6 @@ const { PLACEHOLDERS } = require('../core/onboarding')
 const TEST_TRACE = /^(?:n\/a\s*[—-]\s*.+|(?:A|C\d+)\s*(?:→|->)\s*\S.+)$/i
 const DECISION_TRACE = /\[(?:fuente|supuesto):\s*[^\]]+\]/i
 const COMMIT_TRACE = /^(?:n\/a\s*[—-]\s*.+|[0-9a-f]{7,40}\s+\S.*)$/i
-const EPIC_AUXILIARY_FILES = new Set(['notes.md', 'plan.md', 'research.md', 'spec.md'])
 
 function validTestTrace(value) {
   return String(value || '').split(/\s*;\s*/).filter(Boolean)
@@ -75,6 +74,9 @@ function doneEntryErrors(entry, epics = []) {
   const at = `${entry.source} ${entry.slug}`
   const errors = []
   if (!entry.acceptance) errors.push(`${at}: falta acept:`)
+  // La fecha de cierre. Mientras las entradas vivían en un archivo, el orden lo daba la posición; con un
+  // archivo por tarea no hay posición, y sin fecha no hay forma de saber cuál se cerró antes.
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(entry.fecha)) errors.push(`${at}: falta fecha: AAAA-MM-DD`)
   if (!entry.done) errors.push(`${at}: falta done:`)
   if (!entry.qa) errors.push(`${at}: falta qa:`)
   if (!entry.commit) errors.push(`${at}: falta commit:`)
@@ -117,201 +119,41 @@ function validateEpic(epic, done = new Set()) {
   return errors
 }
 
-function validateRoadmapStructure(dir) {
-  const roadmap = path.join(dir, 'roadmap')
-  let entries = []
-  try { entries = fs.readdirSync(roadmap, { withFileTypes: true }) } catch { return ['falta roadmap/'] }
+// Las dependencias declaradas, contra lo que existe y contra sí mismas. Dos errores distintos y los dos
+// dejan tareas que no se le ofrecen a nadie: una que depende de algo que no existe no está lista nunca, y
+// un ciclo se traba entero. Las dos se ven como una cola que no avanza y sin causa visible.
+function dependencyErrors(milestones, done) {
   const errors = []
-  for (const entry of entries) {
-    // Un archivo que se llama como una épica y no cumple el patrón no lo lee nadie: ni `check`, ni
-    // `tree`, ni el runner que busca trabajo. Ignorarlo en silencio es peor que rechazarlo, porque el
-    // planning se reporta válido mientras la épica que alguien escribió no existe para el sistema.
-    if (/^epic-/.test(entry.name) && !/^epic-\d{3}-/.test(entry.name)) {
-      errors.push(
-        `roadmap/${entry.name}: nadie lo lee. Una épica se nombra epic-NNN-<slug>.md, `
-        + 'o un directorio epic-NNN-<slug>/ con spec.md adentro.',
-      )
-      continue
-    }
-    if (!entry.isDirectory() || !/^epic-\d{3}-/.test(entry.name)) continue
-    const epicDir = path.join(roadmap, entry.name)
-    if (!fs.existsSync(path.join(epicDir, 'spec.md'))) {
-      errors.push(`roadmap/${entry.name}: falta spec.md`)
-    }
-    for (const child of fs.readdirSync(epicDir, { withFileTypes: true })) {
-      if (!child.isFile() || !EPIC_AUXILIARY_FILES.has(child.name)) {
-        errors.push(`roadmap/${entry.name}/${child.name}: archivo auxiliar no permitido`)
+  const tasks = milestones.flatMap((milestone) => milestone.tasks)
+  const queued = new Map(tasks.map((task) => [task.slug, task.depends || []]))
+  for (const task of tasks) {
+    for (const dep of task.depends || []) {
+      if (dep === task.slug) errors.push(`BACKLOG ${task.slug}: depende de sí misma`)
+      else if (!queued.has(dep) && !done.set.has(dep)) {
+        errors.push(`BACKLOG ${task.slug}: depende de ${dep}, que no existe en BACKLOG ni DONE`)
       }
     }
   }
-  return errors
-}
-
-// El BACKLOG es la única cola, y su lector descarta en silencio lo que no cumple el contrato: una
-// viñeta mal escrita no está en cola, no aparece en `tree` y no la toma nadie, sin que nada falle.
-// Se juzga sólo lo que vive bajo un hito —el encabezado del archivo es prosa— y sólo las viñetas,
-// para no confundir con un error el texto que acompaña a una tarea.
-function validateBacklogStructure(dir) {
-  const text = P.withoutComments(P.read(path.join(dir, 'BACKLOG.md')))
-  const errors = []
-  let milestone = ''
-  for (const line of text.split('\n')) {
-    const heading = line.match(P.MILESTONE_HEADING)
-    if (heading) { milestone = heading[1]; continue }
-    if (/^##\s+Hito\b/.test(line)) {
-      errors.push(`BACKLOG "${line.trim()}": encabezado inválido; se escribe ## Hito <slug> — <Título>, `
-        + 'y sin él las tareas que vienen abajo quedan huérfanas')
-      milestone = ''
-      continue
+  // 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(' → ')}`)
+      return
     }
-    if (/^##\s+/.test(line)) { milestone = ''; continue }
-    if (!milestone || !/^\s*[-*]\s+\S/.test(line) || P.TASK_LINE.test(line)) continue
-    const lane = line.match(P.TASK_LINE_ANY_LANE)
-    if (lane) {
-      errors.push(`BACKLOG ${lane[1].trim()}: lane "${lane[2]}" no existe; usá ${P.LANES.join(' | ')}, `
-        + 'o dejá la tarea sin clasificar')
-      continue
-    }
-    const at = `BACKLOG hito ${milestone}: no la lee nadie`
-    if (/^-\s+\[[xX]\]/.test(line)) {
-      errors.push(`${at} — ${line.trim().slice(0, 60)}. Una tarea terminada se mueve a DONE.md, no se tilda acá.`)
-      continue
-    }
-    errors.push(`${at} — ${line.trim().slice(0, 60)}. Una tarea se escribe `
-      + '`- [ ] **slug** [lane] — descripción`, con `(→ CN) (epic: NNN)` o `_Aceptación:_` después del guión.')
-  }
-  return errors
-}
-
-// El número de una regla es su identificador, y lo cita todo el sistema: cargos, workflows, plantillas
-// y entradas de DONE. El override se declara escribiendo un archivo con el mismo nombre que el del
-// sistema —ahí redefinir sus números es el punto—; en cualquier otro archivo, reusar un `R` crea una
-// segunda definición que nadie declaró y que ninguna herramienta veía. Las propias se numeran `P`.
-function ruleIds(file) {
-  return [...P.read(file).matchAll(/^##\s+([A-Z]\d+)\s+[—-]/gm)].map((match) => match[1])
-}
-
-// Qué IDs deja de regir un override por nombre: los que definía el archivo del sistema y el propio no
-// redefine. Reemplazar el archivo entero es la función del override y está documentada; lo que no se
-// veía es la consecuencia, porque la advertencia nombraba el par de archivos y no la diferencia. El
-// caso caro es una regla que el motor sigue exigiendo —R17 lo hace—: queda exigida y sin estar escrita
-// en ningún lado, y quien la vea fallar la va a buscar en `rules/`, donde ya no está.
-// Dos secciones de una épica que compiten por el mismo rol. El parser prefiere la exacta, así que
-// resuelve —y en silencio: quien escribió las dos no se entera de que una se ignora entera. La
-// promoción dejó de generarlas cuando lo importado empezó a bajar un nivel; a mano se siguen pudiendo
-// escribir, y ahí el aviso es lo único que lo dice.
-function competingSections(dir) {
-  const roadmap = path.join(dir, 'roadmap')
-  const avisos = []
-  let files = []
-  try { files = fs.readdirSync(roadmap).filter((file) => /^epic-\d{3}-/.test(file)) } catch { return [] }
-  for (const file of files.sort()) {
-    const text = P.read(path.join(roadmap, file))
-    const titles = [...text.matchAll(/^##\s+(.+)$/gm)].map((hit) => hit[1].trim())
-    for (const role of [/Criterios/i, /Historias/i]) {
-      const casan = titles.filter((title) => role.test(title))
-      if (casan.length < 2) continue
-      const exact = new RegExp(`^${role.source}$`, role.flags)
-      const gana = casan.find((title) => exact.test(title)) || casan[0]
-      const ignoradas = casan.filter((title) => title !== gana)
-      avisos.push(`roadmap/${file}: "## ${gana}" convive con "## ${ignoradas.join('", "## ')}"; `
-        + 'sólo se lee la primera y el resto se ignora entero')
+    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])
     }
+    estado.set(slug, 'listo')
   }
-  return avisos
-}
-
-function retiredByOverride(dir, name) {
-  const rules = path.join(dir, 'rules')
-  const system = path.join(rules, 'system', name)
-  if (!fs.existsSync(system)) return []
-  const redefined = ruleIds(path.join(rules, name))
-  return ruleIds(system).filter((id) => !redefined.includes(id))
-}
-
-function validateRules(dir) {
-  const rules = path.join(dir, 'rules')
-  const owner = new Map()
-  const errors = []
-  const files = (sub) => {
-    try {
-      return fs.readdirSync(path.join(rules, sub), { withFileTypes: true })
-        .filter((entry) => entry.isFile() && entry.name.endsWith('.md') && entry.name !== 'README.md')
-        .map((entry) => entry.name).sort()
-    } catch { return [] }
-  }
-  const system = new Set(files('system'))
-  for (const name of system) {
-    for (const id of ruleIds(path.join(rules, 'system', name))) {
-      if (owner.has(id)) errors.push(`rules/system/${name}: ${id} ya lo define ${owner.get(id)}`)
-      else owner.set(id, `rules/system/${name}`)
-    }
-  }
-  for (const name of files('')) {
-    // El override se declara por nombre: redefinir los números del archivo que reemplaza es su función.
-    if (system.has(name)) continue
-    for (const id of ruleIds(path.join(rules, name))) {
-      const definedBy = owner.get(id)
-      if (!definedBy) { owner.set(id, `rules/${name}`); continue }
-      errors.push(definedBy.startsWith('rules/system/')
-        ? `rules/${name}: ${id} ya lo define ${definedBy}; una regla propia se numera P1..Pn, `
-          + 'o vive en un archivo con el mismo nombre para declarar el override'
-        : `rules/${name}: ${id} ya lo define ${definedBy}`)
-    }
-  }
-  return errors
-}
-
-// Una decisión que no dice si rige no decide nada, y el molde traía el menú entero en la línea de estado:
-// casi una de cada cinco decisiones escritas con este modelo se publicó con el menú intacto. Presentar
-// las opciones no obliga a elegir; esto sí. Las secciones son las cuatro que se escriben siempre —las
-// alternativas quedan en el molde sin exigirse, porque pedirlas rechazaría a casi todas las que existen—.
-const ADR_STATES = ['Propuesto', 'Aceptado', 'Obsoleto']
-const ADR_SUPERSEDED = /^Reemplazada por \[[^\]]+\]\([^)]+\)(?: \(\d{4}-\d{2}-\d{2}\))?$/
-const ADR_SECTIONS = ['Contexto', 'Decisión', 'Consecuencias', 'Estado de implementación']
-
-function validateAdrFile(at, text) {
-  const errors = []
-  const declared = ((text.match(/^\*\*Estado:\*\*\s*(.+?)\s*$/m) || [])[1] || '').trim()
-  if (!declared) errors.push(`${at}: falta **Estado:**`)
-  else if (declared.includes('|')) errors.push(`${at}: el estado sigue siendo el menú de la plantilla; elegí uno`)
-  else if (!ADR_STATES.includes(declared) && !ADR_SUPERSEDED.test(declared)) {
-    errors.push(`${at}: estado "${declared}" fuera de ${ADR_STATES.join(' | ')} `
-      + '| Reemplazada por [NNN](NNN-slug.md)')
-  }
-  for (const section of ADR_SECTIONS) {
-    if (!new RegExp(`^##\\s+${section}\\s*$`, 'm').test(text)) errors.push(`${at}: falta ## ${section}`)
-  }
-  return errors
-}
-
-// El nombre lleva el id porque de ahí sale la identidad con que se detecta un override, y porque una
-// decisión se cita por número. Sin él, el archivo existe y no lo alcanza ninguna referencia.
-function validateAdr(dir) {
-  const adr = path.join(dir, 'adr')
-  const errors = []
-  const numbers = new Map()
-  const scan = (sub, pattern) => {
-    let entries = []
-    try { entries = fs.readdirSync(path.join(adr, sub), { withFileTypes: true }) } catch { return }
-    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      if (!entry.isFile() || !entry.name.endsWith('.md')) continue
-      if (entry.name === 'README.md' || entry.name === '000-template.md') continue
-      const at = `adr/${sub ? `${sub}/` : ''}${entry.name}`
-      const id = entry.name.match(pattern)
-      if (!id) {
-        errors.push(`${at}: nadie lo lee como decisión. Una ADR se nombra NNN-<slug>.md, `
-          + 'y la del sistema <ID>-NNN-<slug>.md en system/.')
-        continue
-      }
-      if (numbers.has(id[1])) errors.push(`${at}: ${id[1]} ya lo usa ${numbers.get(id[1])}`)
-      else numbers.set(id[1], at)
-      errors.push(...validateAdrFile(at, P.read(path.join(adr, sub, entry.name))))
-    }
-  }
-  scan('', /^(\d{3})-[a-z0-9-]+\.md$/)
-  scan('system', /^([A-Z][A-Z0-9]*-\d{3})-[a-z0-9-]+\.md$/)
-  return errors
+  for (const slug of queued.keys()) visitar(slug, [])
+  return [...new Set(errors)]
 }
 
 // Todo lo que se juzga sobre el estado ya leído: épicas, hitos, tareas, WIP, evidencia y acciones
@@ -319,7 +161,7 @@ function validateAdr(dir) {
 // `validateDoneEntry`, `validateRules`— y estaba creciendo del otro lado sólo porque ahí era más
 // rápido escribirla. No lee nada: recibe el estado, así que se prueba sin tocar disco.
 function validateState({
-  epics, milestones, done, wip, roles = new Set(), humanActions = [], adopted = new Set(),
+  epics, milestones, done, wips = [], roles = new Set(), humanActions = [], adopted = new Set(),
 }) {
   const errors = []
   const epicNums = new Set()
@@ -399,15 +241,20 @@ function validateState({
     }
   }
 
-  if (wip && !backlogSlugs.has(wip.task) && !done.set.has(wip.task)) {
-    errors.push(`WIP ${wip.task}: no existe en BACKLOG ni DONE`)
-  }
+  errors.push(...dependencyErrors(milestones, done))
+
+  for (const wip of wips) {
+    const at = `wip/${wip.runner}.md`
+    if (!backlogSlugs.has(wip.task) && !done.set.has(wip.task)) {
+      errors.push(`${at}: ${wip.task} no existe en BACKLOG ni DONE`)
+    }
   // El WIP es el punto de retorno tras una interrupción, y el protocolo manda seguir desde el primer
   // paso sin tildar. Un plan que el motor no puede contar se lee como un plan terminado, así que la
   // recuperación se queda sin de dónde retomar justo cuando es lo único que quedó del trabajo.
-  if (wip && !wip.complete && !wip.pending) {
-    errors.push(`WIP ${wip.task}: el plan no tiene pasos que el motor pueda contar; `
-      + 'se escriben `1. [ ] paso`')
+    if (!wip.complete && !wip.pending) {
+      errors.push(`${at}: el plan de ${wip.task} no tiene pasos que el motor pueda contar; `
+        + 'se escriben `1. [ ] paso`')
+    }
   }
   for (const row of humanActions) {
     if (!row.valid) {
@@ -444,15 +291,9 @@ function validateState({
 module.exports = {
   validateState,
   doneEntryErrors,
-  validateAdr,
-  validateRules,
-  retiredByOverride,
-  competingSections,
-  validateBacklogStructure,
   validCommitTrace,
   validDecisionTrace,
   validTestTrace,
   validateDoneEntry,
   validateEpic,
-  validateRoadmapStructure,
 }