@ingeniomaps/cauce 0.94.0 → 0.95.0

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.95.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",