@ingeniomaps/cauce 0.43.0 → 0.47.0

package/automatization/workflows/integrations/sync.js

@@ -10,10 +10,7 @@ export const meta = {
   ],
 }
 
-// El prefijo lo completa `automation install`. No puede venir del entorno: el runtime de workflows no
-// expone `process`, así que leerlo de ahí reventaba el archivo entero en su primera línea. Viaja
-// escrito, relativo a la carpeta donde se abre la herramienta, que es el cwd de los agentes.
-const ROOT = '{{OPS_DIR}}'.replace(/\/+$/, '') || '.'
+{{INCLUDE:shared/workflow-root.js}}
 // `/integration-sync jira` o `{"provider": "jira"}`: sin entorno, el argumento es la única entrada.
 const input = typeof args === 'string' ? { provider: args } : (args || {})
 const REQUESTED = String(input.provider || '').trim()

package/automatization/workflows/onboard.js

@@ -26,9 +26,7 @@ export const meta = {
   ],
 }
 
-// El prefijo lo completa `automation install`: el runtime no expone `process`, así que la ruta de la
-// raíz ops viaja escrita, relativa a donde se abre la herramienta.
-const ROOT = '{{OPS_DIR}}'.replace(/\/+$/, '') || '.'
+{{INCLUDE:shared/workflow-root.js}}
 const P = `${ROOT}/planning`
 const ORG = `${ROOT}/organization`
 const HUMAN = `${P}/HUMAN_ACTIONS.md`
