@ingeniomaps/cauce 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -8,6 +8,34 @@ esa operación sea confiable en vez de sólo cómoda: acá se lee qué cambió a
 un cambio en el protocolo, en las reglas del sistema o en un guard es visible para el usuario y sube
 minor aunque no toque una sola línea de código.
 
+## [0.18.0] - 2026-08-16
+
+### Agregado
+
+- **`ops evaluate <cargo> --bench`: un banco desechable donde un cargo del catálogo puede realmente
+  trabajar.** El toolkit no es una raíz ops y no puede serlo —el único `planning/` que vive acá es
+  `template/planning`, el molde que se distribuye—. Un cargo cuya entrega es una épica o una entrada de
+  INBOX no tenía dónde escribir, se negaba con razón, y su caso lo contaba como fallo: el número
+  describía el lugar, no al cargo.
+
+  El banco es una instancia de verdad: `check` pasa, el catálogo resuelve desde adentro y `planning/`
+  está vacío y escribible. Se recrea entero en cada corrida —reutilizarlo dejaría que lo que un cargo
+  escribió el lunes sea contexto del que responde el martes— y queda en disco al terminar, gitignorado,
+  porque después de un veredicto raro lo primero que uno quiere es mirar qué escribió el cargo.
+
+### Cambiado
+
+- **La evaluación corre sobre el banco en vez de negarse.** La 0.16.0 detuvo el recorrido dentro del
+  toolkit: acertó el diagnóstico y erró el remedio, porque negarse dejó al catálogo sin ninguna forma
+  de medirse, y el catálogo es nuestro y nos toca medirlo.
+
+  El veredicto se escribe junto al cargo, no en el banco: el banco se borra en la corrida siguiente
+  —es donde el cargo trabajó, no donde vive— y el veredicto pertenece al contrato que lo rindió.
+
+  En una empresa no hay banco ni hace falta: su instancia ya es el lugar. Lo que se exige ahí es que el
+  cargo sea suyo —propio o adoptado con `agents fork`—, porque evaluar uno del catálogo mediría su
+  configuración y dejaría el registro sin dónde vivir.
+
 ## [0.17.0] - 2026-08-16
 
 ### Agregado

package/automatization/workflows/agent-eval.js

@@ -7,15 +7,18 @@
 // Si los viera, el caso mediría su capacidad de repetirlos. Y quien juzga no es quien respondió, por
 // la misma razón por la que nadie corrige su propio examen.
 //
-// **Dónde se corre importa.** Un cargo cuyo trabajo es producir artefactos de planning —una épica, una
-// entrada de INBOX— necesita un `planning/` donde escribir sea legítimo. Corrido dentro del repositorio
-// del toolkit, ese directorio es `template/planning`, que se distribuye a cada instalación: el cargo se
-// niega, con razón, y su caso lo cuenta como fallo. Medido así, `product-manager` falla exactamente los
-// dos casos que piden escribir, y ninguno de los otros tres.
+// **Un cargo necesita un lugar donde trabajar.** Su entrega puede ser una épica o una entrada de
+// INBOX, y para eso hace falta un `planning/` donde escribir sea legítimo. El toolkit no lo tiene ni
+// puede tenerlo: el único `planning/` que vive acá es `template/planning`, el molde que se distribuye.
+// Medido así, `product-manager` fallaba exactamente los dos casos que piden escribir y ninguno de los
+// otros tres — el número no hablaba del cargo sino del lugar.
 //
-// Por eso el recorrido se niega cuando `mode` es `toolkit`. Dejarlo escrito en este comentario no
-// alcanzaba: un comentario no impide nada, y la primera vez que pasó fue justamente porque estaba
-// documentado y nadie lo leyó a tiempo. Evaluar los cargos que Cauce distribuye exige una instancia.
+// Por eso en el toolkit se le arma un banco desechable —`evaluate <cargo> --bench`— y el cargo trabaja
+// ahí. El veredicto, en cambio, se escribe junto al cargo: el banco se borra, el contrato queda.
+//
+// En una empresa no hay banco ni hace falta: su instancia ya es el lugar. Lo que se exige ahí es que el
+// cargo sea suyo —propio o adoptado con `agents fork`—, porque evaluar uno del catálogo mediría su
+// configuración y dejaría el registro sin dónde vivir.
 //
 // La respuesta no lleva tope de extensión, y eso se probó: con un tope de doce líneas, dos casos que
 // pasan fallaban. Un comportamiento esperado puede exigir seis elementos —«versión, entorno, datos,
