@ingeniomaps/cauce 0.16.1 → 0.18.0

package/CHANGELOG.md

@@ -8,6 +8,61 @@ 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
+
+- **`ops agents fork <cargo>`: una empresa se lleva un cargo del catálogo y lo mantiene desde su
+  carpeta.** El tercer camino ya resolvía —un cargo propio con el mismo slug tapa al del sistema, en el
+  listado, en `learn` y en el puntero que instala el runner—, pero llegar hasta ahí era copiar a mano, y
+  eso sale mal de una forma que no se nota: se agarra el `SKILL.md`, que es lo que se ve, y quedan atrás
+  los casos adversariales, las fuentes y el modelo operativo. El cargo responde igual y ya no se puede
+  evaluar, sin ningún aviso.
+
+  No se heredan los informes de aprendizaje, las propuestas ni los veredictos de evaluación. Un veredicto
+  pertenece al contrato que lo ganó, y el fork nace para dejar de ser ese contrato; una propuesta
+  pendiente arrastraría a la empresa a firmar una decisión que era nuestra.
+
+  En el toolkit se niega: acá el catálogo se edita, no se lo copia. Dejarlo pasar creaba un duplicado que
+  tapaba al original, y el trabajo siguiente se hacía sobre la copia mientras la versión que se publica
+  quedaba quieta.
+
+- **`check` y `upgrade` avisan cuando el cargo que forkeaste mejoró río arriba.** El mecanismo ya existía
+  para ADRs y reglas —«sobrescribir es legítimo; lo que no puede pasar es que ocurra en silencio»— pero
+  no cubría los cargos, que es donde más caro sale: un fork se hace una vez y se olvida.
+
+  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. Editar lo propio
+  no dispara nada, y esa mitad es la que decide si el aviso se lee o se ignora.
+
 ## [0.16.1] - 2026-08-16
 
 ### Corregido

package/README.md

@@ -74,6 +74,7 @@ Lee [template/planning/PROTOCOL.md](template/planning/PROTOCOL.md) para el contr
 | `ops tree <planning>` | Muestra roadmap, backlog, WIP, inbox y done sin mutar nada. |
 | `ops context <planning>` | Emite el contexto mínimo de la tarea vigente para un runner. |
 | `ops agents list <ops-root>` | Lista los cargos visibles resolviendo la precedencia. |
+| `ops agents fork <cargo>` | Copia un cargo del catálogo a la empresa, que pasa a mantenerlo. |
 | `ops upgrade <ops-root>` | Actualiza `system/` y el runtime sin tocar lo del proyecto. |
 | `ops archive <planning> <NNN>` | Archiva el DONE de una épica cerrada de forma idempotente. |
 | `ops learn <agent>` | Prepara el informe semanal que completa la automatización de Codex. |
@@ -183,6 +184,25 @@ todas las empresas: investigarla una vez y bien es mejor que repetirla en cada i
 Por eso `learn` falla si lo corrés sobre un cargo del catálogo dentro de una instancia: escribiría en
 el paquete y se perdería. El ciclo mensual de aprendizaje tampoco se distribuye — vive sólo acá.
 
+#### Quedarse con una versión propia de un cargo del catálogo
+
+```bash
+npm run ops -- agents fork product-manager
+```
+
+Copia el cargo entero a `agents/roles/<slug>/` y desde ahí lo mantenés vos: `learn`, `evaluate` y el
+puntero que instala el runner pasan a resolver contra tu copia. **Copiarlo a mano no es equivalente**
+—se agarra el `SKILL.md`, que es lo que se ve, y quedan atrás los casos, las fuentes y el modelo
+operativo: el cargo responde igual y ya no se puede evaluar—.
+
+Lo que no viaja son los informes de aprendizaje, las propuestas y los veredictos de evaluación. Un
+veredicto pertenece al contrato que lo ganó, y el fork nace para dejar de ser ese contrato.
+
+A partir de ahí tu copia deja de recibir las mejoras del catálogo, que es lo que elegiste, pero no en
+silencio: `check` y `upgrade` avisan cuando el original cambia río arriba. Editar tu propia copia no
+dispara nada — se compara contra lo que el catálogo tenía el día del fork, no contra lo que vos
+escribiste después.
+
 ### Versionado
 
 Como `upgrade` reemplaza `system/` sin pedir confirmación, un cambio en el protocolo, en una regla del

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/agents/fork.js

