@ingeniomaps/cauce 0.43.0 → 0.47.0

package/engine/automation/index.js

@@ -69,7 +69,7 @@ function mergeConfig(current, incoming) {
 // el merge deje exactamente las de esta versión, ni una más.
 const ENTREGADO = /automatization\/hooks\/guard-[a-z-]+\.sh/
 
-function withoutDeliveredHooks(config, vigentes) {
+function withoutDeliveredHooks(config, live) {
   const dropped = []
   const walk = (node) => {
     if (Array.isArray(node)) {
@@ -79,7 +79,7 @@ function withoutDeliveredHooks(config, vigentes) {
           if (!ENTREGADO.test(command)) return true
           // Sólo se anuncia lo que ya no vuelve: una entrada que el merge repone quedó igual, y decir
           // que se quitó y se puso la misma línea es ruido que esconde el caso que sí importa.
-          if (!vigentes.has(command)) dropped.push(command)
+          if (!live.has(command)) dropped.push(command)
           return false
         })
         .map(walk)
@@ -97,20 +97,20 @@ function withoutDeliveredHooks(config, vigentes) {
 // ruta que dejó de existir: el primero se ejecutaba dos veces por herramienta —con `verify`, la suite
 // entera del proyecto dos veces por commit—, y el segundo no se ejecutaba nunca. Decirlo distinto es lo
 // único que le permite a alguien darse cuenta de cuál de los dos tenía.
-function reportarQuitadas(name, dropped, vigentes, output) {
+function reportRemoved(name, dropped, live, output) {
   const wrappers = new Map()
-  const sueltas = []
+  const loose = []
   for (const command of dropped) {
     const hit = supersededGuards().find(
-      (entry) => command.endsWith(entry.file) && [...vigentes].some((v) => v.endsWith(entry.wrapper)),
+      (entry) => command.endsWith(entry.file) && [...live].some((v) => v.endsWith(entry.wrapper)),
     )
     if (hit) wrappers.set(hit.wrapper, [...(wrappers.get(hit.wrapper) || []), hit.file])
-    else sueltas.push(command)
+    else loose.push(command)
   }
   for (const [wrapper, files] of wrappers) {
     output.log(`− ${name}: reemplazado ${[...new Set(files)].join(', ')} por ${wrapper}`)
   }
-  for (const command of sueltas) output.log(`− ${name}: quitada una entrada obsoleta (${command})`)
+  for (const command of loose) output.log(`− ${name}: quitada una entrada obsoleta (${command})`)
 }
 
 function includesConfig(actual, expected) {
@@ -246,7 +246,7 @@ description: ${role.description}
 # ${role.slug}
 
 Leé \`${role.reference}/SKILL.md\` para el contrato completo del cargo: cuándo actuar,
-qué decide, qué no le corresponde y cuál es su entrega mínima. Sus métodos y formatos de salida están
+qué decide, qué no le corresponde y cuál es su entrega mínima. Sus métodos y formatos de output están
 en \`${role.reference}/references/\`.
 
 Esas rutas se resuelven desde este directorio raíz, no desde el repositorio de operaciones: en modo
@@ -264,13 +264,13 @@ function installRoleSkills(root, runner, output) {
   const roles = roleCatalog(root)
   // Los cargos y los recorridos comparten el espacio de nombres de skills del runner, así que un cargo
   // que se llame como un recorrido lo pisa. Hoy no pasa, y por eso mismo hay que detenerlo acá: el
-  // catálogo de una empresa es suyo, nadie le prohíbe un cargo `team`, y el daño sería que `/cauce:team`
+  // catálogo de una empresa es suyo, nadie le prohíbe un cargo `flow`, y el daño sería que `/cauce:flow`
   // deje de existir sin que nada falle. Renombrar el cargo es la salida, y sólo la puede tomar alguien.
-  const recorridos = new Set((runner.commands && runner.commands.names) || [])
-  const chocan = roles.filter((role) => recorridos.has(role.slug)).map((role) => role.slug)
-  if (chocan.length) {
+  const commandNames = new Set((runner.commands && runner.commands.names) || [])
+  const collide = roles.filter((role) => commandNames.has(role.slug)).map((role) => role.slug)
+  if (collide.length) {
     throw new Error(
-      `${runner.name}: ${chocan.join(', ')} es a la vez un cargo y un recorrido, y comparten `
+      `${runner.name}: ${collide.join(', ')} es a la vez un cargo y un recorrido, y comparten `
       + `${runner.roleSkills}. Renombrá el cargo en agents/roles/ antes de instalar.`,
     )
   }
@@ -349,7 +349,7 @@ function check(root) {
   }
   const workflows = [
     'autobuild.js',
-    'team.js',
+    'flow.js',
     path.join('integrations', 'sync.js'),
     path.join('integrations', 'promote.js'),
   ]
@@ -366,11 +366,11 @@ function check(root) {
       : `automatization/hooks/${file}: quedó atrás del paquete y ya no protege lo que dice; `
         + 'corré `cauce upgrade` antes de instalar el runner')
   }
-  for (const name of RUNNER_NAMES) validateRunner(root, name, errors)
+  for (const name of RUNNER_NAMES) validateRunnerManifest(root, name, errors)
   return errors
 }
 
-function validateRunner(root, name, errors) {
+function validateRunnerManifest(root, name, errors) {
   try {
     const runner = runnerManifest(root, name)
     if (runner.name !== name || runner.schemaVersion !== 1
@@ -445,35 +445,35 @@ function probeBridge(paths, runner) {
   if (!fs.existsSync(script)) return []
   let config = {}
   try { config = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8')) } catch { return [] }
-  const eventos = [...new Set(
+  const hookEvents = [...new Set(
     JSON.stringify(config).match(/hook\.js ([a-z-]+)/g) || [],
   )].map((entrada) => entrada.split(' ')[1])
-  if (!eventos.length) return []
+  if (!hookEvents.length) return []
 
-  const problemas = []
+  const problems = []
   // Desde la raíz y desde una carpeta de adentro: si el runner lanza el hook con otro cwd, la ruta
   // relativa de su configuración deja de resolver y eso hay que verlo acá, no en la primera sesión.
-  const desde = [paths.install, path.dirname(script)]
-  for (const evento of eventos) {
-    for (const cwd of desde) {
+  const sourceRoot = [paths.install, path.dirname(script)]
+  for (const event of hookEvents) {
+    for (const cwd of sourceRoot) {
       const payload = JSON.stringify({ toolCall: { args: { CommandLine: 'ls', Cwd: paths.install } } })
-      const result = spawnSync(process.execPath, [script, evento], { cwd, input: payload, encoding: 'utf8' })
-      let respuesta = {}
-      try { respuesta = JSON.parse((result.stdout || '').trim()) } catch { respuesta = {} }
+      const result = spawnSync(process.execPath, [script, event], { cwd, input: payload, encoding: 'utf8' })
+      let response = {}
+      try { response = JSON.parse((result.stdout || '').trim()) } catch { response = {} }
       // Cada evento tiene su respuesta sana: `stop` cierra la sesión —eso es funcionar— y el resto deja
       // pasar. El puente falla cerrado, así que `deny` en una llamada inocua es que algo se rompió antes
       // de poder juzgarla, y `continue` es el camino de error del propio `stop`.
       // Y sin `reason`: el puente sólo la manda cuando algo falló, así que un `stop` que la trae es
       // una falla de infraestructura que se dejó cerrar la sesión, no un arranque sano.
-      const sana = evento === 'stop' ? 'stop' : 'allow'
-      if (respuesta.decision === sana && !respuesta.reason) continue
-      const salida = (result.stderr || 'sin respuesta').trim().split('\n')[0]
-      const motivo = respuesta.reason
-        || (respuesta.decision ? `respondió ${respuesta.decision}` : salida)
-      problemas.push(`${bridge.target} ${evento} desde ${path.basename(cwd)}/: ${motivo}`)
+      const healthy = event === 'stop' ? 'stop' : 'allow'
+      if (response.decision === healthy && !response.reason) continue
+      const output = (result.stderr || 'sin respuesta').trim().split('\n')[0]
+      const reason = response.reason
+        || (response.decision ? `respondió ${response.decision}` : output)
+      problems.push(`${bridge.target} ${event} desde ${path.basename(cwd)}/: ${reason}`)
     }
   }
-  return problemas
+  return problems
 }
 
 function doctor(root, name, output = console) {
@@ -500,12 +500,12 @@ function doctor(root, name, output = console) {
     // El archivo compartido no se compara entero: alrededor del bloque vive el texto de la empresa, así
     // que su hash difiere siempre. Comparado como archivo, `doctor` avisaba cuando el bloque estaba bien
     // y callaba cuando alguien lo había borrado, que es exactamente al revés.
-    if (esArchivoCompartido(root, resolved.target)) {
-      const contenido = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
+    if (isSharedFile(root, resolved.target)) {
+      const content = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
       if (!fs.existsSync(resolved.target)) errors.push(`falta ${item.target}`)
-      else if (!fs.readFileSync(resolved.target, 'utf8').includes(bloqueInicio(name))) {
+      else if (!fs.readFileSync(resolved.target, 'utf8').includes(blockStart(name))) {
         errors.push(`${item.target}: no tiene las instrucciones de Cauce; reinstalá el adaptador`)
-      } else if (!bloqueAlDia(resolved.target, name, contenido)) {
+      } else if (!blockUpToDate(resolved.target, name, content)) {
         warnings.push(`${item.target}: su bloque de Cauce quedó viejo; reinstalá el adaptador`)
       }
       continue
@@ -513,9 +513,9 @@ function doctor(root, name, output = console) {
     // `AGENTS.md` es un nombre compartido entre herramientas y la instancia ya tiene el suyo: en
     // modo embedded el archivo del runner y el de la empresa son el mismo, y pedirle que se
     // referencie a sí mismo no significa nada.
-    const propio = path.basename(resolved.target) === 'AGENTS.md'
+    const ownFile = path.basename(resolved.target) === 'AGENTS.md'
     if (!fs.existsSync(resolved.target)) errors.push(`falta ${item.target}`)
-    else if (!propio && !fs.readFileSync(resolved.target, 'utf8').includes('AGENTS.md')) {
+    else if (!ownFile && !fs.readFileSync(resolved.target, 'utf8').includes('AGENTS.md')) {
       warnings.push(`${item.target}: no referencia AGENTS.md; verifica las reglas globales`)
     }
     if (deliveryState(M.readRunners(root), name, resolved, opsPrefix(root)) === 'desactualizado') {
@@ -527,11 +527,11 @@ function doctor(root, name, output = console) {
   const recorded = M.readRunners(root)
   for (const item of runner.artifacts || []) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
-    const situacion = deliveryState(recorded, name, resolved, opsPrefix(root))
-    if (situacion === 'nuevo') errors.push(`falta ${item.target}`)
-    else if (situacion === 'desactualizado') {
+    const status = deliveryState(recorded, name, resolved, opsPrefix(root))
+    if (status === 'nuevo') errors.push(`falta ${item.target}`)
+    else if (status === 'desactualizado') {
       warnings.push(`${item.target}: hay una versión más nueva en Cauce; reinstalá el adaptador`)
-    } else if (situacion === 'ajeno') {
+    } else if (status === 'ajeno') {
       warnings.push(`${item.target}: lo editaste y es del toolkit; `
         + 'agregá lo tuyo al lado o reinstalá con --force para volver a la versión de Cauce')
     }
@@ -554,7 +554,7 @@ function doctor(root, name, output = console) {
     }
   }
   // Un puente que no responde niega cada llamada del runner: es error, no advertencia.
-  for (const problema of probeBridge(paths, runner)) errors.push(problema)
+  for (const problem of probeBridge(paths, runner)) errors.push(problem)
 
   const executable = spawnSync(
     'sh',
@@ -588,8 +588,8 @@ function deliveryKey(name, target) {
 function deliveryState(recorded, name, resolved, prefix = '') {
   if (!fs.existsSync(resolved.target)) return 'nuevo'
   const current = M.digest(resolved.target)
-  const esperado = render(resolved.source, prefix, resolved.automationRoot, resolved.opsRoot)
-  if (current === M.digestText(esperado)) return 'al día'
+  const expectedItem = render(resolved.source, prefix, resolved.automationRoot, resolved.opsRoot)
+  if (current === M.digestText(expectedItem)) return 'al día'
   const delivered = recorded[deliveryKey(name, resolved.item.target)]
   return delivered && delivered === current ? 'desactualizado' : 'ajeno'
 }
@@ -600,21 +600,21 @@ function deliveryState(recorded, name, resolved, prefix = '') {
 function unmergeConfig(current, incoming) {
   if (Array.isArray(incoming)) {
     if (!Array.isArray(current)) return current
-    const nuestras = new Set(incoming.map((value) => JSON.stringify(value)))
-    return current.filter((value) => !nuestras.has(JSON.stringify(value)))
+    const ours = new Set(incoming.map((value) => JSON.stringify(value)))
+    return current.filter((value) => !ours.has(JSON.stringify(value)))
   }
   if (incoming && typeof incoming === 'object') {
     if (!current || typeof current !== 'object' || Array.isArray(current)) return current
     const result = { ...current }
     for (const [key, value] of Object.entries(incoming)) {
       if (!(key in result)) continue
-      const limpio = unmergeConfig(result[key], value)
+      const clean = unmergeConfig(result[key], value)
       // Una clave que queda vacía por habernos ido no es del usuario: la creamos nosotros al instalar.
-      const vacia = limpio === undefined
-        || (Array.isArray(limpio) && !limpio.length)
-        || (limpio && typeof limpio === 'object' && !Array.isArray(limpio) && !Object.keys(limpio).length)
-      if (vacia) delete result[key]
-      else result[key] = limpio
+      const empty = clean === undefined
+        || (Array.isArray(clean) && !clean.length)
+        || (clean && typeof clean === 'object' && !Array.isArray(clean) && !Object.keys(clean).length)
+      if (empty) delete result[key]
+      else result[key] = clean
     }
     return result
   }
@@ -649,30 +649,30 @@ function uninstall(root, name, output = console) {
   const paths = runnerPaths(root, name, runner)
   const prefix = opsPrefix(root)
   const recorded = M.readRunners(root)
-  const conservados = []
-  let quitados = 0
+  const kept = []
+  let removed = 0
 
   const items = [...(runner.instructions || []), ...(runner.artifacts || [])]
-  const entregado = { ...recorded }
+  const deliveredPaths = { ...recorded }
   for (const item of items) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
     const key = deliveryKey(name, item.target)
-    if (!fs.existsSync(resolved.target)) { delete entregado[key]; continue }
-    if (esArchivoCompartido(root, resolved.target)) {
-      const texto = fs.readFileSync(resolved.target, 'utf8')
-      const limpio = sinBloque(texto, name)
-      if (limpio !== texto.trimEnd()) {
-        F.atomicWrite(resolved.target, `${limpio}\n`)
-        quitados += 1
+    if (!fs.existsSync(resolved.target)) { delete deliveredPaths[key]; continue }
+    if (isSharedFile(root, resolved.target)) {
+      const body = fs.readFileSync(resolved.target, 'utf8')
+      const clean = withoutBlock(body, name)
+      if (clean !== body.trimEnd()) {
+        F.atomicWrite(resolved.target, `${clean}\n`)
+        removed += 1
       }
-      delete entregado[key]
+      delete deliveredPaths[key]
       continue
     }
-    const situacion = deliveryState(recorded, name, resolved, prefix)
-    if (situacion === 'ajeno') { conservados.push(item.target); continue }
+    const status = deliveryState(recorded, name, resolved, prefix)
+    if (status === 'ajeno') { kept.push(item.target); continue }
     removeFile(resolved.target, paths.install)
-    delete entregado[key]
-    quitados += 1
+    delete deliveredPaths[key]
+    removed += 1
   }
 
   // Los punteros a cargos no se registran uno por uno —son cuarenta y siete y se regeneran enteros—,
@@ -683,62 +683,62 @@ function uninstall(root, name, output = console) {
       const file = path.join(base, role.slug, 'SKILL.md')
       if (!fs.existsSync(file)) continue
       if (M.digest(file) !== M.digestText(roleSkill(role))) {
-        conservados.push(path.relative(paths.install, file))
+        kept.push(path.relative(paths.install, file))
         continue
       }
       removeFile(file, paths.install)
-      quitados += 1
+      removed += 1
     }
   }
 
   if (fs.existsSync(paths.configTarget)) {
     const current = JSON.parse(fs.readFileSync(paths.configTarget, 'utf8'))
-    const limpio = unmergeConfig(current, runnerConfig(paths, root))
-    if (limpio && Object.keys(limpio).length) F.atomicWriteJson(paths.configTarget, limpio)
-    else { removeFile(paths.configTarget, paths.install); quitados += 1 }
+    const clean = unmergeConfig(current, runnerConfig(paths, root))
+    if (clean && Object.keys(clean).length) F.atomicWriteJson(paths.configTarget, clean)
+    else { removeFile(paths.configTarget, paths.install); removed += 1 }
     output.log(`✓ ${name}: ${runner.config.target} sin las entradas de Cauce`)
   }
 
-  M.write(root, undefined, entregado)
-  output.log(`✓ ${name}: ${quitados} archivo(s) del toolkit quitados de ${paths.install}`)
-  for (const file of conservados) output.log(`= ${name}: conservado ${file} (tiene cambios tuyos)`)
+  M.write(root, undefined, deliveredPaths)
+  output.log(`✓ ${name}: ${removed} archivo(s) del toolkit quitados de ${paths.install}`)
+  for (const file of kept) output.log(`= ${name}: conservado ${file} (tiene cambios tuyos)`)
   if (runner.activation) output.log(`  ${name}: si lo habías registrado a mano, quitalo también.`)
-  return { removed: quitados, kept: conservados }
+  return { removed: removed, kept: kept }
 }
 
 // `AGENTS.md` es el único nombre que el runner y la instancia comparten: en modo embebido el archivo de
 // instrucciones de Codex es el mismo que el de la empresa. Conservarlo entero —lo correcto para un
 // archivo del proyecto— dejaba a ese runner sin una sola línea de Cauce, así que su contenido se
 // fusiona adentro, entre marcas, y todo lo demás del archivo queda intacto.
-const bloqueInicio = (name) => `<!-- cauce:${name} inicio — lo reescribe "automation install", no editar -->`
-const bloqueFin = (name) => `<!-- cauce:${name} fin -->`
+const blockStart = (name) => `<!-- cauce:${name} inicio — lo reescribe "automation install", no editar -->`
+const blockEnd = (name) => `<!-- cauce:${name} fin -->`
 
-function esArchivoCompartido(root, target) {
+function isSharedFile(root, target) {
   return path.resolve(target) === path.resolve(root, 'AGENTS.md')
 }
 
-function sinBloque(text, name) {
-  const desde = text.indexOf(bloqueInicio(name))
-  if (desde === -1) return text
-  const hasta = text.indexOf(bloqueFin(name), desde)
-  if (hasta === -1) return text
-  return `${text.slice(0, desde)}${text.slice(hasta + bloqueFin(name).length)}`.trimEnd()
+function withoutBlock(text, name) {
+  const sourceRoot = text.indexOf(blockStart(name))
+  if (sourceRoot === -1) return text
+  const until = text.indexOf(blockEnd(name), sourceRoot)
+  if (until === -1) return text
+  return `${text.slice(0, sourceRoot)}${text.slice(until + blockEnd(name).length)}`.trimEnd()
 }
 
-function fusionarInstruccion(file, name, contenido) {
+function mergeInstruction(file, name, content) {
   const actual = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
-  const cuerpo = sinBloque(actual, name).trimEnd()
-  const bloque = `${bloqueInicio(name)}\n\n${contenido.trim()}\n\n${bloqueFin(name)}\n`
-  F.atomicWrite(file, cuerpo ? `${cuerpo}\n\n${bloque}` : bloque)
+  const instructionBody = withoutBlock(actual, name).trimEnd()
+  const block = `${blockStart(name)}\n\n${content.trim()}\n\n${blockEnd(name)}\n`
+  F.atomicWrite(file, instructionBody ? `${instructionBody}\n\n${block}` : block)
 }
 
-function bloqueAlDia(file, name, contenido) {
+function blockUpToDate(file, name, content) {
   if (!fs.existsSync(file)) return false
-  const texto = fs.readFileSync(file, 'utf8')
-  const desde = texto.indexOf(bloqueInicio(name))
-  const hasta = texto.indexOf(bloqueFin(name))
-  if (desde === -1 || hasta === -1) return false
-  return texto.slice(desde + bloqueInicio(name).length, hasta).trim() === contenido.trim()
+  const body = fs.readFileSync(file, 'utf8')
+  const sourceRoot = body.indexOf(blockStart(name))
+  const until = body.indexOf(blockEnd(name))
+  if (sourceRoot === -1 || until === -1) return false
+  return body.slice(sourceRoot + blockStart(name).length, until).trim() === content.trim()
 }
 
 function install(root, name, output = console, options = {}) {
@@ -769,13 +769,13 @@ function install(root, name, output = console, options = {}) {
   const state = new Map(resolvedItems.map((r) => [r, deliveryState(recorded, name, r, prefix)]))
   // Un archivo de instrucciones es del proyecto y se conserva; uno ejecutable es del toolkit y se
   // reemplaza. Editarlo detiene la instalación antes de pisarlo, igual que hace `upgrade`.
-  const editados = resolvedItems.filter((resolved) => {
+  const edited = resolvedItems.filter((resolved) => {
     return state.get(resolved) === 'ajeno' && !runner.instructions.includes(resolved.item)
   })
-  if (editados.length && !options.force) {
+  if (edited.length && !options.force) {
     throw new Error(
-      `${editados.length} archivo(s) que mantiene Cauce fueron editados y se perderían:\n`
-      + `${editados.map((resolved) => `- ${resolved.item.target}`).join('\n')}\n\n`
+      `${edited.length} archivo(s) que mantiene Cauce fueron editados y se perderían:\n`
+      + `${edited.map((resolved) => `- ${resolved.item.target}`).join('\n')}\n\n`
       + 'Son del toolkit: en vez de editarlos, agregá lo tuyo al lado y registralo en la\n'
       + 'configuración de tu runner. Si el cambio ya no te sirve, repetí con --force.',
     )
@@ -784,64 +784,64 @@ function install(root, name, output = console, options = {}) {
   // Gemini son del usuario, así que ahí se fusiona; pero fusionar conserva también lo que pusimos en
   // una versión anterior, y una entrada nuestra que quedó viva apuntando a donde ya no hay nada es un
   // guard que el runner intenta ejecutar y falla. Se quitan las nuestras y las vuelve a poner el merge.
-  const vigentes = new Set((JSON.stringify(incoming).match(/"command":"[^"]*"/g) || [])
+  const live = new Set((JSON.stringify(incoming).match(/"command":"[^"]*"/g) || [])
     .map((entry) => JSON.parse(`{${entry}}`).command))
-  const limpio = runner.config.owned ? { config: {}, dropped: [] } : withoutDeliveredHooks(current, vigentes)
-  reportarQuitadas(name, limpio.dropped, vigentes, output)
-  F.atomicWriteJson(paths.configTarget, mergeConfig(limpio.config, incoming))
+  const clean = runner.config.owned ? { config: {}, dropped: [] } : withoutDeliveredHooks(current, live)
+  reportRemoved(name, clean.dropped, live, output)
+  F.atomicWriteJson(paths.configTarget, mergeConfig(clean.config, incoming))
   // Dónde aterrizó, no sólo qué archivo: en sidecar el destino no es el repo desde el que se corrió
   // el comando, y descubrirlo por sorpresa es la diferencia entre confiar y adivinar.
   if (paths.install !== root) {
     output.log(`  ${name}: el runner se abre en ${paths.install} — ahí queda su configuración`)
   }
   output.log(`✓ ${name}: configuración instalada en ${runner.config.target}`)
-  const entregado = { ...recorded }
+  const deliveredPaths = { ...recorded }
   for (const resolved of resolvedItems) {
-    const situacion = state.get(resolved)
-    const propio = runner.instructions.includes(resolved.item)
-    if (propio && esArchivoCompartido(root, resolved.target)) {
-      const contenido = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
-      if (bloqueAlDia(resolved.target, name, contenido)) {
+    const status = state.get(resolved)
+    const ownFile = runner.instructions.includes(resolved.item)
+    if (ownFile && isSharedFile(root, resolved.target)) {
+      const content = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
+      if (blockUpToDate(resolved.target, name, content)) {
         output.log(`= ${name}: ${resolved.item.target} ya trae sus instrucciones`)
       } else {
-        fusionarInstruccion(resolved.target, name, contenido)
+        mergeInstruction(resolved.target, name, content)
         output.log(`✓ ${name}: sus instrucciones quedaron dentro de ${resolved.item.target}`)
       }
-      entregado[deliveryKey(name, resolved.item.target)] = M.digest(resolved.target)
+      deliveredPaths[deliveryKey(name, resolved.item.target)] = M.digest(resolved.target)
       continue
     }
-    if (situacion === 'ajeno' && propio) {
+    if (status === 'ajeno' && ownFile) {
       output.log(`= ${name}: conservado ${resolved.item.target} (tiene cambios tuyos)`)
-    } else if (situacion === 'al día') {
+    } else if (status === 'al día') {
       output.log(`= ${name}: ${resolved.item.target} ya está al día`)
     } else {
       fs.mkdirSync(path.dirname(resolved.target), { recursive: true })
-      const escrito = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
-      F.atomicWrite(resolved.target, escrito)
-      const verbo = situacion === 'nuevo' ? 'instalado' : 'actualizado'
-      output.log(`✓ ${name}: ${verbo} ${resolved.item.target}`)
+      const written = render(resolved.source, opsPrefix(root), resolved.automationRoot, resolved.opsRoot)
+      F.atomicWrite(resolved.target, written)
+      const verb = status === 'nuevo' ? 'instalado' : 'actualizado'
+      output.log(`✓ ${name}: ${verb} ${resolved.item.target}`)
     }
     // Sólo se anota lo que Cauce puso: un archivo conservado con cambios de la empresa no es una
     // entrega, y registrarlo lo volvería indistinguible de uno intacto en la próxima instalación.
-    if (!(situacion === 'ajeno' && propio)) {
-      entregado[deliveryKey(name, resolved.item.target)] = M.digest(resolved.target)
+    if (!(status === 'ajeno' && ownFile)) {
+      deliveredPaths[deliveryKey(name, resolved.item.target)] = M.digest(resolved.target)
     }
   }
   installRoleSkills(root, runner, output)
-  // Cómo se lo llama acá. El nombre del recorrido es el mismo en todos los runners —`onboard`, `team`,
+  // Cómo se lo llama acá. El nombre del recorrido es el mismo en todos los runners —`onboard`, `flow`,
   // `autobuild`—; el prefijo lo pone cada uno según su espacio de nombres, y esa diferencia es la que
   // hace que alguien no encuentre en Gemini lo que usó en Claude. Decirlo al instalar cuesta una línea
   // y ahorra buscarlo en una lista de cincuenta skills.
-  const invocacion = runner.commands && runner.commands.invocation
-  if (invocacion && (runner.commands.names || []).length) {
-    const lista = runner.commands.names.map((nombre) => invocacion.replace('{name}', nombre))
-    output.log(`  ${name}: se invocan como ${lista.join(', ')}`)
+  const invocation = runner.commands && runner.commands.invocation
+  if (invocation && (runner.commands.names || []).length) {
+    const listing = runner.commands.names.map((nombre) => invocation.replace('{name}', nombre))
+    output.log(`  ${name}: se invocan como ${listing.join(', ')}`)
   }
   if (runner.activation && activated(runner) !== true) {
     output.log(`  ${name}: falta registrarlo para que corra. Desde ${paths.install}:`)
     output.log(`    ${runner.activation.hint}`)
   }
-  M.write(root, undefined, entregado)
+  M.write(root, undefined, deliveredPaths)
   return runner
 }
 

package/engine/cli/args.js

@@ -25,9 +25,9 @@ const FLAGS = {
   agents: ['--json', '--own', '--system'],
   integration: ['--fixture'],
   automation: ['--force'],
-  learn: ['--proposal', '--applied', '--period'],
-  evaluate: ['--cases', '--json', '--bench', '--force', '--record'],
-  team: ['--json'],
+  learn: ['--flow', '--proposal', '--applied', '--period'],
+  evaluate: ['--cases', '--json', '--bench', '--force', '--record', '--flow'],
+  flow: ['--json'],
 }
 
 // La línea de comandos, leída una sola vez. Antes cada función buscaba sus banderas en

package/engine/cli/bootstrap.js

@@ -8,12 +8,12 @@
 
 const readline = require('node:readline/promises')
 
-const SIN_RUNNER = 'ninguno'
-const SIN_PROVEEDOR = 'ninguna'
+const NO_RUNNER = 'ninguno'
+const NO_PROVIDER = 'ninguna'
 
 // Cuántas veces se repregunta antes de tomar el default. Insistir para siempre cuelga una corrida no
 // interactiva que igual llegó hasta acá; rendirse a la primera convierte un dedazo en una decisión.
-const INTENTOS = 3
+const ATTEMPTS = 3
 
 // Una terminal de verdad, aislada acá para que el resto del módulo no sepa que existe.
 function terminal() {
@@ -24,24 +24,24 @@ function terminal() {
 // Un Ctrl+D o un Ctrl+C en mitad de la pregunta valen como «no elijo»: readline rechaza la promesa, y
 // dejar que ese rechazo suba terminaba la corrida con «Aborted with Ctrl+D» y la instancia recién creada
 // sin una línea que dijera cómo seguir. El default no hace nada, así que tomarlo no decide nada.
-async function elegir(deps, texto, opciones, fallback) {
+async function choose(deps, texto, opciones, fallback) {
   // Una opción por línea y el default señalado donde se mira: apretar Enter es la respuesta más común, y
   // en una sola línea apretada el `[ninguno]` del final no se lee como «esto pasa si no elegís nada».
-  const listado = opciones
+  const options = opciones
     .map((opcion, indice) => `  ${indice + 1}) ${opcion}${opcion === fallback ? '   ← Enter' : ''}`)
     .join('\n')
-  for (let intento = 0; intento < INTENTOS; intento += 1) {
-    let dicho
-    try { dicho = await deps.ask(`\n${texto}\n\n${listado}\n\n> `) } catch {
+  for (let attempt = 0; attempt < ATTEMPTS; attempt += 1) {
+    let typed
+    try { typed = await deps.ask(`\n${texto}\n\n${options}\n\n> `) } catch {
       deps.log(`\n  sin respuesta: sigo con ${fallback}.`)
       return fallback
     }
-    const respuesta = dicho.trim()
-    if (!respuesta) return fallback
-    const numero = Number(respuesta)
-    if (Number.isInteger(numero) && numero >= 1 && numero <= opciones.length) return opciones[numero - 1]
-    if (opciones.includes(respuesta)) return respuesta
-    deps.log(`  «${respuesta}» no está en la lista.`)
+    const answer = typed.trim()
+    if (!answer) return fallback
+    const index = Number(answer)
+    if (Number.isInteger(index) && index >= 1 && index <= opciones.length) return opciones[index - 1]
+    if (opciones.includes(answer)) return answer
+    deps.log(`  «${answer}» no está en la lista.`)
   }
   return fallback
 }
@@ -52,32 +52,32 @@ async function elegir(deps, texto, opciones, fallback) {
 //
 // La terminal se abre acá y no en el CLI, y sólo si hay algo que preguntar: quien llama no tiene por
 // qué saber que readline existe, y una prueba reemplaza `deps.ask` sin que se abra ninguna.
-async function preguntas(opciones, deps) {
-  const falta = !opciones.runner || !opciones.integration
-  if (!opciones.interactive || !falta) {
-    return { runner: opciones.runner || SIN_RUNNER, proveedor: opciones.integration || SIN_PROVEEDOR }
+async function askMissing(opciones, deps) {
+  const missing = !opciones.runner || !opciones.integration
+  if (!opciones.interactive || !missing) {
+    return { runner: opciones.runner || NO_RUNNER, provider: opciones.integration || NO_PROVIDER }
   }
   const tty = deps.ask ? null : terminal()
-  const con = { ...deps, ask: deps.ask || tty.ask }
-  const runners = [...opciones.runners, SIN_RUNNER]
-  const proveedores = [...opciones.providers, SIN_PROVEEDOR]
+  const io = { ...deps, ask: deps.ask || tty.ask }
+  const runners = [...opciones.runners, NO_RUNNER]
+  const providers = [...opciones.providers, NO_PROVIDER]
   try {
     const runner = opciones.runner
-      || await elegir(con, '¿Con qué runner vas a trabajar?', runners, SIN_RUNNER)
-    const proveedor = opciones.integration
-      || await elegir(con, '¿Habilitar alguna integración?', proveedores, SIN_PROVEEDOR)
-    return { runner, proveedor }
+      || await choose(io, '¿Con qué runner vas a trabajar?', runners, NO_RUNNER)
+    const provider = opciones.integration
+      || await choose(io, '¿Habilitar alguna integración?', providers, NO_PROVIDER)
+    return { runner, provider }
   } finally { if (tty) tty.close() }
 }
 
-function validar(opciones) {
-  const runners = [...opciones.runners, SIN_RUNNER]
-  const proveedores = [...opciones.providers, SIN_PROVEEDOR]
+function validate(opciones) {
+  const runners = [...opciones.runners, NO_RUNNER]
+  const providers = [...opciones.providers, NO_PROVIDER]
   if (opciones.runner && !runners.includes(opciones.runner)) {
     throw new Error(`--runner debe ser ${runners.join(', ')}.`)
   }
-  if (opciones.integration && !proveedores.includes(opciones.integration)) {
-    throw new Error(`--integration debe ser ${proveedores.join(', ')}.`)
+  if (opciones.integration && !providers.includes(opciones.integration)) {
+    throw new Error(`--integration debe ser ${providers.join(', ')}.`)
   }
 }
 
@@ -85,16 +85,16 @@ function validar(opciones) {
 // habilita con el motor que corre `init` —su plantilla viaja en el paquete—, pero el runner necesita
 // la dependencia ya instalada, porque sus adaptadores y workflows se resuelven desde `node_modules`.
 async function run(root, opciones, deps) {
-  validar(opciones)
-  const { runner, proveedor } = await preguntas(opciones, deps)
-  if (proveedor !== SIN_PROVEEDOR) deps.enableProvider(proveedor)
-  if (!opciones.install) return { runner, proveedor, instalado: false, pendiente: 'npm install' }
+  validate(opciones)
+  const { runner, provider } = await askMissing(opciones, deps)
+  if (provider !== NO_PROVIDER) deps.enableProvider(provider)
+  if (!opciones.install) return { runner, provider, installed: false, pending: 'npm install' }
   deps.log('\n· npm install (el motor viene de la dependencia)')
   if (deps.npm(root) !== 0) {
-    return { runner, proveedor, instalado: false, error: 'npm install falló', pendiente: 'npm install' }
+    return { runner, provider, installed: false, error: 'npm install falló', pending: 'npm install' }
   }
-  if (runner !== SIN_RUNNER) deps.installRunner(runner)
-  return { runner, proveedor, instalado: true }
+  if (runner !== NO_RUNNER) deps.installRunner(runner)
+  return { runner, provider, installed: true }
 }
 
-module.exports = { run, SIN_RUNNER, SIN_PROVEEDOR }
+module.exports = { run, NO_RUNNER, NO_PROVIDER }