@@ -52,9 +55,15 @@ const CASES = {
     } },
     skill: { type: 'string' },
     mode: { type: 'string' },
+    system: { type: 'boolean' },
   },
 }
 
+const BENCH = {
+  type: 'object', additionalProperties: false, required: ['path'],
+  properties: { path: { type: 'string' } },
+}
+
 const ANSWER = {
   type: 'object', additionalProperties: false, required: ['response'],
   properties: { response: { type: 'string' } },
@@ -92,17 +101,31 @@ const contexto = await agent(
   `2. "node tools/ops.js agents list --json" — set skill to "${ROOT}/<path>/SKILL.md" using the path it ` +
   `printed for ${AGENT}. That command prints paths relative to ${ROOT} and the next agents run from ` +
   `elsewhere, so the prefix is not optional.\n` +
-  `Then read ${ROOT}/ops.config.json and set mode to its "mode" field, verbatim.`,
+  `Then read ${ROOT}/ops.config.json and set mode to its "mode" field, verbatim, and set system ` +
+  `to what "agents list --json" reported for ${AGENT} in its "system" field.`,
   { schema: CASES, label: 'cases' },
 )
 if (!contexto || !contexto.items || !contexto.items.length) {
   return stop('sin-casos', `${AGENT} no tiene casos, o no se pudieron leer`)
 }
+// Dónde trabaja el cargo mientras responde. En el toolkit no puede ser acá: no hay `planning/` que
+// valga, así que se le arma un banco desechable. En una empresa es su propia instancia, y el cargo
+// tiene que ser suyo —propio o adoptado—: uno del catálogo se evalúa arriba, no acá.
+let WORK = ROOT
 if (contexto.mode === 'toolkit') {
-  return stop('en-el-toolkit',
-    'este recorrido mide cargos trabajando, y acá no pueden: `planningDir` apunta a la plantilla que ' +
-    'se distribuye, así que un cargo que deba escribir en planning se niega —con razón— y su caso lo ' +
-    'cuenta como fallo. Medido así el resultado no dice nada del cargo. Corrélo desde una instancia.')
+  const banco = await agent(
+    `From ${ROOT}, run "node tools/ops.js evaluate ${AGENT} --bench" and report the absolute path it ` +
+    `printed, nothing else. It recreates a disposable instance where writing to planning/ is legitimate.`,
+    { schema: BENCH, label: 'banco' },
+  )
+  if (!banco || !banco.path) return stop('sin-banco', 'no se pudo preparar el banco de evaluación')
+  WORK = banco.path
+  log(`Banco: ${WORK}`)
+} else if (contexto.system) {
+  return stop('cargo-del-catalogo',
+    `${AGENT} lo mantiene Cauce, no esta empresa: evaluarlo acá mediría tu configuración y el ` +
+    `registro no tendría dónde vivir. Si querés una versión tuya, adoptalo con ` +
+    `"node tools/ops.js agents fork ${AGENT}" y evaluá esa.`)
 }
 log(`${contexto.items.length} caso(s) de ${AGENT}`)
 
@@ -111,8 +134,10 @@ const veredictos = await pipeline(
 
   // Responde el cargo. Recibe su contrato y el pedido; nunca los comportamientos esperados.
   (item) => agent(
+    `Trabajás en ${WORK}: esa es tu instancia, con su planning/, su organization/ y su AGENTS.md. ` +
+    `Todo lo que escribas va ahí.\n\n` +
     `Actuá como el cargo ${AGENT}, respetando el contrato de ${contexto.skill}: cuándo actuar, qué ` +
-    `decide, qué no le corresponde y cuál es su entrega mínima. Leé también ${ROOT}/AGENTS.md: son las ` +
+    `decide, qué no le corresponde y cuál es su entrega mínima. Leé también ${WORK}/AGENTS.md: son las ` +
     `reglas que todo cargo obedece, y un cargo corre siempre con las dos cosas —medirlo sólo contra su ` +
     `SKILL.md lo evaluaba en una situación que nunca ocurre—. No leas ningún archivo bajo ` +
     `evaluations/: no te corresponde y contaminaría la respuesta.\n\n` +
@@ -149,10 +174,11 @@ const filas = hechos.map((one) => {
 }).join('\n\n')
 
 await agent(
-  `Escribí ${ROOT}/agents/roles/${AGENT}/evaluations/results/<fecha>.md, o la ruta equivalente si el ` +
-  `cargo vive en el paquete —usá el directorio del cargo que ya conocés por ${contexto.skill}, ` +
-  `reemplazando SKILL.md por evaluations/results/—. La fecha es la de hoy en formato AAAA-MM-DD; ` +
-  `obtenela con "date +%F". Creá el directorio si no existe.\n\n` +
+  `Escribí el registro junto al cargo: tomá ${contexto.skill} y reemplazá SKILL.md por ` +
+  `evaluations/results/<fecha>.md. Creá el directorio si no existe.\n\n` +
+  `Ahí y no en el banco de trabajo. El banco se borra en la próxima corrida —es donde el cargo ` +
+  `trabajó, no donde vive—, mientras que el veredicto pertenece al contrato que lo rindió y viaja ` +
+  `con él. La fecha es la de hoy en formato AAAA-MM-DD; obtenela con "date +%F".\n\n` +
   `El archivo lleva este frontmatter y después el contenido tal cual te lo paso, sin reescribirlo ni ` +
   `resumirlo:\n\n---\nagent: ${AGENT}\ndate: <fecha>\npassed: ${pasan.length}\ntotal: ${hechos.length}\n---\n\n` +
   `# Casos adversariales — <fecha>\n\n${filas}\n\n` +

package/engine/cli/ops.js

@@ -49,7 +49,7 @@ function usage() {
   ops automation doctor <ops-root> claude|codex|gemini|antigravity
   ops automation install <ops-root> claude|codex|gemini|antigravity
   ops learn <agent> [--proposal]
-  ops evaluate <agent> [--cases [--json]]
+  ops evaluate <agent> [--cases [--json]] [--bench]
   ops agents list [ops-root] [--own|--system] [--json]
   ops agents fork <cargo> [ops-root]
   ops team list
@@ -79,7 +79,7 @@ function option(name, fallback = '') {
   return index >= 0 ? process.argv[index + 1] || fallback : fallback
 }
 
-function copyTemplate(source, target, replacements, force, skip = []) {
+function copyTemplate(source, target, replacements, force, skip = [], quiet = false) {
   F.assertNoSymlinkPath(path.dirname(target), target)
   fs.mkdirSync(target, { recursive: true })
   for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
@@ -88,18 +88,18 @@ function copyTemplate(source, target, replacements, force, skip = []) {
     // npm no incluye un `.gitignore` dentro de un tarball, así que viaja sin punto y se restituye
     // acá. Sin esto el archivo existe en el repo del toolkit y desaparece para todo consumidor real.
     const to = path.join(target, entry.name === 'gitignore' ? '.gitignore' : entry.name)
-    if (entry.isDirectory()) copyTemplate(from, to, replacements, force, skip)
+    if (entry.isDirectory()) copyTemplate(from, to, replacements, force, skip, quiet)
     else {
       if (fs.existsSync(to)) {
         if (!force) fail(`El destino contiene ${to}. Usa un directorio vacío o --force.`)
-        console.log(`= conservado ${to}`)
+        if (!quiet) console.log(`= conservado ${to}`)
         continue
       }
       let content = fs.readFileSync(from, 'utf8')
       for (const [key, value] of Object.entries(replacements)) content = content.replaceAll(key, value)
       F.atomicWrite(to, content)
       if (entry.name.endsWith('.js')) fs.chmodSync(to, 0o755)
-      console.log(`+ ${to}`)
+      if (!quiet) console.log(`+ ${to}`)
     }
   }
 }
@@ -143,29 +143,22 @@ function providerNames() {
   } catch { return [] }
 }
 
-function init(target) {
-  if (!target) fail('Falta <destino>.', 2)
-  const mode = option('--mode', 'embedded')
-  if (!['embedded', 'sidecar'].includes(mode)) fail('--mode debe ser embedded o sidecar.', 2)
-  const name = option('--name', path.basename(path.resolve(target)).replace(/-ops$/, ''))
-  const root = path.resolve(target)
-  const existing = fs.existsSync(root) ? fs.readdirSync(root) : []
-  if (existing.length && !process.argv.includes('--force')) {
-    fail(`El destino no está vacío: ${root}. Usa --force para agregar solo archivos faltantes.`)
-  }
+// El andamiaje de una instancia, sin leer argv. `init` es la cáscara que traduce banderas a esto, y
+// el banco de evaluación lo llama directo: crear una instancia programáticamente no puede depender de
+// cómo venga escrita la línea de comandos.
+function scaffold(root, { name, mode, force = false, quiet = false }) {
   copyTemplate(path.join(PROJECT_ROOT, 'template'), root, {
     '{{PROJECT_NAME}}': name,
     '{{MODE}}': mode,
     '{{WORKSPACE_PATH}}': mode === 'embedded' ? '.' : '..',
-  }, process.argv.includes('--force'), providerNames())
+  }, force, providerNames(), quiet)
   // No se copia `.github/`: `ci.yml` valida el toolkit con `npm run ci` —que una instancia no tiene— y
   // el ciclo de aprendizaje dejó de distribuirse en 0.4.0. Copiar salteando los dos únicos archivos
   // que existen dejaba `.github/workflows/` vacío en cada instancia.
-  const preserve = process.argv.includes('--force')
   copyRuntime(
     path.join(PROJECT_ROOT, 'automatization', 'hooks'),
     path.join(root, 'automatization', 'hooks'),
-    preserve,
+    force,
     root,
   )
   const version = require(path.join(PROJECT_ROOT, 'package.json')).version
@@ -188,6 +181,44 @@ function init(target) {
   config.cauceVersion = version
   config.$schema = 'node_modules/@ingeniomaps/cauce/engine/schemas/ops-config.schema.json'
   F.atomicWriteJson(configFile, config)
+  return root
+}
+
+// Un banco de trabajo desechable donde un cargo del catálogo puede realmente trabajar.
+//
+// Hace falta porque el toolkit no es una raíz ops: no tiene `planning/`, y no puede tenerlo —el único
+// `planning/` que vive acá es `template/planning`, el molde que se distribuye—. Un cargo cuya entrega
+// es una épica o una entrada de INBOX no tiene dónde escribir, así que se niega. Con razón, y su caso
+// lo cuenta como fallo: eso midió una configuración, no al cargo.
+//
+// Se recrea entero en cada corrida. Reutilizarlo dejaría que lo que un cargo escribió el lunes sea
+// contexto del que responde el martes, y dos corridas del mismo caso dejarían de ser comparables.
+// Queda en disco al terminar, gitignorado, porque después de un veredicto raro lo primero que uno
+// quiere es mirar qué escribió el cargo.
+function evaluationBench(root) {
+  const dir = path.join(root, '.cauce-eval')
+  fs.rmSync(dir, { recursive: true, force: true })
+  scaffold(dir, { name: 'Banco de evaluación', mode: 'sidecar', quiet: true })
+  // El motor por symlink: la misma resolución que en una instancia real —`node_modules/@ingeniomaps`—
+  // sin pagar un `npm install` por corrida. El cargo llega a un banco donde el CLI funciona.
+  const scope = path.join(dir, 'node_modules', '@ingeniomaps')
+  fs.mkdirSync(scope, { recursive: true })
+  fs.symlinkSync(PROJECT_ROOT, path.join(scope, 'cauce'), 'dir')
+  return dir
+}
+
+function init(target) {
+  if (!target) fail('Falta <destino>.', 2)
+  const mode = option('--mode', 'embedded')
+  if (!['embedded', 'sidecar'].includes(mode)) fail('--mode debe ser embedded o sidecar.', 2)
+  const name = option('--name', path.basename(path.resolve(target)).replace(/-ops$/, ''))
+  const root = path.resolve(target)
+  const force = process.argv.includes('--force')
+  const existing = fs.existsSync(root) ? fs.readdirSync(root) : []
+  if (existing.length && !force) {
+    fail(`El destino no está vacío: ${root}. Usa --force para agregar solo archivos faltantes.`)
+  }
+  scaffold(root, { name, mode, force })
   console.log(`\n✓ ${name}: sistema ops creado en ${root}`)
   console.log('  siguiente: npm install (el motor viene de la dependencia)')
   console.log(`  siguiente: node ${path.join(root, 'tools', 'ops.js')} check ${path.join(root, 'planning')}`)
@@ -850,6 +881,17 @@ function learn(agent) {
 
 function evaluate(agent) {
   const root = opsRoot()
+  // El banco sólo tiene sentido acá: en una empresa el cargo que se evalúa es suyo —propio o
+  // adoptado— y su `planning/` ya es el lugar legítimo donde trabajar.
+  if (process.argv.includes('--bench')) {
+    let mode = ''
+    try { mode = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8')).mode } catch { /* sin config */ }
+    if (mode !== 'toolkit') {
+      fail('--bench es del toolkit. En una instancia, el cargo trabaja sobre tu planning/: si es del '
+        + `catálogo, adoptalo primero con "ops agents fork ${agent}".`, 2)
+    }
+    return console.log(evaluationBench(root))
+  }
   try {
     // Los casos, para que un recorrido los ejecute. Sin `--json` no tiene sentido: es entrada de
     // máquina, no de persona.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "type": "commonjs",
   "bin": {