@@ -0,0 +1,152 @@
+'use strict'
+
+// Llevarse un cargo del catálogo a la carpeta de la empresa para mantenerlo desde ahí.
+//
+// Existe porque copiar a mano sale mal de una forma que no se nota: quien copia agarra el `SKILL.md`
+// —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.
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const catalog = require('./catalog')
+const manifest = require('../core/manifest')
+const ownership = require('../core/ownership')
+
+// Se comparan contra la ruta relativa dentro del cargo. `_template.md` sobrevive en las dos carpetas
+// porque es andamiaje del mecanismo, no un artefacto de nadie.
+function inherited(relative) {
+  if (/^learning\/(reports|proposals)\//.test(relative)) return path.basename(relative) === '_template.md'
+  if (relative.startsWith('evaluations/results/')) return false
+  return true
+}
+
+function tree(dir, prefix = '') {
+  const found = []
+  let list = []
+  try { list = fs.readdirSync(dir, { withFileTypes: true }) } catch { return found }
+  for (const entry of list) {
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name
+    if (entry.isDirectory()) found.push(...tree(path.join(dir, entry.name), relative))
+    else found.push(relative)
+  }
+  return found.sort()
+}
+
+// La misma resolución que usa todo lo demás —paquete primero, toolkit después— en vez de deducirla
+// del directorio del motor: la versión que interesa es la del catálogo del que sale la copia.
+function packageVersion(root) {
+  const file = ownership.packagePath(root, 'package.json')
+  if (!file) return ''
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')).version || '' } catch { return '' }
+}
+
+// La fila deja el límite por escrito: arriba, cómo llegó el contrato a ser lo que es —decisiones que
+// tomamos nosotros—; abajo, lo que decida la empresa. Sin ese renglón, la primera fila propia parece
+// continuación de una conversación ajena.
+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 content = fs.readFileSync(file, 'utf8')
+  fs.writeFileSync(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.
+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 }
+
+  const found = catalog.find(root, slug)
+  if (!found.system) {
+    throw new Error(`${slug} ya lo mantiene esta empresa: ${path.relative(root, found.dir)}`)
+  }
+  const type = path.basename(path.dirname(path.dirname(found.dir)))
+  const target = path.join(root, 'agents', type, slug)
+  if (fs.existsSync(target)) throw new Error(`${path.relative(root, target)} ya existe`)
+
+  const files = tree(found.dir).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á —empezando por la fila de historial que se escribe abajo—.
+  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 })
+    fs.copyFileSync(from, to)
+    digests[relative] = manifest.digest(from)
+  }
+
+  const version = packageVersion(root)
+  markHistory(target, slug, version, date)
+
+  const forks = { ...manifest.readForks(root) }
+  forks[slug] = { type, version, files: digests }
+  manifest.write(root, null, null, forks)
+
+  return { slug, type, dir: target, files, version, skipped: tree(found.dir).filter((one) => !inherited(one)) }
+}
+
+// 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.
+//
+// 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
+// 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)
+  const catalogDir = ownership.packageDir(root, 'agents')
+  const found = []
+  for (const [slug, record] of Object.entries(forks)) {
+    if (!record || !record.files) continue
+    const source = catalogDir ? path.join(catalogDir, record.type || 'roles', 'system', slug) : ''
+    if (!source || !fs.existsSync(source)) continue
+    const current = tree(source).filter(inherited)
+    const changed = []
+    const removed = []
+    for (const [relative, recorded] of Object.entries(record.files)) {
+      if (!current.includes(relative)) { removed.push(relative); continue }
+      if (manifest.digest(path.join(source, relative)) !== recorded) changed.push(relative)
+    }
+    const added = current.filter((relative) => !(relative in record.files))
+    if (changed.length || added.length || removed.length) {
+      found.push({ slug, version: record.version || '', changed, added, removed })
+    }
+  }
+  return found.sort((left, right) => left.slug.localeCompare(right.slug))
+}
+
+// Una línea por fork, para que `check` y `upgrade` digan lo mismo con las mismas palabras.
+function driftLine(entry) {
+  const parts = []
+  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(', ')}`
+}
+
+module.exports = { drift, driftLine, fork, inherited }

package/engine/cli/ops.js

@@ -49,8 +49,9 @@ 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
   ops team check <team>
   ops team show <team>`)
