@ingeniomaps/cauce 0.72.0 → 0.74.0

package/CHANGELOG.md

@@ -14,6 +14,68 @@ desde este repositorio no va, porque el que lee no puede actuar sobre eso. Cuand
 unas pocas líneas casi siempre es porque cuenta cómo se descubrió el problema o por qué se eligió el
 diseño — eso vive en el commit y en el código.
 
+## [0.74.0] - 2026-09-10
+
+### Corregido
+
+- **Un gate ya no pisa lo que vos construiste.** Al medir el índice, lo ignorado se enlazaba al árbol
+  real: el gate corría sobre lo staged y te dejaba la salida de build con **esa** versión, mientras tu
+  fuente en disco tenía otra y nada lo decía. Si corrías la app después de commitear, corrías algo que
+  no era lo que estabas mirando. Ahora lo que un gate puede fabricar —`dist`, `build`, `out`,
+  `coverage`, `.next`, `.nuxt`, `.svelte-kit`, `.turbo`, `.output`, `.parcel-cache`, `__pycache__`,
+  `.pytest_cache`— se construye adentro de la copia y se descarta con ella. Lo que no puede fabricar
+  —`node_modules`, un `.env`— se le sigue enlazando.
+
+  Arregla también algo del propio gate: construía sobre restos de tu corrida anterior, así que su
+  veredicto dependía de un estado que nadie declaró.
+
+  **Lo que te pide algo**: el build del gate deja de ser incremental, así que ese commit tarda más. Y si
+  tu proyecto genera en un directorio ignorado que no está en esa lista, seguí reportándolo: el nombre
+  se agrega.
+
+- **Los gates corren sobre una copia que se declara no interactiva, y un gate que falla dice qué dijo.**
+  `verify` mide el índice en un temporal y enlaza ahí lo ignorado, `node_modules` incluido, apuntando al
+  original. En un proyecto pnpm eso no corre: el gestor ve que el árbol enlazado no fue instalado ahí y
+  su reacción es reinstalar, que empieza borrando el `node_modules` **del proyecto**. Lo único que lo
+  detenía es que el hijo no ve una terminal. Ahora la copia lleva `CI=true`, que es la variable que el
+  propio pnpm nombra — y sólo la copia: si árbol e índice coinciden, los gates corren en tu directorio y
+  ahí no se te cambia nada.
+
+  Y el bloqueo dejaba de decir por qué: `test (exit 1)` era el mismo texto para una suite en rojo y para
+  un gestor que se negó a arrancar el script, así que empujaba a aprobar el commit como «rojo conocido»
+  sin que nada se hubiera medido. Ahora llega con la duración y con la primera línea de error de la
+  herramienta, y cuando todos los gates fallan por debajo de dos segundos lo dice — sin afirmar que no
+  corrieron, que es algo que no se puede saber desde acá.
+
+  **Lo que te pide algo**: si tenías un gate que se comportaba distinto bajo `CI`, ahora lo va a hacer
+  al commitear con algo sin stagear o sin trackear.
+
+## [0.73.0] - 2026-09-09
+
+### Corregido
+
+- **Los guards dejan de frenar trabajo legítimo escrito en varias líneas.** Siete reglas acotaban
+  «dentro de este comando» con `[^;&|]`, y el salto de línea —que también separa comandos— no estaba en
+  esa lista: cualquier bandera de una línea posterior se leía como parte del comando de arriba. `git
+  commit -m "x"` seguido de `ls -a` se bloqueaba como si stageara al commitear, y `git push origin main`
+  seguido de `rm -f /tmp/x` como un force push, que además nombraba una violación que no estaba.
+
+  Lo que frena sigue frenando: `commit -am`, `add -A`, `push --force`, `--amend` e `install -g` en una
+  línea siguen bloqueados, y un `git push` seguido de otra cosa sigue pidiendo la acción humana que R10
+  exige — sólo que ya no lo llama reescritura de historia.
+
+- **Un banco de evaluación que no se puede rehacer lo dice, en vez de seguir sobre uno que no es nuevo.**
+  El borrado ahora se comprueba, y si algo sobrevive la corrida corta nombrando qué. Hasta acá el mismo
+  hecho se venía rodeando por síntoma —reintentos en el borrado, `force` en el andamiaje, un `rm` antes
+  del enlace—, y cada rodeo dejaba la medición siguiente corriendo sobre restos de la anterior.
+
+  La prueba que lo destapaba, además, **descartaba el resultado de la corrida que fallaba**: cualquier
+  causa terminaba en el mismo `true !== false` con el `stderr` tirado, y por eso tres investigaciones
+  dejaron escrito «no está establecido por qué». Ahora la falla llega con su código y su ruta.
+
+  **Lo que te pide algo**: si rehacer un banco te corta con «no se pudo borrar entero», borralo a mano y
+  volvé a correr. Antes eso seguía en silencio y fallaba más adelante, en otro lado.
+
 ## [0.72.0] - 2026-09-09
 
 ### Corregido

