@ingeniomaps/cauce 0.22.0 → 0.24.0

package/engine/agents/fork.js

@@ -6,14 +6,9 @@
 // —que es lo que se ve— y deja atrás los casos adversariales, las fuentes de aprendizaje y el modelo
 // operativo. Queda un cargo que responde igual y ya no se puede evaluar, sin ningún aviso.
 //
-// **Qué no se hereda.** Los informes de aprendizaje, las propuestas y los veredictos de evaluación se
-// quedan en el catálogo. No es prolijidad: un veredicto pertenece al contrato que lo ganó, y el fork
-// nace para dejar de ser ese contrato. Heredarlos le daría a la copia una garantía que no rindió, y
-// una propuesta pendiente arrastraría a la empresa a firmar una decisión que era nuestra.
-//
-// Lo que sí se hereda entero es el contrato y todo lo que lo hace verificable: casos, conductas
-// esperadas, fuentes, automatización y referencias. La empresa recibe un cargo evaluable desde el
-// primer minuto, y a partir de ahí lo mantiene.
+// Se hereda el contrato entero y todo lo que lo hace verificable —casos, conductas esperadas,
+// fuentes, referencias—, así la empresa recibe un cargo evaluable desde el primer minuto. Qué queda
+// afuera y por qué, en `inherited()`.
 
 const fs = require('node:fs')
 const path = require('node:path')
@@ -22,13 +17,9 @@ const catalog = require('./catalog')
 const manifest = require('../core/manifest')
 const ownership = require('../core/ownership')
 