@@ -60,15 +58,7 @@ const BASE = `Nunca inventes clientes, métricas, ingresos, plazos ni responsabl
   `empezar. El análisis profundo llega después, cuando alguien pida algo concreto; adelantarlo acá ` +
   `retrasa el único momento en que la herramienta todavía no sirve para nada.`
 
-function finish(result) {
-  log(`Fin: ${JSON.stringify(result)}`)
-  return result
-}
-
-const stop = (reason, detail = '') => {
-  log(`Checkpoint: ${reason}${detail ? ` — ${detail}` : ''}`)
-  return finish({ stopped: true, reason, detail })
-}
+{{INCLUDE:shared/workflow-finish.js}}
 
 const SCAN = {
   type: 'object', additionalProperties: false, required: ['fresh', 'services'],
@@ -134,8 +124,8 @@ if (!state.fresh && !FORCE) {
 }
 
 const services = state.services || []
-const listado = services.map((service) => service.path).join(', ')
-log(`${services.length} servicio(s) en el workspace${listado ? `: ${listado}` : ''}`)
+const listed = services.map((service) => service.path).join(', ')
+log(`${services.length} servicio(s) en el workspace${listed ? `: ${listed}` : ''}`)
 
 // Sin contexto no hay nada que escribir que no sea inventado. Lo que se devuelve no es una negativa
 // sino la conversación: quien recién instaló no sabe qué es «volvé a correrlo con contexto», y adivinar
@@ -147,9 +137,9 @@ const dimensions = state.dimensions || []
 if (!CONTEXT && state.opening) {
   log(`Falta lo que el repositorio no puede decir. Preguntale primero, con estas palabras:`)
   log(`  ${state.opening}`)
-  const faltan = dimensions.map((need) => `  · ${need}`).join('\n')
+  const pending = dimensions.map((need) => `  · ${need}`).join('\n')
   log(`Después, según lo que conteste, hasta ${state.followUps || 3} preguntas más, formuladas para este ` +
-    `proyecto y no como formulario, hasta cubrir lo que haga falta de:\n${faltan}`)
+    `proyecto y no como formulario, hasta cubrir lo que haga falta de:\n${pending}`)
   log('Con sus respuestas, volvé a invocar el arranque pasándoselas como contexto.')
   return finish({ needsContext: true, opening: state.opening, dimensions, services: services.length })
 }
@@ -224,15 +214,15 @@ const epic = await agent(
 if (!epic) return stop('epic-unavailable', 'la épica no devolvió resultado')
 if (!epic.passed) return stop('check-failed', epic.details || 'check no pasó tras escribir la épica')
 
-const supuestos = (drafted.assumptions || []).length
-const acciones = (drafted.humanActions || []).length
-log(`Contexto escrito con ${supuestos} supuesto(s) por confirmar y ${acciones} acción(es) humana(s) en ${HUMAN}.`)
+const assumptions = (drafted.assumptions || []).length
+const humanActions = (drafted.humanActions || []).length
+log(`Contexto escrito con ${assumptions} supuesto(s) por confirmar y ${humanActions} acción(es) humana(s) en ${HUMAN}.`)
 log(`Épica en ${epic.file}, sin promover: revisala, promoví una historia a un hito del BACKLOG y corré /autobuild.`)
 
 return finish({
   services: services.length,
-  assumptions: supuestos,
-  humanActions: acciones,
+  assumptions,
+  humanActions,
   epic: epic.file,
   promoted: false,
 })

package/engine/agents/evaluations.js

@@ -11,8 +11,20 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
+const { spawnSync } = require('node:child_process')
 const catalog = require('./catalog')
 
+// De quién son los casos. Un cargo y un recorrido se miden igual —una tentación escrita, los
+// comportamientos que debería exhibir, un veredicto registrado— y lo único que cambia es dónde vive
+// el contrato. Se resuelve acá y una sola vez, en vez de duplicar el mecanismo por tipo de sujeto.
+//
+// El tipo se nombra en la llamada y no se adivina del slug: un cargo y un recorrido pueden llamarse
+// igual sin colisionar, porque hoy viven en árboles separados, y adivinar los volvería ambiguos.
+function subject(root, slug, kind = 'agent') {
+  if (kind === 'flow') return path.dirname(require('../flows/registry').read(root, slug).file)
+  return catalog.resolve(root, slug)
+}
+
 const RESULTS = ['evaluations', 'results']
 
 function caseFiles(dir) {
@@ -42,8 +54,8 @@ function fixtureFiles(dir, prefix = '') {
   return found
 }
 
-function fixtures(root, agent, id) {
-  const dir = path.join(catalog.resolve(root, agent), 'evaluations', 'cases', id)
+function fixtures(root, agent, id, kind) {
+  const dir = path.join(subject(root, agent, kind), 'evaluations', 'cases', id)
   return { dir, files: fixtureFiles(dir) }
 }
 
@@ -65,8 +77,8 @@ function parseCase(text) {
   return { request: request.trim(), expected }
 }
 
-function list(root, agent) {
-  const dir = path.join(catalog.resolve(root, agent), 'evaluations', 'cases')
+function list(root, agent, kind) {
+  const dir = path.join(subject(root, agent, kind), 'evaluations', 'cases')
   return caseFiles(dir).map((name) => {
     const id = name.replace(/\.md$/, '')
     return {
@@ -87,8 +99,8 @@ function list(root, agent) {
 // al proponer cambios, nunca al evaluar. La conducta prohibida entraba únicamente si quien lanzaba la
 // corrida se acordaba de escribirla en el prompt, y ahí el criterio cambiaba entre corridas: tres rondas
 // del mismo caso se midieron con tres listones distintos y dejaron de ser comparables.
-function behaviors(root, agent) {
-  const file = path.join(catalog.resolve(root, agent), 'evaluations', 'expected-behaviors.yaml')
+function behaviors(root, agent, kind) {
+  const file = path.join(subject(root, agent, kind), 'evaluations', 'expected-behaviors.yaml')
   let text
   try { text = fs.readFileSync(file, 'utf8') } catch { return { required: [], forbidden: [] } }
   const found = { required: [], forbidden: [] }
@@ -103,8 +115,23 @@ function behaviors(root, agent) {
   return found
 }
 
-function resultsDir(root, agent) {
-  return path.join(catalog.resolve(root, agent), ...RESULTS)
+// Cuándo cambió por última vez el contrato que la corrida midió. Sale de git y no del mtime del
+// archivo: un `npm ci` o un checkout reescriben mtimes y dirían que todo cambió hoy.
+//
+// Sin esto, un contrato que se endurece deja atrás registros que siguen diciendo «pasa» — y el que
+// endurece es justo el que puede hacerlos fallar. Es la misma confusión que el resultado que cubre
+// menos casos de los que existen, y se ve igual de poco.
+//
+// La comparación es por día y no por instante porque el registro guarda fecha y no hora: un contrato
+// que cambia y se vuelve a medir el mismo día no dispara el aviso. Es el caso que menos importa
+// —quien lo cambió hoy sabe que lo cambió—, y afinar más pediría una hora que el registro no tiene.
+function contractChangedAt(dir) {
+  const git = spawnSync('git', ['-C', dir, 'log', '-1', '--format=%cs', '--', 'SKILL.md'], { encoding: 'utf8' })
+  return git.status === 0 ? (git.stdout || '').trim() : ''
+}
+
+function resultsDir(root, agent, kind) {
+  return path.join(subject(root, agent, kind), ...RESULTS)
 }
 
 // Un registro por corrida, y puede haber más de una en el mismo día: aplicar una propuesta cambia el
@@ -130,9 +157,9 @@ function resultNames(dir) {
 
 // El nombre que le toca a la corrida de hoy: el primero libre. Lo decide el motor y no el prompt del
 // recorrido, porque «escribí en <fecha>.md» es una instrucción que no puede saber qué ya existe.
-function nextResult(root, agent, date) {
+function nextResult(root, agent, date, kind) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) throw new Error(`fecha inválida: ${date}`)
-  const dir = resultsDir(root, agent)
+  const dir = resultsDir(root, agent, kind)
   const taken = new Set(resultNames(dir))
   if (!taken.has(`${date}.md`)) return `${date}.md`
   let run = 2
@@ -142,8 +169,8 @@ function nextResult(root, agent, date) {
 
 // El último resultado registrado, para que `evaluate` pueda decir si el cargo se corrió alguna vez y
 // cómo le fue. No es un error no tenerlo: correrlo cuesta, y exigirlo en CI sería exigir red.
-function latest(root, agent) {
-  const dir = resultsDir(root, agent)
+function latest(root, agent, kind) {
+  const dir = resultsDir(root, agent, kind)
   const names = resultNames(dir)
   if (!names.length) return null
   const name = names[names.length - 1]
@@ -162,13 +189,48 @@ function latest(root, agent) {
   }
 }
 
+// El veredicto vigente de cada caso, compuesto sobre todas las corridas: se leen en orden y la última
+// gana. Es lo que hay que mirar cuando existe `--cases`, porque desde que existe una corrida cubre a
+// propósito menos casos de los que el sujeto tiene, y leer sólo la última daba «cubre 1 de 4: el
+// resultado no vale» sobre sujetos con los cuatro casos medidos. Componer a mano lo dejaba a merced de
+// que alguien se acordara.
+//
+// La fecha que viaja es la **más vieja** de las que aportan un veredicto vigente, no la más nueva: un
+// resultado compuesto es tan fresco como su parte más rancia, y es contra eso que hay que comparar un
+// cambio de contrato. Con la más nueva, un caso medido antes del cambio pasaba por medido después.
+function composed(root, agent, kind) {
+  const dir = resultsDir(root, agent, kind)
+  const names = resultNames(dir)
+  if (!names.length) return null
+  const current = new Map()
+  for (const name of names) {
+    const file = path.join(dir, name)
+    const [, date] = name.match(RESULT_NAME)
+    const pattern = /\n###\s+([^\n]+)\n\n-\s*Veredicto:\s*(pasa|no pasa)\s*$/gim
+    for (const hit of fs.readFileSync(file, 'utf8').matchAll(pattern)) {
+      current.set(hit[1].trim(), { passed: hit[2].toLowerCase() === 'pasa', date, file })
+    }
+  }
+  const entries = [...current.entries()]
+  const dates = entries.map(([, one]) => one.date).sort()
+  return {
+    measured: new Map(entries),
+    total: entries.length,
+    passed: entries.filter(([, one]) => one.passed).length,
+    failed: entries.filter(([, one]) => !one.passed).map(([id]) => id),
+    oldest: dates[0] || '',
+    newest: dates[dates.length - 1] || '',
+    runs: names.length,
+  }
+}
+
 // Coherencia entre lo que hay y lo que se corrió. Todo sale como advertencia y ninguno afecta el
 // código de salida, y no es blandura: correr los casos exige un modelo, y CI no lo tiene. Un `evaluate`
 // que fallara por un resultado viejo obligaría a pagar una corrida para poder integrar, y volvería a
 // fallar cada vez que el contrato cambie. Quien falla fuerte es el recorrido que sí los ejecuta.
-function validate(root, agent) {
+function validate(root, agent, kind) {
   const warnings = []
-  const cases = list(root, agent)
+  const cases = list(root, agent, kind)
   const total = cases.length
   // Esto sí es control estructural y no advertencia: que el artefacto esté entregado es una propiedad
   // estática del caso, verificable sin modelo, y dejarla en advertencia es lo que permitió que 47 casos
@@ -176,18 +238,32 @@ function validate(root, agent) {
   const errors = cases
     .filter((item) => item.id.includes('adversarial') && !item.fixtures.length)
     .map((item) => `${item.id}: caso adversarial sin artefacto en cases/${item.id}/`)
-  const last = latest(root, agent)
-  if (!last) {
+  if (!total) {
+    warnings.push('no declara casos: nada mide si su contrato aguanta')
+    return { errors, warnings, cases: 0, last: null }
+  }
+  const last = latest(root, agent, kind)
+  const state = composed(root, agent, kind)
+  if (!last || !state) {
     warnings.push(`sin resultados de casos: corré el recorrido de evaluación para los ${total} casos`)
     return { errors, warnings, cases: total, last: null }
   }
-  if (last.total !== total) {
-    warnings.push(`${path.basename(last.file)} cubre ${last.total} de ${total} caso(s): el resultado no vale`)
+  const sinMedir = cases.map((item) => item.id).filter((id) => !state.measured.has(id))
+  if (sinMedir.length) {
+    warnings.push(`${state.total} de ${total} caso(s) con veredicto: sin medir ${sinMedir.join(', ')}`)
   }
-  if (last.passed < last.total) {
-    warnings.push(`${last.total - last.passed} caso(s) no pasaron en ${last.date}: volvé a correrlos`)
+  if (state.failed.length) {
+    warnings.push(`${state.failed.length} caso(s) no pasan: ${state.failed.join(', ')}`)
   }
-  return { errors, warnings, cases: total, last }
+  const cambio = contractChangedAt(subject(root, agent, kind))
+  if (cambio && cambio > state.oldest) {
+    const parte = state.oldest === state.newest ? 'la última corrida es' : 'el veredicto más viejo es'
+    warnings.push(`el contrato cambió el ${cambio} y ${parte} del ${state.oldest}: `
+      + 'mide una versión anterior')
+  }
+  return { errors, warnings, cases: total, last, state }
 }
 
-module.exports = { behaviors, fixtures, list, latest, nextResult, parseCase, validate, resultsDir }
+module.exports = {
+  behaviors, composed, fixtures, list, latest, nextResult, parseCase, validate, resultsDir,
+}

package/engine/agents/fork.js

@@ -16,6 +16,7 @@ const path = require('node:path')
 const catalog = require('./catalog')
 const manifest = require('../core/manifest')
 const ownership = require('../core/ownership')
+const { atomicWrite } = require('../core/files')
 
 // 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
@@ -45,10 +46,10 @@ function packageVersion(root) {
 function markHistory(target, slug, version, date) {
   const file = path.join(target, 'learning', 'HISTORY.md')
   if (!fs.existsSync(file)) return
-  const origen = version ? `del catálogo de Cauce ${version}` : 'del catálogo de Cauce'
-  const row = `| ${date} | — | Copiado ${origen} | — | ${slug} pasa a mantenerlo esta empresa |\n`
+  const provenance = version ? `del catálogo de Cauce ${version}` : 'del catálogo de Cauce'
+  const row = `| ${date} | — | Copiado ${provenance} | — | ${slug} pasa a mantenerlo esta empresa |\n`
   const content = fs.readFileSync(file, 'utf8')
-  fs.writeFileSync(file, content.endsWith('\n') ? content + row : `${content}\n${row}`)
+  atomicWrite(file, content.endsWith('\n') ? content + row : `${content}\n${row}`)
 }
 
 // `date` entra por parámetro en vez de leerse acá: la salida tiene que ser reproducible en una prueba.
@@ -68,22 +69,22 @@ function fork(root, slug, date) {
   const target = path.join(root, 'agents', type, slug)
   if (fs.existsSync(target)) throw new Error(`${path.relative(root, target)} ya existe`)
 
-  const todo = tree(found.dir)
-  const files = todo.filter(inherited)
+  const all = tree(found.dir)
+  const files = all.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 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 fromPath = `agents/${type}/system/${slug}`
+  const toPath = `agents/${type}/${slug}`
   const digests = {}
   for (const relative of files) {
     const from = path.join(found.dir, relative)
     const to = path.join(target, relative)
     fs.mkdirSync(path.dirname(to), { recursive: true })
-    if (TEXT.test(relative)) fs.writeFileSync(to, fs.readFileSync(from, 'utf8').split(desde).join(hacia))
+    if (TEXT.test(relative)) fs.writeFileSync(to, fs.readFileSync(from, 'utf8').split(fromPath).join(toPath))
     else fs.copyFileSync(from, to)
     digests[relative] = manifest.digest(from)
   }
@@ -95,7 +96,7 @@ function fork(root, slug, date) {
   forks[slug] = { type, version, files: digests }
   manifest.write(root, null, null, forks)
 
-  return { slug, type, dir: target, files, version, skipped: todo.filter((one) => !inherited(one)) }
+  return { slug, type, dir: target, files, version, skipped: all.filter((one) => !inherited(one)) }
 }
 
 // Qué cambió en el catálogo desde que la empresa se llevó su copia.
@@ -139,8 +140,8 @@ function driftLine(entry) {
   if (entry.changed.length) parts.push(`${entry.changed.length} archivo(s) cambiaron`)
   if (entry.added.length) parts.push(`${entry.added.length} nuevo(s)`)
   if (entry.removed.length) parts.push(`${entry.removed.length} retirado(s)`)
-  const desde = entry.version ? ` desde ${entry.version}` : ''
-  return `${entry.slug}: tu copia no recibe mejoras del catálogo y ahí${desde} ${parts.join(', ')}`
+  const since = entry.version ? ` desde ${entry.version}` : ''
+  return `${entry.slug}: tu copia no recibe mejoras del catálogo y ahí${since} ${parts.join(', ')}`
 }
 
 module.exports = { drift, driftLine, fork, inherited }