package/engine/cli/catalog.js

@@ -102,6 +102,29 @@ function evaluationBench(root, agent, caso, force, kind) {
   // reintentos, rehacer un banco es una operación que falla de vez en cuando y deja la corrida sin
   // empezar.
   fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })
+  // Y se comprueba que haya borrado. `rmSync` puede volver sin lanzar y dejar cosas —pasó en CI y no
+  // está establecido por qué—, y hasta acá cada síntoma se rodeaba por separado: `force` en el
+  // andamiaje, un `rm` antes del enlace. Rodearlo deja la corrida siguiendo sobre un banco que no es
+  // nuevo, y lo que falla después no dice nada del borrado: el test que lo destapó reportaba
+  // `true !== false` sobre un archivo de la corrida anterior, sin nombrar de dónde salía.
+  //
+  // Falla en vez de seguir, porque un banco a medio borrar contamina la medición que viene, que es lo
+  // que la recreación existe para evitar. Y nombra lo que sobrevivió: es lo único que va a permitir
+  // establecer la causa la próxima vez que ocurra.
+  if (fs.existsSync(dir)) {
+    const sobreviven = []
+    const recorrer = (base, relative = '') => {
+      for (const entry of fs.readdirSync(base, { withFileTypes: true })) {
+        if (sobreviven.length >= 5) return
+        const next = relative ? `${relative}/${entry.name}` : entry.name
+        if (entry.isDirectory()) recorrer(path.join(base, entry.name), next)
+        else sobreviven.push(next)
+      }
+    }
+    try { recorrer(dir) } catch { /* el listado es la explicación, no la comprobación */ }
+    fail(`${dir} no se pudo borrar entero y el banco tiene que ser nuevo. Sobrevivieron al borrado: `
+      + `${sobreviven.join(', ') || '(sólo directorios)'}. Borralo a mano y volvé a correr.`, 2)
+  }
   // Con `force`: el banco es desechable y se acaba de borrar, así que lo que sobreviva al `rmSync` se
   // pisa en vez de cortar la corrida. Sin esto, `copyTemplate` se niega ante cualquier archivo que
   // quede —«El destino contiene …/AGENTS.md»— y el mismo test falló así tres veces en un día, en las

package/engine/core/evidence.js