@@ -78,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 })) {
@@ -87,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}`)
     }
   }
 }
@@ -142,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
@@ -187,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')}`)
@@ -300,6 +332,9 @@ function check(dir) {
   for (const override of O.overrides(path.resolve(root, '..'))) {
     warnings.push(`${override.collection}/${override.project} sobrescribe ${override.system} (override explícito)`)
   }
+  // Misma regla para los cargos, que es donde más caro sale: un fork se hace una vez y se olvida.
+  const FK = require('../agents/fork')
+  for (const entry of FK.drift(path.resolve(root, '..'))) warnings.push(FK.driftLine(entry))
 
   if (process.argv.includes('--json')) {
     console.log(JSON.stringify({
@@ -604,6 +639,10 @@ function upgrade(dir) {
   for (const name of runners) {
     console.log(`  reinstalá tu runner para que el wiring quede al día: make install-${name}`)
   }
+  // Después de aplicar, no antes: recién acá el paquete tiene la versión nueva y la comparación dice
+  // algo. Es además el momento en que alguien está mirando qué le trajo la actualización.
+  const FK = require('../agents/fork')
+  for (const entry of FK.drift(root)) console.log(`  ⚠ ${FK.driftLine(entry)}`)
 }
 
 // Lista los cargos visibles resolviendo la precedencia; evita que cada consumidor —CI incluido—
@@ -614,7 +653,22 @@ function opsRoot(dir) {
   return path.resolve(dir || process.env.OPS_ROOT || '.')
 }
 
-function agents(action, dir) {
+function agentsFork(slug, dir) {
+  const root = opsRoot(dir)
+  if (!slug) fail('Falta el cargo: ops agents fork <cargo> [ops-root]', 2)
+  let result
+  const date = new Date().toISOString().slice(0, 10)
+  try { result = require('../agents/fork').fork(root, slug, date) } catch (error) { fail(error.message, 2) }
+  console.log(`+ ${path.relative(root, result.dir)} (${result.files.length} archivo(s))`)
+  if (result.skipped.length) {
+    console.log(`  quedan en el catálogo: ${result.skipped.length} artefacto(s) que ganó su versión`)
+  }
+  console.log(`  copiado de Cauce ${result.version || '(versión desconocida)'}; desde ahora lo mantenés vos`)
+  console.log(`  reinstalá tu runner para que ${slug} apunte a tu copia`)
+}
+
+function agents(action, dir, extra) {
+  if (action === 'fork') return agentsFork(dir, extra)
   if (action !== 'list') fail(`Acción de agents desconocida: ${action || '(vacía)'}`, 2)
   const root = opsRoot(dir)
   // Una empresa mantiene sus cargos, no los nuestros: `learn` sobre uno del catálogo se niega, así que
@@ -827,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.
@@ -884,7 +949,7 @@ async function main() {
   else if (command === 'tree') tree(arg[1])
   else if (command === 'context') context(arg[1])
   else if (command === 'upgrade') upgrade(arg[1])
-  else if (command === 'agents') agents(arg[1], arg[2])
+  else if (command === 'agents') agents(arg[1], arg[2], arg[3])
   else if (command === 'archive') archive(arg[1], arg[2])
   else if (command === 'integration') {
     await integration(arg[1], arg[2], arg[3], arg[4])

package/engine/core/manifest.js

@@ -30,17 +30,24 @@ function readAll(root) {
     return {
       files: typeof data.files === 'object' && data.files ? data.files : {},
       runners: typeof data.runners === 'object' && data.runners ? data.runners : {},
+      forks: typeof data.forks === 'object' && data.forks ? data.forks : {},
     }
-  } catch { return { files: {}, runners: {} } }
+  } catch { return { files: {}, runners: {}, forks: {} } }
 }
 
 function read(root) { return readAll(root).files }
 
 function readRunners(root) { return readAll(root).runners }
 
+// Tercera sección, y de otra naturaleza que las dos anteriores: `files` y `runners` registran lo que
+// Cauce entregó, mientras `forks` registra lo que la empresa se llevó. Guarda el contenido del cargo
+// del sistema **en el momento de la copia**, que es lo único contra lo que se puede decir después
+// «esto mejoró río arriba»: comparar contra el fork mismo mediría las ediciones de la empresa.
+function readForks(root) { return readAll(root).forks }
+
 // Cada sección que no se pasa se conserva: `upgrade` no sabe del wiring y `install` no sabe de la
 // instancia, y ninguno de los dos debería borrar lo que el otro anotó.
-function write(root, files, runners) {
+function write(root, files, runners, forks) {
   const current = readAll(root)
   const target = path.join(root, FILE)
   fs.mkdirSync(path.dirname(target), { recursive: true })
@@ -51,6 +58,7 @@ function write(root, files, runners) {
     version: 1,
     files: ordered(files || current.files),
     runners: ordered(runners || current.runners),
+    forks: ordered(forks || current.forks),
   }
   fs.writeFileSync(target, `${JSON.stringify(data, null, 2)}\n`)
 }
@@ -85,4 +93,6 @@ function edited(root, relative, files) {
   })
 }
 
-module.exports = { FILE, digest, digestText, edited, prune, read, readRunners, record, write }
+module.exports = {
+  FILE, digest, digestText, edited, prune, read, readForks, readRunners, record, write,
+}

package/package.json

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