-// Se comparan contra la ruta relativa dentro del cargo. Informes, propuestas y veredictos no viajan:
-// son lo que produjo nuestra versión del contrato, y el fork nace para dejar de ser ese contrato.
-//
-// Antes se exceptuaba `_template.md`, por andamiaje. Ese andamiaje resultó ser muerto —el motor
-// genera el informe y la propuesta desde un molde propio y nunca lee esos archivos— y en un tercio
-// del catálogo contradecía la forma que sí produce, así que se retiró entero. No hay caso especial
-// que preservar.
+// Informes, propuestas y veredictos no viajan: son lo que produjo nuestra versión del contrato, y el
+// fork nace para dejar de ser ese contrato. Heredar un veredicto le daría a la copia una garantía que
+// no rindió; heredar una propuesta pendiente la haría firmar una decisión que era nuestra.
 function inherited(relative) {
   if (/^learning\/(reports|proposals)\//.test(relative)) return false
   if (relative.startsWith('evaluations/results/')) return false
@@ -37,8 +28,7 @@ function inherited(relative) {
 
 const TEXT = /\.(md|ya?ml|json|txt)$/i
 
-// El mismo recorrido que usa `upgrade` para comparar instancia contra paquete: un cargo es un árbol
-// de archivos como cualquier otro, y tener dos implementaciones sólo daba dos formas de ordenarlos.
+// El mismo recorrido que usa `upgrade`: un cargo es un árbol de archivos como cualquier otro.
 const tree = ownership.treeFiles
 
 // La misma resolución que usa todo lo demás —paquete primero, toolkit después— en vez de deducirla
@@ -66,12 +56,9 @@ function fork(root, slug, date) {
   // En el toolkit no hay a quién copiarle: el catálogo se mantiene acá, directo. Dejarlo pasar creaba
   // un duplicado en `agents/roles/` que tapaba al original, y el trabajo siguiente se hacía sobre la
   // copia mientras la versión que se publica quedaba quieta.
-  try {
-    const config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8'))
-    if (config.mode === 'toolkit') {
-      throw new Error(`${slug} vive acá: en el toolkit se edita el catálogo, no se lo copia`)
-    }
-  } catch (error) { if (error instanceof Error && error.message.includes('vive acá')) throw error }
+  if (ownership.mode(root) === 'toolkit') {
+    throw new Error(`${slug} vive acá: en el toolkit se edita el catálogo, no se lo copia`)
+  }
 
   const found = catalog.find(root, slug)
   if (!found.system) {
@@ -85,13 +72,10 @@ function fork(root, slug, date) {
   const files = todo.filter(inherited)
   if (!files.includes('SKILL.md')) throw new Error(`${slug} no tiene SKILL.md: no hay contrato que copiar`)
 
-  // El digest sale del origen, no de la copia. Es lo que el catálogo tenía al momento del fork, y es
-  // contra eso que después se responde «esto mejoró río arriba»; medirlo sobre la copia lo ataría a
-  // cualquier cosa que le hagamos acá —la reescritura de rutas incluida—.
-  //
-  // Y esa reescritura no es cosmética: el `AUTOMATION.md` del catálogo dice «mantené
-  // `agents/<tipo>/system/<slug>`», que en una empresa es el paquete. Copiado tal cual, el aprendizaje
-  // del fork apuntaría a un directorio que el guard bloquea y que npm borra en el próximo install.
+  // El digest sale del origen, no de la copia: es contra lo que el catálogo tenía al forkear que
+  // después se responde «esto mejoró río arriba». Medirlo sobre la copia lo ataría a nuestras propias
+  // ediciones, la reescritura de rutas incluida — y esa reescritura no es cosmética: sin ella el
+  // aprendizaje del fork apuntaría al paquete, que el guard bloquea y npm borra en el próximo install.
   const desde = `agents/${type}/system/${slug}`
   const hacia = `agents/${type}/${slug}`
   const digests = {}
@@ -116,12 +100,11 @@ function fork(root, slug, date) {
 
 // Qué cambió en el catálogo desde que la empresa se llevó su copia.
 //
-// El fork es legítimo y esperado —para eso está el comando—, pero deja de recibir las mejoras del
-// toolkit, y eso no puede pasar en silencio: la empresa decidió mantener un cargo, no quedarse sin
-// enterarse de que el original mejoró. Nadie va a comparar 14 archivos a mano en cada actualización.
+// El fork es legítimo, pero deja de recibir las mejoras del toolkit y eso no puede pasar en silencio:
+// la empresa decidió mantener un cargo, no quedarse sin enterarse de que el original mejoró.
 //
 // Se compara contra los digests guardados al forkear, nunca contra la copia: la copia está editada a
-// propósito, así que medir contra ella devolvería «todo cambió» desde el primer ajuste. Y el aviso no
+// propósito, así que medir contra ella devolvería «todo cambió» desde el primer ajuste. El aviso no
 // dice qué hacer —integrar o no es decisión de la empresa—, sólo que hay algo que mirar.
 function drift(root) {
   const forks = manifest.readForks(root)

package/engine/agents/learning.js

@@ -1,9 +1,7 @@
 'use strict'
 
-// Motor de aprendizaje controlado para los perfiles de agentes.
-
-const fs = require('fs')
-const path = require('path')
+const fs = require('node:fs')
+const path = require('node:path')
 const catalog = require('./catalog')
 
 const REQUIRED_SECTIONS = [
@@ -35,6 +33,42 @@ function assertWritable(root, agent) {
 function isoDate(now = new Date()) { return now.toISOString().slice(0, 10) }
 function month(now = new Date()) { return now.toISOString().slice(0, 7) }
 
+const PROPOSAL_NAME = /^\d{4}-\d{2}\.md$/
+
+// El tope de la línea de índice. No es estético: son 47 líneas que se leen de un vistazo, y una que
+// se envuelve rompe la columna que hace posible el vistazo.
+const SUMMARY_MAX = 120
+
+function proposalFiles(dir) {
+  try { return fs.readdirSync(dir).filter((name) => PROPOSAL_NAME.test(name)).sort() } catch { return [] }
+}
+
+function proposalState(text) {
+  return ((text.match(/^status:\s*(\S+)\s*$/m) || [])[1] || 'proposed').toLowerCase()
+}
+
+// El estado terminal del ciclo. Existía la firma, la aplicación y el historial, y faltaba justo el
+// paso que vuelve irrepetible lo ya hecho: `status:` nacía en `proposed` y nadie lo movía nunca.
+//
+// No era un dato desprolijo. `agent-promote` busca la propuesta más nueva y aplica si el estado dice
+// aprobada con responsable — y «aprobada y aplicada» cumple eso—, así que volver a correrlo sobre una
+// propuesta ya aplicada la aplicaba de nuevo. Como los cambios son aditivos por diseño, el resultado
+// no es un error visible sino un contrato con cada viñeta y cada fuente duplicadas.
+function seal(root, agent, period = '') {
+  const dir = path.join(assertWritable(root, agent), 'learning', 'proposals')
+  const names = proposalFiles(dir)
+  if (!names.length) throw new Error(`${agent} no tiene propuestas en learning/proposals/.`)
+  const name = period ? `${period}.md` : names[names.length - 1]
+  if (!names.includes(name)) throw new Error(`${agent} no tiene la propuesta ${name}.`)
+  const file = path.join(dir, name)
+  const text = fs.readFileSync(file, 'utf8')
+  const state = proposalState(text)
+  if (state === 'applied') return { file, already: true }
+  if (!/^status:\s*\S+\s*$/m.test(text)) throw new Error(`${file} no declara status en su frontmatter.`)
+  fs.writeFileSync(file, text.replace(/^status:\s*\S+\s*$/m, 'status: applied'))
+  return { file, already: false }
+}
+
 function prepareReport(root, agent, now = new Date()) {
   const reports = path.join(assertWritable(root, agent), 'learning', 'reports')
   const file = path.join(reports, `${isoDate(now)}.md`)
@@ -150,24 +184,32 @@ function evaluate(root, agent) {
   for (const phrase of ['no inventar', 'autorización', 'evidencia observable']) {
     if (!skill.includes(phrase)) errors.push(`SKILL.md no conserva el control: ${phrase}`)
   }
-  let proposals = []
-  try {
-    proposals = fs.readdirSync(path.join(target, 'learning', 'proposals'))
-      .filter((name) => /^\d{4}-\d{2}\.md$/.test(name))
-  } catch { /* vacío */ }
+  // Sin su línea, el cargo existe pero no se encuentra: quien tiene una tarea tendría que abrir la
+  // carpeta para saber si es éste. Se exige acá y no como advertencia porque es estático y de una línea.
+  const linea = catalog.summary(target)
+  if (!linea) errors.push('SKILL.md no declara summary: la línea con la que se elige este cargo')
+  else if (linea.length > SUMMARY_MAX) {
+    errors.push(`summary tiene ${linea.length} caracteres y el máximo es ${SUMMARY_MAX}: `
+      + 'si no entra en una línea, no sirve para elegir de un vistazo')
+  }
+  const proposals = proposalFiles(path.join(target, 'learning', 'proposals'))
+  let pending = 0
   for (const name of proposals) {
     const text = fs.readFileSync(path.join(target, 'learning', 'proposals', name), 'utf8')
     if (!/^automatic_apply:\s*false$/m.test(text)) errors.push(`${name}: automatic_apply debe ser false`)
     for (const section of REQUIRED_SECTIONS) {
       if (!text.includes(`## ${section}`)) errors.push(`${name}: falta sección ${section}`)
     }
+    // Contar sólo las que esperan algo. Una propuesta aplicada contada como propuesta deja al cargo
+    // reportando trabajo pendiente para siempre, y es la misma confusión que permitía reaplicarla.
+    if (proposalState(text) !== 'applied') pending += 1
   }
   let cases = 0
   try {
     cases = fs.readdirSync(path.join(target, 'evaluations', 'cases'))
       .filter((name) => name.endsWith('.md')).length
   } catch { /* vacío */ }
-  return { errors, proposals: proposals.length, cases }
+  return { errors, proposals: proposals.length, pending, cases }
 }
 
-module.exports = { prepareReport, prepareProposal, evaluate }
+module.exports = { prepareReport, prepareProposal, evaluate, proposalState, seal }

package/engine/automation/index.js

@@ -243,24 +243,7 @@ function check(root) {
   if (!fs.existsSync(path.join(root, 'automatization', 'AGENTS.md'))) {
     errors.push('falta automatization/AGENTS.md')
   }
-  const hooks = [
-    'run-hook.sh',
-    'guard-shell.sh',
-    'guard-files.sh',
-    'guard-destructive.sh',
-    'guard-git-add.sh',
-    'guard-secrets.sh',
-    'guard-generated.sh',
-    'guard-workspace-boundary.sh',
-    'guard-engine.sh',
-    'guard-migrations.sh',
-    'guard-dependencies.sh',
-    'guard-governance.sh',
-    'guard-verify.sh',
-    'guard-planning-drift.sh',
-    'guard-integration-snapshot.sh',
-  ]
-  for (const name of hooks) {
+  for (const name of expectedHooks()) {
     const file = path.join(hookDir, name)
     if (!fs.existsSync(file)) errors.push(`falta automatization/hooks/${name}`)
     else if (!(fs.statSync(file).mode & 0o111)) {
@@ -316,13 +299,32 @@ function validateRunner(root, name, errors) {
   }
 }
 
+// Un `.sh` por grupo de más de un guard: es el que registra el runner para correrlos en un proceso.
+function groupWrappers() {
+  return Object.entries(H.hookGroups)
+    .filter(([, names]) => names.length > 1)
+    .map(([group]) => [group, `guard-${group.replace('pre-', '')}.sh`])
+}
+
+// Los scripts que la instancia debe tener, derivados del registro que los ejecuta en vez de copiados
+// a mano: la copia envejecía sin avisar, porque un guard nuevo del motor no entraba en la cuenta.
+//
+// Se comprueba en una sola dirección a propósito. Un `.sh` que no está acá no sobra: así es como una
+// empresa agrega el suyo —`guard-acme.sh` al lado de los nuestros—, que es lo que `upgrade` le dice
+// que haga y lo único que sobrevive a cada actualización.
+function expectedHooks() {
+  return [
+    'run-hook.sh',
+    ...groupWrappers().map(([, wrapper]) => wrapper),
+    ...GUARD_NAMES.map((name) => `guard-${name}.sh`),
+  ]
+}
+
 // Guards que hoy viven dentro de un grupo, con el wrapper que los reemplaza.
 function supersededGuards() {
   const entries = []
-  for (const [group, names] of Object.entries(H.hookGroups)) {
-    if (names.length < 2) continue
-    const wrapper = `guard-${group.replace('pre-', '')}.sh`
-    for (const name of names) entries.push({ file: `guard-${name}.sh`, wrapper })
+  for (const [group, wrapper] of groupWrappers()) {
+    for (const name of H.hookGroups[group]) entries.push({ file: `guard-${name}.sh`, wrapper })
   }
   return entries
 }
@@ -477,6 +479,12 @@ function deliveryState(recorded, name, resolved, prefix = '') {
 }
 
 function install(root, name, output = console, options = {}) {
+  // `install` arma la superficie de consumo de una empresa: punteros a cada cargo, una copia de los
+  // workflows y los guards. Acá los cargos y los workflows son el producto —la copia divergiría— y
+  // hay guards que contradicen el trabajo, como el que bloquea el push de cada release.
+  if (O.mode(root) === 'toolkit') {
+    throw new Error('Acá se fabrica Cauce, no se lo consume.')
+  }
   const runner = runnerManifest(root, name)
   const errors = check(root)
   if (errors.length) throw new Error(`La automatización no es instalable:\n- ${errors.join('\n- ')}`)

package/engine/cli/args.js

@@ -0,0 +1,52 @@
+'use strict'
+
+// La gramática de la línea de comandos, en su propio módulo para poder probarla sin ejecutar el
+// CLI: `tools/ops.js` invoca el comando haciendo `require` del motor, así que ops.js corre al ser
+// requerido y no puede exportar nada sin dispararse.
+
+// Banderas que consumen el argumento siguiente: su valor no es un posicional.
+const VALUED_FLAGS = new Set(['--name', '--mode', '--fixture', '--period'])
+
+// Qué acepta cada comando, y a la vez qué comandos existen. Una bandera desconocida se rechaza en vez
+// de ignorarse: `check --jsonn` imprimía la salida humana con código 0, así que quien esperaba JSON
+// —un agente, típicamente— recibía texto sin ninguna señal de que su bandera no existía.
+const FLAGS = {
+  init: ['--name', '--mode', '--force'],
+  check: ['--json'],
+  tree: ['--json', '--no-color'],
+  context: ['--json'],
+  upgrade: ['--check', '--force'],
+  archive: [],
+  agents: ['--json', '--own', '--system'],
+  integration: ['--fixture'],
+  automation: ['--force'],
+  learn: ['--proposal', '--applied', '--period'],
+  evaluate: ['--cases', '--json', '--bench', '--force'],
+  team: ['--json'],
+}
+
+// La línea de comandos, leída una sola vez. Antes cada función buscaba sus banderas en
+// `process.argv`, veinticinco veces y a cualquier profundidad: `evaluationBench` sacaba `--force` de
+// ahí en vez de recibirlo, así que su firma no decía de qué dependía y probar un comando exigía
+// levantar un proceso. Acá se parsea al entrar y lo demás recibe el resultado.
+function parse(argv) {
+  const flags = new Set()
+  const values = {}
+  const positional = []
+  for (let index = 0; index < argv.length; index += 1) {
+    const value = argv[index]
+    if (!value.startsWith('--')) { positional.push(value); continue }
+    flags.add(value)
+    if (VALUED_FLAGS.has(value)) { values[value] = argv[index + 1] || ''; index += 1 }
+  }
+  return {
+    positional,
+    has: (flag) => flags.has(flag),
+    value: (flag, fallback = '') => values[flag] || fallback,
+    // Lo que el comando no declara en `FLAGS`. Se calcula sobre `flags` y no sobre argv crudo para
+    // que el valor de una bandera con valor no se confunda con una bandera suelta.
+    unknown: (command) => [...flags].filter((flag) => !FLAGS[command].includes(flag)),
+  }
+}
+
+module.exports = { FLAGS, VALUED_FLAGS, parse }