@@ -31,12 +31,16 @@ function logPath(root) {
 
 // Una línea por gate corrido. Nunca lanza: es un efecto de borde de un guard, y un registro que no se
 // puede escribir no puede impedir el commit que estaba juzgando.
-function record(root, gate, status) {
+// `ms` es cuánto tardó el gate, y se guarda porque es lo que separa una suite que falló de una que
+// nunca arrancó. Antes había que restar los `at` de dos líneas seguidas para estimarlo, y esa resta
+// incluye lo que pasó entre gate y gate; el número propio no. Fue lo que costó diagnosticar el caso 068:
+// tres gates «en rojo» a un segundo uno de otro, cuando la corrida real de ese proyecto tarda trece.
+function record(root, gate, status, ms) {
   if (!root) return
   try {
     const file = logPath(root)
     const previous = fs.existsSync(file) ? fs.readFileSync(file, 'utf8').split('\n').filter(Boolean) : []
-    const entry = JSON.stringify({ at: new Date().toISOString(), gate, status })
+    const entry = JSON.stringify({ at: new Date().toISOString(), gate, status, ...(ms >= 0 ? { ms } : {}) })
     fs.mkdirSync(path.dirname(file), { recursive: true })
     fs.writeFileSync(file, `${[...previous, entry].slice(-MAX_RUNS).join('\n')}\n`)
   } catch { /* el registro es evidencia, no una puerta */ }

package/engine/hooks/shell.js

@@ -31,6 +31,13 @@ const EV = require('../core/evidence')
 const ANTES = String.raw`(?:^|[\s;&|('"\`])`
 const PALABRA = String.raw`$|[\s;&|)'"\`]`
 const COMANDO = String.raw`$|[;&|)'"\`]`
+// Lo que puede haber **entre** un comando y su bandera sin salir de ese comando. El salto de línea va
+// adentro de lo excluido porque también separa comandos, exactamente igual que `;`, `&` y `|`: sin él,
+// una bandera escrita en una línea posterior se leía como parte del primer comando. Es la causa de los
+// falsos positivos del caso 067, en siete reglas a la vez — `git push origin main` seguido de
+// `rm -f /tmp/x` se bloqueaba anunciando «`git push --force` reescribe historia publicada», que además
+// de frenar trabajo legítimo nombraba una violación que no estaba.
+const MISMO = String.raw`[^;&|\n]`
 
 // Un mensaje de commit es dato, no código. `git commit -m "fix: bloquear git push --force"` disparaba
 // el guard de publicación, y lo mismo `rm -rf /` nombrado en una explicación; con el heredoc que se usa
@@ -62,7 +69,8 @@ function destructive(input) {
   // matchea igual las dos formas, así que `allowPush` habilitaba el force-push sin que nadie lo decidiera
   // y el párrafo de autonomía de `AGENTS.md` tenía que confesarlo. R8 prohíbe `force` sin excepción
   // configurable, así que esta rama va antes del permiso y no lo consulta.
-  if (/\bgit\s+push\b[^;&|]*\s(?:-f|--force(?:-with-lease|-if-includes)?)\b/.test(command)) {
+  if (new RegExp(String.raw`\bgit\s+push\b${MISMO}*\s(?:-f|--force(?:-with-lease|-if-includes)?)\b`)
+    .test(command)) {
     block("'git push --force' reescribe historia ya publicada. R8 lo prohíbe y runner.allowPush no lo "
       + 'habilita: publicá con un push normal, o registrá una acción humana.')
   }
@@ -75,7 +83,7 @@ function destructive(input) {
     // no devolvía una línea. Se bloquea por política y no por daño —un `--amend` sobre algo que nadie vio
     // no rompe nada—, así que el mensaje manda a lo que sí corresponde: otro commit.
     [
-      /\bgit\s+commit\b[^;&|]*\s--amend\b/,
+      new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s--amend\b`),
       "'git commit --amend' reescribe un commit ya creado. R8 pide uno nuevo en su lugar.",
     ],
     [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento."],
@@ -89,7 +97,7 @@ function destructive(input) {
     [
       // `git restore .` no lleva `--` y destruye igual: comprobado en `git restore --help` (git 2.43.0),
       // que restaura el working tree por defecto y toma el pathspec sin separador.
-      new RegExp(String.raw`\bgit\s+(?:checkout|restore)\s+(?:[^;&|]*?\s)?`
+      new RegExp(String.raw`\bgit\s+(?:checkout|restore)\s+(?:${MISMO}*?\s)?`
         + String.raw`(?:--(?=\s*(?:${COMANDO}))|(?:--\s+)?(?:\.|\*|:\/)(?=\s*(?:${COMANDO})))`),
       "'git checkout -- .' revierte todo lo no commiteado del directorio, no sólo lo que estás mirando. "
       + 'Nombrá el archivo, o commiteá lo que quieras conservar antes.',
@@ -104,7 +112,7 @@ function destructive(input) {
     ],
     [
       new RegExp(ANTES + String.raw`(?:mkfs\S*|shred)\s`
-        + String.raw`|\bdd\s+[^;&|]*\bof=\/dev\/|>\s*\/dev\/(?:sd|nvme|disk)`),
+        + String.raw`|\bdd\s+${MISMO}*\bof=\/dev\/|>\s*\/dev\/(?:sd|nvme|disk)`),
       'Operación destructiva sobre disco o dispositivo.',
     ],
     [
@@ -124,14 +132,14 @@ function gitAdd(input) {
   // Dónde termina la palabra lo decide PALABRA y no un espacio: `bash -c "git add -A"` y
   // `eval 'git add -A'` pasaban porque después de la bandera venía una comilla. Es el hueco que 028
   // cerró en las reglas de `destructive`, y esta regla se quedó afuera de aquel arreglo.
-  if (new RegExp(String.raw`\bgit\s+add\s+(?:[^;&|]*\s)?(?:-A|--all|\.)(?=${PALABRA})`)
+  if (new RegExp(String.raw`\bgit\s+add\s+(?:${MISMO}*\s)?(?:-A|--all|\.)(?=${PALABRA})`)
     .test(command)) {
     block("'git add -A/--all/.' está prohibido. Stagea rutas explícitas.")
   }
   // La misma regla con otra ortografía: `-a` stagea todo lo seguido sin nombrar una ruta, y encima lo
   // hace al commitear —después de este hook—, así que los guards que leen el índice tampoco lo ven.
   // `--amend` queda afuera: empieza con dos guiones y lo frena `destructive`, por otra razón.
-  if (/\bgit\s+commit\b[^;&|]*\s(?:-[a-z]*a[a-z]*|--all)\b/.test(command)) {
+  if (new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s(?:-[a-z]*a[a-z]*|--all)\b`).test(command)) {
     block("'git commit -a' stagea al commitear, después de este guard: nadie llega a revisar el diff "
       + 'staged, ni vos ni los guards que lo miran. Stageá las rutas por nombre y commiteá aparte.')
   }
@@ -141,7 +149,8 @@ function dependencies(input) {
   if (process.env.OPS_DEPENDENCIES_OVERRIDE === '1') return
   const command = commandOf(input)
   const unsafePackageCommand = /\b(?:npm|pnpm|yarn|bun)\s+publish\b/.test(command)
-    || /\b(?:npm|pnpm|yarn)\s+(?:install|add)\b[^;&|]*(?:\s-g\b|\s--global\b)/.test(command)
+    || new RegExp(String.raw`\b(?:npm|pnpm|yarn)\s+(?:install|add)\b${MISMO}*(?:\s-g\b|\s--global\b)`)
+      .test(command)
   if (unsafePackageCommand) {
     block('Publicar paquetes o instalar dependencias globales requiere una acción humana explícita.')
   }
@@ -346,14 +355,22 @@ function governance(input) {
 function run(program, args, cwd, extra = {}) {
   const env = { ...process.env, ...extra }
   delete env.NODE_TEST_CONTEXT
+  const started = Date.now()
   const result = spawnSync(program, args, { cwd, encoding: 'utf8', stdio: 'pipe', env })
   return {
     ok: result.status === 0,
     status: result.status,
+    ms: Date.now() - started,
     output: `${result.stdout || ''}${result.stderr || ''}`.trim(),
   }
 }
 
+// Salidas de build y cachés que cualquier gate rehace solo. Se comparan contra el nombre entero de la
+// entrada para que valga también anidado —`packages/app/dist`—, y con el separador de `git status`, que
+// siempre usa `/`.
+const RECREABLE = new RegExp('(^|/)(?:dist|build|out|coverage|__pycache__'
+  + '|\\.next|\\.nuxt|\\.svelte-kit|\\.turbo|\\.output|\\.parcel-cache|\\.pytest_cache)$')
+
 // Dónde tiene que correr un gate: sobre lo que el commit va a grabar, que es el índice y no el árbol.
 // El árbol se le parece casi siempre y por eso el error no se veía — puede tener encima otra versión de
 // un archivo staged, y puede tener uno sin trackear que el commit no lleva, que es el olvido de
@@ -390,6 +407,19 @@ function commitTree(dir) {
   for (const line of lines) {
     if (!line.startsWith('!! ')) continue
     const name = line.slice(3).trim().replace(/\/$/, '')
+    // Lo que el gate puede fabricar no se le enlaza: lo construye adentro de la copia y se descarta con
+    // ella. Enlazarlo hacía dos daños a la vez. Uno es del usuario: el gate corre sobre el índice, así
+    // que le dejaba la salida de build con la versión **staged** mientras su fuente en disco tenía otra,
+    // y nada lo decía —medido con un `dist/` que pasó de «lo-que-estoy-editando» a «staged» (caso 069)—.
+    // El otro es del propio gate: construía sobre restos de la corrida anterior del usuario, así que su
+    // veredicto dependía de un estado que nadie declaró.
+    //
+    // La lista envejece y eso pesa menos de lo que parece, porque sólo se aplica a rutas que git ya
+    // marcó como ignoradas: un `dist/` ignorado es generado por definición. Errarle por defecto —que
+    // falte un nombre— deja el comportamiento de antes; errarle por exceso hace que un gate reconstruya,
+    // que es más lento y no incorrecto. Lo que **sí** se enlaza es lo que un gate no puede fabricar:
+    // `node_modules`, un `.env`, las credenciales de una herramienta.
+    if (RECREABLE.test(name)) continue
     const link = path.join(temp, name)
     if (fs.existsSync(link)) continue
     fs.mkdirSync(path.dirname(link), { recursive: true })
@@ -412,7 +442,17 @@ function commitTree(dir) {
   // quien commitea; un proyecto con un gate así tiene que sacar esa escritura del gate.
   const started = run('git', ['init', '--quiet'], temp)
   if (started.ok) run('git', ['add', '--all'], temp)
-  return { root: temp, temp, env: {} }
+  // Un gate no sólo lee su entorno: escribe en él. Lo ignorado se enlaza al original —eso es a
+  // propósito y está arriba—, así que lo que el gate escriba cae en el árbol de quien commitea. Un
+  // gestor de paquetes que se sincroniza antes de correr un script lo lleva al extremo: pnpm 11 ve que
+  // el árbol enlazado no fue instalado acá y su reacción es reinstalar, que empieza borrando el
+  // `node_modules` **del proyecto**. Lo único que hoy lo detiene es que `run` lanza con `stdio: 'pipe'`
+  // y el hijo no ve una terminal (caso 068).
+  //
+  // `CI` es la variable que el propio pnpm nombra para no preguntar, y la que cualquier gate razonable
+  // ya espera. Va sólo acá: por el `return` de arriba los gates corren en el directorio del usuario, y
+  // ahí cambiarle el entorno no tiene ninguna razón.
+  return { root: temp, temp, env: { CI: 'true' } }
 }
 
 function verify(input) {
@@ -453,6 +493,41 @@ function verify(input) {
 // Cada gate deja su rastro en `ops`; para qué sirve ese registro lo dice `core/evidence.js`. Lo que se
 // decide acá es que el rojo se anota igual que el verde: un gate que falló y se commiteó con
 // aprobación es exactamente lo que alguien va a querer ver después.
+// Lo que se sabe de un gate que falló, en la forma en que se va a leer. El mensaje decía sólo
+// `test (exit 1)` y tiraba la salida de la herramienta: cualquier causa —una suite en rojo, un gestor
+// que se negó a arrancar el script, un binario que no está— llegaba con el mismo texto. Es la misma
+// forma de fallar que el caso 066 encontró en una prueba, acá en el mensaje que lee una persona.
+//
+// Se muestra **una** línea y acotada: la salida de un gate puede traer cualquier cosa del entorno, y lo
+// que hace falta para diagnosticar es la primera línea de error, no el volcado.
+const ERROR_LINE = /error|err[_!]|fail|abort|not found|cannot|no such/i
+const MAX_LINE = 160
+function fallo(gate, result) {
+  // La línea que empieza con `>` es el eco del script que npm y pnpm imprimen antes de correrlo, así
+  // que lleva el comando entero y no dice nada de qué falló. Descartarla es lo que hace que la primera
+  // coincidencia sea el error y no el comando — con el eco adentro, un script que **menciona** una
+  // palabra de error gana siempre.
+  const lines = (result.output || '').split('\n').map((one) => one.trim())
+    .filter((one) => one && !one.startsWith('>'))
+  const line = lines.find((one) => ERROR_LINE.test(one)) || lines[0] || ''
+  return { gate, status: result.status, ms: result.ms, line: line.slice(0, MAX_LINE) }
+}
+
+// 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
+    .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 `
+    + 'una suite, así que mirá si llegaron a ejecutarse antes de aprobar esto como un rojo conocido.'
+}
+
 function verifyGates(root, dir, aprobado, env, ops) {
   const failures = []
   if (fs.existsSync(path.join(root, 'package.json'))) {
@@ -463,28 +538,28 @@ function verifyGates(root, dir, aprobado, env, ops) {
     for (const script of ['test', 'lint', 'typecheck', 'build']) {
       if (!pkg.scripts || !pkg.scripts[script]) continue
       const result = run(pm, ['run', script], root, env)
-      EV.record(ops, script, result.status)
-      if (!result.ok) failures.push(`${script} (exit ${result.status})`)
+      EV.record(ops, script, result.status, result.ms)
+      if (!result.ok) failures.push(fallo(script, result))
     }
   } else if (fs.existsSync(path.join(root, 'go.mod'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^ci:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['ci'], root, env)
-      EV.record(ops, 'make ci', result.status)
-      if (!result.ok) failures.push(`make ci (exit ${result.status})`)
+      EV.record(ops, 'make ci', result.status, result.ms)
+      if (!result.ok) failures.push(fallo('make ci', result))
     } else {
       for (const args of [['test', './...'], ['build', './...']]) {
         const result = run('go', args, root, env)
-        EV.record(ops, `go ${args[0]}`, result.status)
-        if (!result.ok) failures.push(`go ${args[0]} (exit ${result.status})`)
+        EV.record(ops, `go ${args[0]}`, result.status, result.ms)
+        if (!result.ok) failures.push(fallo(`go ${args[0]}`, result))
       }
     }
   } else if (fs.existsSync(path.join(root, 'pyproject.toml')) || fs.existsSync(path.join(root, 'requirements.txt'))) {
     const makefile = path.join(root, 'Makefile')
     if (fs.existsSync(makefile) && /^test:/m.test(fs.readFileSync(makefile, 'utf8'))) {
       const result = run('make', ['test'], root, env)
-      EV.record(ops, 'make test', result.status)
-      if (!result.ok) failures.push(`make test (exit ${result.status})`)
+      EV.record(ops, 'make test', result.status, result.ms)
+      if (!result.ok) failures.push(fallo('make test', result))
     }
   }
   if (!failures.length || aprobado) return
@@ -492,7 +567,7 @@ function verifyGates(root, dir, aprobado, env, ops) {
   // 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)}: ${failures.join(', ')}. No se commitea en rojo.${donde}\n`
+  block(`Verify falló en ${path.basename(dir)}: ${comoSeLee(failures)}\nNo se commitea en rojo.${donde}\n`
     + AP.HOW('OPS_SKIP_VERIFY'))
 }
 

package/package.json

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