@ingeniomaps/cauce 0.94.0 → 0.96.0

package/engine/cli/worktree.js

@@ -15,7 +15,7 @@ const ST = require('../planning/state')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const O = require('../core/ownership')
-const { fail, planningRoot } = require('./io')
+const { fail, planningRoot, USAGE, REFUSED } = require('./io')
 
 const git = (cwd, ...args) => spawnSync('git', args, { cwd, encoding: 'utf8' })
 
@@ -34,38 +34,38 @@ function existing(repo, branch) {
 
 function worktree(dir, slug, cli) {
   const root = planningRoot(dir)
-  if (!slug) return fail('Falta el slug. `ops worktree <planning-dir> <tarea>`', 2)
+  if (!slug) return fail('Falta el slug. `ops worktree <planning-dir> <tarea>`', USAGE)
   const state = ST.snapshot(root)
   const task = state.milestones.flatMap((milestone) => milestone.tasks).find((one) => one.slug === slug)
-  if (!task) return fail(`${slug} no está en BACKLOG: sólo se prepara trabajo ya promovido.`, 2)
+  if (!task) return fail(`${slug} no está en BACKLOG: sólo se prepara trabajo ya promovido.`, USAGE)
 
   // No reserva —eso es `claim`— pero se niega a montar sobre lo de otro: preparar un árbol para una
   // tarea ajena es trabajo que se va a tirar, y el aviso cuesta menos que descubrirlo después.
   const taken = state.claims.find((one) => one.slug === slug)
   if (taken && taken.runner !== CL.runner()) {
-    return fail(`${slug} la tomó ${taken.owner}; preparar un árbol para su tarea no ayuda a nadie.`)
+    return fail(`${slug} la tomó ${taken.owner}; preparar un árbol para su tarea no ayuda a nadie.`, REFUSED)
   }
 
   const candidatos = R.reposFor(path.join(root, '..'), task.service)
   if (candidatos.length > 1) {
     return fail(`${task.service || '.'} existe en más de un repositorio (${candidatos.join(', ')}), así que `
-      + 'no puedo saber cuál. Escribí un `service:` que sólo exista en uno.', 2)
+      + 'no puedo saber cuál. Escribí un `service:` que sólo exista en uno.', USAGE)
   }
   const repo = candidatos[0]
   if (!repo) {
     return fail(`no encontré el repositorio de ${task.service || '(sin service)'}: revisá workspaceRoots `
-      + 'en ops.config.json y que la ruta del servicio exista.', 2)
+      + 'en ops.config.json y que la ruta del servicio exista.', USAGE)
   }
 
   const branch = CL.branchOf(slug)
   const already = existing(repo, branch)
   const target = already || path.join(path.dirname(repo), `${path.basename(repo)}-${slug}`)
   if (!already) {
-    if (fs.existsSync(target)) return fail(`${target} ya existe y no es un árbol de esta rama.`)
+    if (fs.existsSync(target)) return fail(`${target} ya existe y no es un árbol de esta rama.`, REFUSED)
     const hasBranch = git(repo, 'rev-parse', '--verify', '--quiet', `refs/heads/${branch}`).status === 0
     const args = hasBranch ? ['worktree', 'add', target, branch] : ['worktree', 'add', '-b', branch, target]
     const added = git(repo, ...args)
-    if (added.status !== 0) return fail(`git worktree add falló: ${(added.stderr || '').trim()}`)
+    if (added.status !== 0) return fail(`git worktree add falló: ${(added.stderr || '').trim()}`, REFUSED)
   }
 
   if (cli.has('--json')) {

package/engine/core/onboarding.js

@@ -119,7 +119,10 @@ function orphanCredentials(root) {
     path.join('planning', 'HUMAN_ACTIONS.md')]
     .map((file) => { try { return fs.readFileSync(path.join(root, file), 'utf8') } catch { return '' } })
     .join('\n')
-  if (!contracts) return []
+  // Acá había una salida temprana por `contracts` vacío que no corría nunca —pegar tres cadenas con
+  // `\n` deja `"\n\n"` aunque las tres fallen—, y no se la repone: una credencial que ningún documento
+  // nombra está huérfana igual, y apagar el aviso porque el documento que debía nombrarla está vacío lo
+  // calla justo en la instancia que más lo necesita.
   const orphans = []
   const cut = []
   for (const service of inventory(root)) {

package/engine/core/ownership.js

@@ -164,9 +164,16 @@ function engineAt(root, relative = '') {
 // de copiarse. Se reconocen por contener `system/`, que es el espacio del toolkit y no algo que un
 // proyecto deba crear. Una sola implementación para las dos, o divergen.
 function packageDir(root, name) {
+  // La raíz declarada va también acá, y no sólo en `packagePath`. Las dos contestan dónde está el paquete
+  // sobre la misma instancia y desde el 158 contestaban distinto: en el layout documentado —`npm install`
+  // en la carpeta de la empresa y la instancia adentro— el motor se resolvía y el catálogo no, así que
+  // `check` pasaba en verde y `agents list` devolvía una lista vacía con exit 0, indistinguible de «esta
+  // instancia no tiene cargos». `evaluate` era peor: culpaba a un `SKILL.md` que falta (caso 171).
+  const above = declaredRoot(root)
   const candidates = [
     path.join(root, 'node_modules', '@ingeniomaps', 'cauce', name),
     path.join(root, name),
+    ...(above ? [path.join(above, 'node_modules', '@ingeniomaps', 'cauce', name)] : []),
   ]
   return candidates.find((dir) => fs.existsSync(path.join(dir, 'system'))
     || fs.existsSync(path.join(dir, 'roles', 'system'))) || ''
@@ -299,7 +306,7 @@ const RETIRED = [
 //
 // El manifiesto no las puede desempatar: `trackedPaths()` nunca las registró, así que para el toolkit
 // todo su contenido es igual de ajeno. Sin poder demostrar que lo entregó, no lo borra.
-const RETIRED_COMPARTIDO = ['automatization/runners', 'automatization/workflows']
+const RETIRED_SHARED = ['automatization/runners', 'automatization/workflows']
 
 function retiredWithLearning(root) {
   const found = []
@@ -407,7 +414,7 @@ module.exports = {
   deliveredFiles,
   effectiveRules,
   shippedFiles,
-  RETIRED_COMPARTIDO,
+  RETIRED_SHARED,
   TEMPLATE_OWN,
   TEMPLATE_PREFIXES,
   addedPaths,

package/engine/core/repos.js

@@ -55,10 +55,10 @@ function repoOf(opsRoot, service) {
 // 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, '--']
+  const head = git(repo, 'rev-parse', '--abbrev-ref', 'HEAD')
+  const trunk = head.status === 0 ? head.stdout.trim() : ''
+  const args = trunk && trunk !== branch
+    ? ['log', '-1', '--format=%cs', branch, '--not', trunk, '--']
     : ['log', '-1', '--format=%cs', branch, '--']
   const shown = git(repo, ...args)
   return shown.status === 0 ? shown.stdout.trim() : ''
@@ -85,9 +85,15 @@ function unrecordedCommits(repo, since, recorded) {
   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)))
+  // 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
+  // forma de que una puerta falle (caso 169).
   return log.stdout.split('\n').map((line) => line.trim()).filter(Boolean)
-    .filter((line) => line.slice(8, 18) >= since)
-    .filter((line) => !conocidos.has(line.slice(0, 7)))
+    .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)))
+    .map((one) => one.line)
 }
 
 // Cuánto del trabajo que entró a los repositorios quedó registrado, desde la última tarea cerrada. Avisa
@@ -102,18 +108,18 @@ function unrecordedCommits(repo, since, recorded) {
 // Y no dice cuántos *deberían* tener entrada, porque eso no se sabe desde acá: lo dice el desglose, y en
 // la instancia medida 120 de 173 eran `feat` o `fix` (caso 082).
 function coverageWarnings(opsRoot, done) {
-  const fechas = done.entries.map((entry) => entry.fecha).filter(Boolean).sort()
-  const desde = fechas[fechas.length - 1]
-  if (!desde) return []
+  const dates = done.entries.map((entry) => entry.fecha).filter(Boolean).sort()
+  const since = dates[dates.length - 1]
+  if (!since) return []
   const recorded = new Set()
   for (const entry of done.entries) {
     for (const sha of String(entry.commit || '').matchAll(/\b[0-9a-f]{7,40}\b/g)) recorded.add(sha[0])
   }
   const warnings = []
   for (const repo of reposFor(opsRoot, '.')) {
-    const sueltos = unrecordedCommits(repo, desde, recorded)
-    if (!sueltos.length) continue
-    warnings.push(`${path.basename(repo)}: ${sueltos.length} commit(s) desde ${desde} que ninguna `
+    const unrecorded = unrecordedCommits(repo, since, recorded)
+    if (!unrecorded.length) continue
+    warnings.push(`${path.basename(repo)}: ${unrecorded.length} commit(s) desde ${since} que ninguna `
       + 'entrada de DONE nombra, así que ese trabajo no está en planning/ (OPS-001)')
   }
   return warnings

package/engine/hooks/approval.js

@@ -96,9 +96,17 @@ function where(input) {
 function HOW(variable, lines, input, pasteable = lines) {
   const chat = CHAT.hold(input, lines)
   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
+  // faltaban no son la misma: que **cubre lo frenado y nada más** explica por qué un archivo nuevo vuelve a
+  // frenar, que desde afuera se lee como que el guard se olvidó; y que **sigue valiendo en los mensajes
+  // 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 esperá: si contesta «dale», reintentá el mismo cambio y '
-      + 'pasa. '
+      + 'pasa. Ese «dale» 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 paste = pasteable.length
     ? (chat ? 'Si prefiere aprobarlo a mano, que pegue ella tal cual en' : 'Aprobalo pegando tal cual en')

package/engine/hooks/chat.js

@@ -116,13 +116,13 @@ function mentions(text, item) {
       if (before && !/[\s'"`(/]/.test(before)) continue
       if (rest && !/^(?:[\s'"`),;:!?]|\.(?:\s|$)|$)/.test(rest)) continue
       const clause = lower.slice(0, at).split(CLAUSE).pop()
-      const frase = `${clause} ${rest.split(CLAUSE)[0]}`
+      const phrase = `${clause} ${rest.split(CLAUSE)[0]}`
       found.push({
         denied: NEGATION.test(clause),
-        asked: asks(frase),
+        asked: asks(phrase),
         // El alcance se lee de la misma frase que decide si la ruta fue pedida, y no del mensaje entero:
         // un «mientras dure la tarea t-014» que hable de otra cosa, en otra oración, no acota a ésta.
-        scope: (frase.match(SCOPE) || [])[1] || '',
+        scope: (phrase.match(SCOPE) || [])[1] || '',
       })
     }
   }
@@ -183,11 +183,19 @@ function record(input) {
     // alcance que ya no acota a nadie.
     const scopes = {}
     for (const one of granted) if (previous.scopes && previous.scopes[one]) scopes[one] = previous.scopes[one]
+    // Que haya alguien a quien preguntarle es de la sesión y no de este mensaje. Una notificación de una
+    // tarea de fondo entra por este mismo hook —es un `UserPromptSubmit` con el texto
+    // `<task-notification>…`, medido sobre los registros reales— así que se anota con `human: false`, y
+    // sin esto borraba del registro a la persona que está mirando el bloqueo en ese instante. Se arrastra
+    // igual que `granted` y por la misma razón: un aviso del runner en el medio no se lleva puesto lo que
+    // ya era cierto. Lo vuelve a decidir el mensaje humano siguiente (caso 166).
+    const flow = flowCommand(text)
+    const askable = human ? !flow : Boolean(previous && previous.askable)
     fs.mkdirSync(DIR, { recursive: true })
     // Sobre qué instancia se está hablando, que es lo que después deja filtrar lo concedido: por qué hace
     // falta, en `grantedIn`.
     fs.writeFileSync(recordPath(input.session_id), JSON.stringify(
-      { id: idOf(input), text, human, flow: flowCommand(text), root: opsRoot(input), approved, granted,
+      { id: idOf(input), text, human, askable, flow, root: opsRoot(input), approved, granted,
         scopes, pending: [] }))
   } catch { /* registrar es un extra: si falla, los guards siguen frenando lo que frenaban */ }
 }
@@ -203,6 +211,20 @@ function said(input) {
   return current && saved.id && current !== saved.id ? null : saved
 }
 
+// Hay una persona en esta sesión a quien preguntarle, que no es lo mismo que «este mensaje lo escribió
+// ella». `said` contesta la segunda porque de ella depende **conceder**; ésta contesta la primera, que es
+// todo lo que hace falta para decidir si el bloqueo ofrece contestar «dale» o manda a pegar líneas en un
+// archivo. Preguntar no es conceder, y fundir las dos preguntas le cobraba un copiar y pegar a la persona
+// justo cuando estaba mirando (caso 166).
+//
+// Un registro escrito antes de que `askable` existiera no lo trae y queda afuera: la sesión pierde la
+// salida por chat hasta el mensaje siguiente, que la vuelve a escribir. Es la dirección barata del error.
+function present(input) {
+  if (process.env.CI || input.agent_id || !input.session_id) return null
+  const saved = load(input.session_id)
+  return saved && saved.askable ? saved : null
+}
+
 // Con qué autorización pasa un ítem, o vacío si no pasa: lo pidió este mensaje, un «dale» aprobó lo que
 // había quedado frenado, o se lo concedieron antes en esta sesión. Qué cuenta como pedirlo depende de qué
 // se frena: un archivo se nombra, un push se ordena con su remoto y su rama.
@@ -303,7 +325,7 @@ function unauthorizedNow(input, items) {
 // Lo que quedó frenado, para que un «dale» en el mensaje siguiente apruebe exactamente eso y nada más.
 // Devuelve si hay una persona a quien preguntarle.
 function hold(input, items) {
-  const saved = said(input)
+  const saved = present(input)
   if (!saved) return false
   try {
     saved.pending = [...new Set([...saved.pending, ...items])]

package/engine/hooks/files.js

@@ -8,7 +8,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const {
-  patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot, opsRoot,
+  patchOf, filesOf, contentOf, cwdOf, block, configOf, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT,
 } = require('./input')
 const AP = require('./approval')
@@ -242,10 +242,10 @@ function planFirst(input) {
   //
   // Se lista recién acá, después de las dos salidas de arriba: quien tiene su plan sale por la primera y
   // no paga esta lectura, que es la misma razón por la que `hasTasks` se pregunta donde se pregunta.
-  const ajenos = readWips(planning).filter((one) => one.complete + one.pending > 0)
+  const foreign = readWips(planning).filter((one) => one.complete + one.pending > 0)
   const estado = wip ? `WIP tiene la tarea ${wip.task} y ningún paso` : 'WIP está en IDLE'
-  const why = ajenos.length
-    ? `hay plan escrito, pero bajo otro id: ${ajenos.map((one) => `${one.runner} (${one.task})`).join(', ')}.\n`
+  const why = foreign.length
+    ? `hay plan escrito, pero bajo otro id: ${foreign.map((one) => `${one.runner} (${one.task})`).join(', ')}.\n`
       + 'Si ese plan es tuyo, volvé a su id con `export CAUCE_RUNNER=<id>` —`ops runners <planning>` los lista '
       + 'con su tarea y su avance— y repetí el cambio. Si vas a trabajar en paralelo, montá tu propio árbol '
       + 'con `ops worktree <planning> <tarea>`, que te devuelve el id hecho.\n'
@@ -258,7 +258,7 @@ function planFirst(input) {
     // Con un plan a la vista no se ofrece ninguna de las dos salidas: aprobar la ruta escribe «esto no es
     // trabajo de una tarea», que ahí es falso, y anunciar la variable ofrece el permiso más ancho cuando
     // la acción correcta es angosta y concreta —el mismo criterio con que `HOW` decide no nombrarla—.
-    const how = ajenos.length
+    const how = foreign.length
       ? AP.HOW(null, [], input, [])
       : AP.HOW('OPS_PLAN_FIRST_OVERRIDE', [raw], input)
     block(`${raw} cambia el producto sin plan. ${why}${how}`)
@@ -359,7 +359,7 @@ function migrations(input) {
 // empresa corre un motor que no coincide con la versión que declara —la clase de diferencia que
 // aparece como un bug irreproducible—. En modo `toolkit` no aplica: ahí el motor es el producto.
 function engineWrites(input) {
-  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+  const root = opsRoot(input)
   if (!root) return
   const config = configOf(root)
   if (config.mode === 'toolkit') return

package/engine/hooks/input.js

@@ -157,7 +157,10 @@ function gitDirectory(command, cwd) {
 // de correr: gobernanza, dependencias y generados. Cualquier variable delante alcanza, y la ironía es
 // que el prefijo que el procedimiento manda escribir para un commit de gobernanza es
 // `OPS_GOVERNANCE_OVERRIDE=1`: escrito ahí, el guard no lee el override, directamente no se ejecuta.
-const PREFIX = String.raw`(?:^|[;&|]\s*)(?:(?:env|sudo)\s+)*`
+// El ancla admite el salto de línea y el `(` por lo mismo que admite `;`: los tres abren un comando. El
+// salto es el que más caro salía —dos líneas en un solo Bash es como se escriben dos pasos— y el léxico
+// de `shell.js` ya lo declaraba separador; acá faltaba (caso 165).
+const PREFIX = String.raw`(?:^|[;&|(\n]\s*)(?:(?:env|sudo)\s+)*`
   + String.raw`(?:[A-Za-z_][A-Za-z0-9_]*=(?:'[^']*'|"[^"]*"|\S*)\s+)*`
 const COMMIT = new RegExp(PREFIX + String.raw`git\s+commit(?:\s|$)`)
 
@@ -230,7 +233,7 @@ function findOpsRoot(start) {
 // Sin raíz legible no hay lista, y quien pregunta se abstiene: el guard que no sabe dónde está no
 // inventa un límite.
 function writableRoots(input) {
-  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+  const root = opsRoot(input)
   if (!root) return null
   const config = configOf(root)
   return [

package/engine/hooks/run.js

@@ -9,7 +9,7 @@
 const fs = require('node:fs')
 const os = require('node:os')
 const path = require('node:path')
-const { readInput, cwdOf, block, findOpsRoot } = require('./input')
+const { readInput, block, opsRoot } = require('./input')
 const shell = require('./shell')
 const { verify } = require('./verify')
 const files = require('./files')
@@ -18,7 +18,7 @@ const { secretsShell } = require('./secrets-shell')
 const { opsConfig, opsConfigShell } = require('./ops-config')
 
 function planningDrift(input) {
-  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+  const root = opsRoot(input)
   if (!root) return
   const local = path.join(root, 'tools', 'ops.js')
   const source = path.join(root, 'engine', 'cli', 'ops.js')
@@ -202,5 +202,5 @@ if (require.main === module) {
 }
 
 module.exports = {
-  execute, executeAll, findOpsRoot, guards, hookGroups, hookMetadata,
+  execute, executeAll, guards, hookGroups, hookMetadata,
 }

package/engine/hooks/shell.js

@@ -120,7 +120,13 @@ function destructive(input) {
       'Operación destructiva sobre disco o dispositivo.',
     ],
     [
-      new RegExp(String.raw`\brm\s+(?:-[^\s]*r[^\s]*\s+)+(?:\/\*?|~\/?|\$HOME|\.\.)(?=${PALABRA})`),
+      // El destino se reconoce como lo escribe una persona y no sólo desnudo: entre comillas, con llaves,
+      // detrás de `--` y con barra final. Las comillas importan más que las otras tres — `rm -rf "$HOME"`
+      // es la forma *correcta* de escribirlo en bash, así que sin esto el hueco premiaba al que cita bien
+      // sus variables. Y `destructive` no desentrecomilla fuera de un commit, a propósito, así que la
+      // comilla tiene que entrar en el patrón (caso 167).
+      new RegExp(String.raw`\brm\s+(?:-[^\s]*r[^\s]*\s+)+(?:--\s+)?['"]?`
+        + String.raw`(?:\/\*?|~\/?|\$\{?HOME\}?\/?|\.\.)(?=${PALABRA})`),
       "'rm -r' sobre /, home o el directorio padre es catastrófico.",
     ],
   ]
@@ -252,7 +258,12 @@ function dependencies(input) {
 // era la causa —sólo hacía que la lectura frenara en un token que sobrevive—: sin él la lista cruzaba
 // igual y el último token era la marca de lo entrecomillado, que el filtro final descarta. O sea que
 // pasaba de casualidad, y aserciar que pasa no fijaba nada.
-const REDIRECT = /(?:^|[\s(])&?\d*>>?\s*(?![&(])([^\s;|&<>()]+)/g
+// Y el `|` después de `>` es el override de `noclobber`, no una tubería: `>| destino` escribe igual que
+// `> destino` aunque el shell esté configurado para no pisar. Sin admitirlo acá el guard no veía ese
+// destino —el `|` está fuera de la clase que captura la ruta, así que la coincidencia moría—, y con él
+// se perdían los tres guards que salen de `writesWithBase` a la vez. Lo que un agente se escribía por
+// ese hueco era su propia `.ops-approval` (caso 164).
+const REDIRECT = /(?:^|[\s(])&?\d*>>?\|?\s*(?![&(])([^\s;|&<>()]+)/g
 const EVERY_ARG = /(?:^|[\s;|&(])(tee|truncate)\s+([^;|&<>()\n]+)/g
 const LAST_ARG = /(?:^|[\s;|&(])(cp|mv|install|rsync)\s+([^;|&<>()\n]+)/g
 const SED = /(?:^|[\s;|&(])sed\s+([^;|&<>()\n]+)/g
@@ -315,7 +326,10 @@ function cdTarget(argument, base) {
 function writesWithBase(command, cwd) {
   const found = []
   let base = cwd
-  for (const segment of unquoted(command).split(/[;&|\n]+/)) {
+  // El `|` que sigue a un `>` no parte nada: es el override de `noclobber`, no una tubería. Partir ahí
+  // separaba la redirección de su destino —`echo x >| ruta` quedaba como `echo x >` y ` ruta`— y el
+  // destino no lo veía nadie, que es por donde se colaba escribir la propia `.ops-approval` (caso 164).
+  for (const segment of unquoted(command).split(/[;&\n]+|(?<!>)\|+/)) {
     const cd = segment.match(/^\s*cd(?:\s+(\S+))?\s*$/)
     if (cd) { base = base === null ? null : cdTarget(cd[1], base); continue }
     for (const raw of writeTargets(segment)) found.push({ raw, base })
@@ -380,9 +394,9 @@ function governance(input) {
   // La aprobación vale para lo que nombra y para nada más: lo que quede sin cubrir es lo que se
   // reporta. Así una aprobación vieja no autoriza el archivo que se sumó después, que es la diferencia
   // entre una llave por operación y una puerta que quedó abierta.
-  const pendientes = AP.pendingNow(opsRoot(input), governed, input)
-  if (!pendientes.length) return
-  block(`El commit toca gobernanza protegida.\n${AP.HOW('OPS_GOVERNANCE_OVERRIDE', pendientes, input)}`)
+  const pending = AP.pendingNow(opsRoot(input), governed, input)
+  if (!pending.length) return
+  block(`El commit toca gobernanza protegida.\n${AP.HOW('OPS_GOVERNANCE_OVERRIDE', pending, input)}`)
 }
 
 function run(program, args, cwd, extra = {}) {

package/engine/hooks/verify.js

@@ -216,15 +216,15 @@ function fallo(gate, result) {
 // Un gate que vuelve en menos de esto no corrió una suite. No se afirma que **no** haya corrido —un
 // lint puede fallar rápido y de verdad— y por eso lo que se agrega es el número, no un veredicto: los
 // tres gates del caso 068 volvieron a un segundo uno de otro contra los trece de la corrida real.
-const DEMASIADO_RAPIDO = 2000
-function comoSeLee(failures) {
-  const texto = failures
+const TOO_FAST = 2000
+function howItReads(failures) {
+  const summary = failures
     .map((one) => `${one.gate} (exit ${one.status}, ${(one.ms / 1000).toFixed(1)} s)`
       + `${one.line ? `: ${one.line}` : ''}`)
     .join('; ')
-  if (!failures.every((one) => one.ms < DEMASIADO_RAPIDO)) return texto
-  const cuantos = failures.length === 1 ? 'Volvió' : `Los ${failures.length} volvieron`
-  return `${texto}\n${cuantos} en menos de ${DEMASIADO_RAPIDO / 1000} s: eso no alcanza para correr `
+  if (!failures.every((one) => one.ms < TOO_FAST)) return summary
+  const lead = failures.length === 1 ? 'Volvió' : `Los ${failures.length} volvieron`
+  return `${summary}\n${lead} en menos de ${TOO_FAST / 1000} s: eso no alcanza para correr `
     + 'una suite, así que mirá si llegaron a ejecutarse antes de aprobar esto como un rojo conocido.'
 }
 
@@ -268,7 +268,7 @@ function verifyGates(root, dir, sinAprobar, env, input) {
   // comando a mano se lee como que el guard miente, y lo que pasó es que midió lo que se va a grabar.
   const donde = root === dir ? '' : '\nCorrió sobre el índice, que es lo que el commit graba: si en tu '
     + 'directorio pasa, es que en disco tenés algo que no está staged.'
-  block(`Verify falló en ${path.basename(dir)}: ${comoSeLee(failures)}\nNo se commitea en rojo.${donde}\n`
+  block(`Verify falló en ${path.basename(dir)}: ${howItReads(failures)}\nNo se commitea en rojo.${donde}\n`
     + AP.HOW('OPS_SKIP_VERIFY', sinAprobar, input))
 }
 

package/engine/integrations/proposals.js

@@ -40,7 +40,11 @@ function validate(root, provider, workspaces = []) {
   let maxHours = 4
   try {
     const config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8'))
-    maxHours = config.runner.maxTaskHours
+    // `|| maxHours` y no a secas: un `runner` sin `maxTaskHours` no lanza, así que el `catch` no lo ve
+    // y el tope quedaba en `undefined`. `estimate > undefined` es falso siempre, o sea que el límite
+    // desaparecía entero y en silencio — el modo de fallo que menos se nota, porque lo que deja de
+    // pasar es un rechazo.
+    maxHours = config.runner.maxTaskHours || maxHours
   } catch { /* reported by the main validator */ }
   for (const proposal of read(root, provider)) {
     const at = `integrations/${provider}/proposed/${proposal.file}`

package/engine/integrations/registry.js

@@ -197,6 +197,13 @@ function validate(root, onlyProvider = '') {
         if (fields.promotionKind === 'story' && (!/^\d{3}$/.test(fields.promotionEpic) || !fields.promotionCriteria)) {
           errors.push(`${at}: story exige promotionEpic NNN y promotionCriteria`)
         }
+        // Para una épica el campo es opcional —sin él el número lo elige el motor—, y por eso nadie lo
+        // miraba: el único caso sin validar era justo el que arma el nombre del archivo con lo que diga.
+        // `promotionEpic: 7` producía `epic-7-…`, que el roadmap no reconoce como épica, y un `..` sacaba
+        // la épica de `roadmap/` entero con `promote` devolviendo 0 y anunciando que promovió.
+        if (fields.promotionKind === 'epic' && fields.promotionEpic && !/^\d{3}$/.test(fields.promotionEpic)) {
+          errors.push(`${at}: promotionEpic debe ser NNN`)
+        }
         if (!sections.Aceptación || /^(por definir|n\/a|pendiente)\.?$/i.test(sections.Aceptación)) {
           errors.push(`${at}: ready exige aceptación concreta`)
         }

package/engine/integrations/state.js

@@ -107,9 +107,12 @@ function derive(snapshot, draft) {
 }
 
 function renderDraft(item, config, state = 'pending') {
-  const service = config.serviceFrom === 'component' && item.components.length === 1
-    ? item.components[0]
-    : ''
+  // `|| []` porque el item lo arma el adaptador y el README declara el contrato por sus tres funciones,
+  // sin decir qué campos trae un item. Uno propio —que es lo que ese README invita a escribir— puede no
+  // traer `components`, y con `serviceFrom: "component"`, que es lo que trae el molde, eso era un
+  // TypeError sin nada que lo atribuya. Sin campo la respuesta es la que el borrador ya sabe dar.
+  const components = item.components || []
+  const service = config.serviceFrom === 'component' && components.length === 1 ? components[0] : ''
   const acceptance = item.acceptance || 'Por definir.'
   const issues = []
   if (!item.acceptance) issues.push('La incidencia no contiene aceptación concreta.')

package/engine/planning/adoption.js

@@ -74,9 +74,9 @@ function sealWarnings(dir) {
   if (extra > 0) {
     // Cuáles sobran no se puede decir sin el conjunto original, y la cuenta sí: se nombran los últimos,
     // que es donde se agrega a mano. Decir «alguna de éstas» es más honesto que señalar la equivocada.
-    const últimos = slugs.slice(-extra).join(', ')
+    const lastOnes = slugs.slice(-extra).join(', ')
     return [`${BASELINE}: la lista creció. La huella sella ${seal[1]} entrada(s) y hay ${slugs.length}; `
-      + `sobra(n) ${extra}, probablemente ${últimos}. Una entrada agregada a mano queda exenta para `
+      + `sobra(n) ${extra}, probablemente ${lastOnes}. Una entrada agregada a mano queda exenta para `
       + 'siempre y nada más lo dice.']
   }
   return [`${BASELINE}: la huella no coincide con la lista. Sella ${seal[1]} entrada(s) y hay `

package/engine/planning/claims.js

@@ -109,7 +109,7 @@ function validate({ claims, milestones, done }) {
   return errors
 }
 
-const days = (from, to) => Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`))
+const daysBetween = (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
@@ -125,14 +125,14 @@ function warnings({ claims, done, today, activity = new Map() }) {
     }
     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`
+    const lastSeen = commit && commit > claim.started ? commit : claim.started
+    const idleDays = daysBetween(lastSeen, today)
+    if (idleDays > STALE_DAYS) {
+      const signal = commit
+        ? `último commit hace ${daysBetween(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`)
+      lines.push(`${claim.at}: ${claim.slug} sin avanzar hace ${idleDays} días `
+        + `(${claim.owner}, tomada hace ${daysBetween(claim.started, today)}; ${signal}); mirá si sigue viva`)
     }
   }
   // Dos tareas del mismo servicio pueden tocar los mismos archivos, y eso no se puede saber antes de

package/engine/planning/parser.js

@@ -315,13 +315,13 @@ const HUMAN_ACTION_STATES = ['pendiente', 'resuelta']
 // Lo que no cubre: una celda que termine en una barra invertida literal. En markdown eso se escribe
 // `\\` y acá se leería como escape del separador. Es un borde que nadie escribe y taparlo pedía un
 // parser de verdad; queda dicho en vez de supuesto.
-const SEPARADOR = /(?<!\\)\|/
-const SEPARADORES = /^\|\s*:?-+/
+const CELL_SPLIT = /(?<!\\)\|/
+const SEPARATORS = /^\|\s*:?-+/
 
 // El escape se quita al normalizar. Esta columna existe para que una persona lea qué tiene que hacer, y
 // `\|` no es parte de lo que quiso decir: es cómo markdown escribe un pipe. La fila archivada no se ve
 // afectada —`archive` reescribe `raw`, la línea original, no las celdas—, así que quitarlo no pierde nada.
-const celda = (cell) => cell.trim().replace(/\\\|/g, '|')
+const cellOf = (cell) => cell.trim().replace(/\\\|/g, '|')
 
 // Las filas de datos de las tablas de un texto, con las celdas ya normalizadas. Vive acá y no en cada
 // lector porque el escape del pipe tiene que leerse igual en los dos archivos que traen tabla: escrito
@@ -332,11 +332,11 @@ const celda = (cell) => cell.trim().replace(/\\\|/g, '|')
 // y con `findIndex` la segunda y la tercera vuelven a leerse como datos. Nada más se mueve, porque una
 // fila de datos nunca está inmediatamente antes de los guiones.
 function tableRows(text) {
-  const lineas = text.split('\n')
-  const cabeceras = new Set(lineas.map((line, i) => (SEPARADORES.test(line) ? i - 1 : -1)))
-  return lineas
-    .filter((line, i) => /^\|/.test(line) && !SEPARADORES.test(line) && !cabeceras.has(i))
-    .map((line) => ({ line, cells: line.split(SEPARADOR).slice(1, -1).map(celda) }))
+  const lines = text.split('\n')
+  const headers = new Set(lines.map((line, i) => (SEPARATORS.test(line) ? i - 1 : -1)))
+  return lines
+    .filter((line, i) => /^\|/.test(line) && !SEPARATORS.test(line) && !headers.has(i))
+    .map((line) => ({ line, cells: line.split(CELL_SPLIT).slice(1, -1).map(cellOf) }))
 }
 
 function readHumanActions(dir) {

package/engine/planning/state.js

@@ -86,8 +86,8 @@ function currentTask({ milestones, done, wips = [], claims = [] }, blockers = []
     // estaría lista y no acá—, así que buscarla no puede fallar y no lleva defensa.
     waiting: pending.filter((task) => !others.has(task.slug) && !ready(task)).map((task) => {
       const dep = task.depends.find((one) => !done.set.has(one))
-      const otro = others.get(dep)
-      return { slug: task.slug, dep, owner: otro ? otro.owner : (mine.has(dep) ? 'vos' : '') }
+      const other = others.get(dep)
+      return { slug: task.slug, dep, owner: other ? other.owner : (mine.has(dep) ? 'vos' : '') }
     }),
   }
 }

package/engine/planning/structure.js

@@ -98,23 +98,23 @@ function ruleIds(file) {
 // escribir, y ahí el aviso es lo único que lo dice.
 function competingSections(dir) {
   const roadmap = path.join(dir, 'roadmap')
-  const avisos = []
+  const warnings = []
   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 matching = titles.filter((title) => role.test(title))
+      if (matching.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('", "## ')}"; `
+      const winner = matching.find((title) => exact.test(title)) || matching[0]
+      const ignored = matching.filter((title) => title !== winner)
+      warnings.push(`roadmap/${file}: "## ${winner}" convive con "## ${ignored.join('", "## ')}"; `
         + 'sólo se lee la primera y el resto se ignora entero')
     }
   }
-  return avisos
+  return warnings
 }
 
 function retiredByOverride(dir, name) {

package/package.json

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