@ingeniomaps/cauce 0.53.2 → 0.55.0

package/engine/automation/config.js

@@ -8,7 +8,7 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const F = require('../core/files')
-const { supersededGuards } = require('./hooks')
+const { supersededGuards, expectedHooks } = require('./hooks')
 
 function mergeConfig(current, incoming) {
   if (Array.isArray(incoming)) {
@@ -32,19 +32,40 @@ function mergeConfig(current, incoming) {
   return incoming
 }
 
-// Una entrada de hook que puso Cauce se reconoce por el guard al que apunta: `automatization/hooks/`
-// es nuestro y ninguna empresa escribe ahí. Se saca del archivo del usuario antes de fusionar para que
-// el merge deje exactamente las de esta versión, ni una más.
-const DELIVERED = /automatization\/hooks\/guard-[a-z-]+\.sh/
+// Una entrada de hook que puso Cauce se reconoce por el guard al que apunta, y lo nuestro es lo que
+// efectivamente entregamos, no todo lo que vive en nuestra carpeta. Reconocer por directorio
+// desregistraba el guard propio del proyecto en cada reinstalación: `template/AGENTS.md` invita a
+// ponerlo justo ahí y promete que sobrevive a cada actualización, el archivo quedaba en disco, y lo
+// único que se veía era una línea diciendo que se había quitado una entrada obsoleta.
+// Se saca del archivo del usuario antes de fusionar para que el merge deje exactamente las de esta
+// versión, ni una más.
+const HOOK_PATH = /automatization\/hooks\/([a-z0-9-]+\.sh)(?:\s|$)/
 
-function withoutDeliveredHooks(config, live) {
+// Dos fuentes, y la segunda es la que cierra el borde. `expectedHooks()` dice qué entrega el motor de
+// hoy y alcanza para una instancia que nunca instaló; `delivered` es lo que esta instancia registró
+// haber recibido la última vez, y es lo único que reconoce un guard que entregamos en una versión y
+// retiramos en la siguiente: su nombre ya no está en la lista de hoy, así que sin el registro quedaría
+// vivo en la configuración llamando a un guard que Cauce ya no mantiene. Un guard propio del proyecto
+// no está en ninguna de las dos, que es exactamente por lo que sobrevive.
+function isDelivered(command, delivered) {
+  const hit = String(command).match(HOOK_PATH)
+  if (!hit) return false
+  return expectedHooks().includes(hit[1]) || delivered.has(String(command))
+}
+
+// Lo que de un conjunto de comandos es wiring de guards nuestro, para anotarlo como entregado.
+function deliveredHookCommands(commands) {
+  return [...commands].filter((command) => HOOK_PATH.test(String(command)))
+}
+
+function withoutDeliveredHooks(config, live, delivered = new Set()) {
   const dropped = []
   const walk = (node) => {
     if (Array.isArray(node)) {
       return node
         .filter((item) => {
           const command = item && typeof item === 'object' ? String(item.command || '') : ''
-          if (!DELIVERED.test(command)) return true
+          if (!isDelivered(command, delivered)) 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 (!live.has(command)) dropped.push(command)
@@ -83,9 +104,20 @@ function reportRemoved(name, dropped, live, output) {
 
 function includesConfig(actual, expected) {
   if (Array.isArray(expected)) {
-    return Array.isArray(actual) && expected.every((item) => {
-      return actual.some((value) => JSON.stringify(value) === JSON.stringify(item))
-    })
+    return Array.isArray(actual) && expected.every((item) => actual.some((value) => {
+      // Un grupo de hooks se compara por su contenido, no por su forma serializada. La comprobación es
+      // «contiene», que es lo correcto, pero con el ítem entero como unidad un grupo `{matcher, hooks}`
+      // con un hook de más dejaba de ser el mismo objeto y contaba como ausente: `doctor` llamaba
+      // divergente a una configuración que tenía todo lo esperado, y el anidamiento —donde vive la
+      // diferencia real— no se miraba nunca. La instalación promete conservar lo que el proyecto ya
+      // tenía, así que sumar un hook propio a un grupo nuestro es exactamente lo que permite.
+      if (item && typeof item === 'object' && Array.isArray(item.hooks)) {
+        return value && typeof value === 'object'
+          && value.matcher === item.matcher
+          && includesConfig(value.hooks, item.hooks)
+      }
+      return JSON.stringify(value) === JSON.stringify(item)
+    }))
   }
   if (expected && typeof expected === 'object') {
     return actual && typeof actual === 'object' && Object.entries(expected).every(([key, value]) => {
@@ -170,6 +202,6 @@ function blockUpToDate(file, name, content) {
 
 module.exports = {
   blockStart,
-  mergeConfig, withoutDeliveredHooks, reportRemoved, includesConfig, hasHooks,
+  mergeConfig, withoutDeliveredHooks, deliveredHookCommands, reportRemoved, includesConfig, hasHooks,
   unmergeConfig, isSharedFile, withoutBlock, mergeInstruction, blockUpToDate,
 }

package/engine/automation/hooks.js

@@ -7,7 +7,6 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const H = require('../hooks/run')
-const O = require('../core/ownership')
 const M = require('../core/manifest')
 const { packagedAutomation } = require('./runners')
 

package/engine/automation/index.js

@@ -4,8 +4,6 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const F = require('../core/files')
-const H = require('../hooks/run')
-const P = require('../planning/parser')
 const catalog = require('../agents/catalog')
 const O = require('../core/ownership')
 const M = require('../core/manifest')
@@ -19,7 +17,7 @@ const {
   legacyGuardWiring, staleHooks, listHooks,
 } = require('./hooks')
 const {
-  blockStart, mergeConfig, withoutDeliveredHooks, reportRemoved, includesConfig, hasHooks,
+  blockStart, mergeConfig, withoutDeliveredHooks, deliveredHookCommands, reportRemoved, includesConfig, hasHooks,
   unmergeConfig, isSharedFile, withoutBlock, mergeInstruction, blockUpToDate,
 } = require('./config')
 
@@ -228,6 +226,11 @@ function deliveryKey(name, target) {
   return `${name}/${target.split(path.sep).join('/')}`
 }
 
+// La sección `runners` del manifiesto anota archivo → digest; ésta es la única entrada que guarda una
+// lista, porque lo que registra no es un archivo sino las entradas que dejamos dentro del archivo de
+// configuración del usuario. No colisiona con ningún `target`: ninguno se llama así.
+const HOOKS_KEY = 'config.hooks'
+
 // En qué estado quedó un archivo que este adaptador entregó alguna vez.
 //
 //   nuevo          no existe todavía
@@ -279,6 +282,7 @@ function uninstall(root, name, output = console) {
 
   const items = [...(runner.instructions || []), ...(runner.artifacts || [])]
   const deliveredPaths = { ...recorded }
+  delete deliveredPaths[deliveryKey(name, HOOKS_KEY)]
   for (const item of items) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
     const key = deliveryKey(name, item.target)
@@ -380,7 +384,12 @@ function install(root, name, output = console, options = {}) {
   // guard que el runner intenta ejecutar y falla. Se quitan las nuestras y las vuelve a poner el merge.
   const live = new Set((JSON.stringify(incoming).match(/"command":"[^"]*"/g) || [])
     .map((entry) => JSON.parse(`{${entry}}`).command))
-  const clean = runner.config.owned ? { config: {}, dropped: [] } : withoutDeliveredHooks(current, live)
+  // Lo que este adaptador anotó haber entregado la última vez. Es lo único que reconoce una entrada
+  // nuestra cuyo guard el motor ya no trae: por nombre no se distingue de la que agregó el proyecto.
+  const previous = new Set(recorded[deliveryKey(name, HOOKS_KEY)] || [])
+  const clean = runner.config.owned
+    ? { config: {}, dropped: [] }
+    : withoutDeliveredHooks(current, live, previous)
   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ó
@@ -390,6 +399,12 @@ function install(root, name, output = console, options = {}) {
   }
   output.log(`✓ ${name}: configuración instalada en ${runner.config.target}`)
   const deliveredPaths = { ...recorded }
+  // Qué wiring de guards dejamos puesto, para poder retirarlo el día que el motor deje de traerlo. Se
+  // anota lo que instalamos y no lo que quedó en el archivo: ahí conviven las entradas del proyecto, y
+  // registrarlas nos autorizaría a borrar lo ajeno en la instalación siguiente.
+  const ourHooks = deliveredHookCommands(live)
+  if (ourHooks.length) deliveredPaths[deliveryKey(name, HOOKS_KEY)] = ourHooks
+  else delete deliveredPaths[deliveryKey(name, HOOKS_KEY)]
   for (const resolved of resolvedItems) {
     const status = state.get(resolved)
     const ownFile = runner.instructions.includes(resolved.item)

package/engine/cli/args.js

@@ -25,7 +25,7 @@ const FLAGS = {
   agents: ['--json', '--own', '--system'],
   integration: ['--fixture'],
   automation: ['--force'],
-  learn: ['--flow', '--proposal', '--applied', '--period'],
+  learn: ['--flow', '--proposal', '--applied', '--archived', '--period'],
   evaluate: ['--cases', '--json', '--bench', '--force', '--record', '--flow'],
   flow: ['--json'],
 }
@@ -54,4 +54,4 @@ function parse(argv) {
   }
 }
 
-module.exports = { FLAGS, VALUED_FLAGS, parse }
+module.exports = { FLAGS, parse }

package/engine/cli/catalog.js

@@ -132,6 +132,16 @@ function learn(agent, cli) {
     // aplicada editando frontmatter a mano es justo el paso que un agente hace mal en silencio.
     // Un recorrido aprende de sus corridas y un cargo de su profesión: mismo ciclo, distinto insumo.
     const kind = cli.has('--flow') ? 'flow' : 'agent'
+    // El tercer destino: se miró y no cambia nada. Sin esto sólo había aplicarla o dejarla esperando,
+    // y lo que se hacía era mergear el PR sin firmar — que deja el documento diciendo «sin aplicar»
+    // para siempre, indistinguible de una que espera trabajo.
+    if (cli.has('--archived')) {
+      const result = L.archive(opsRoot(), agent, cli.value('--period'), kind)
+      const relative = path.relative(opsRoot(), result.file)
+      return console.log(result.already
+        ? `= ${relative} ya estaba archivada`
+        : `✓ ${relative} queda archivada: se miró y no cambia nada`)
+    }
     if (cli.has('--applied')) {
       const result = L.seal(opsRoot(), agent, cli.value('--period'), kind)
       const relative = path.relative(opsRoot(), result.file)
@@ -139,14 +149,28 @@ function learn(agent, cli) {
         ? `= ${relative} ya estaba aplicada`
         : `✓ ${relative} queda aplicada: no se vuelve a aplicar`)
     }
+    // Un recorrido no tiene informe semanal: su propuesta se compone de los veredictos de sus propias
+    // corridas y nunca lee `learning/reports/`. La forma desnuda —la que para un cargo abre el informe
+    // de la semana— no tiene entonces qué abrir acá, y `prepareReport` lo decía resolviendo con el
+    // `kind` por defecto: «no existe agents/<tipo>/<slug>/SKILL.md», que manda a crear un cargo que no
+    // falta. Negarse nombrando el comando que sí corresponde es lo que cierra R13.
+    if (kind === 'flow' && !cli.has('--proposal')) {
+      fail(`${agent} es un recorrido: aprende de sus corridas, no de informes semanales.\n`
+        + `  Abrí la propuesta con "ops learn ${agent} --flow --proposal".`, 2)
+    }
     // `--period` es para consolidar a mano un mes que no es el de hoy. El ciclo automático no lo
     // pasa: la propuesta se llama por el mes en que se abre y arrastra lo que todavía no entró.
     const result = cli.has('--proposal')
       ? L.prepareProposal(opsRoot(), agent, new Date(), cli.value('--period'), kind)
       : L.prepareReport(opsRoot(), agent)
-    // Sin informes pendientes no hay archivo que nombrar, y decirlo es el resultado: el ciclo corrió
-    // y no había nada que consolidar.
-    if (!result.file) return console.log('= sin informes pendientes: no se abre propuesta')
+    // Sin archivo que nombrar hay dos resultados distintos y decir cuál es el punto: no había material,
+    // o lo había y ninguno propuso un cambio. El segundo no es un error ni un mes perdido —el informe
+    // es histórico igual— y confundirlo con el primero manda a buscar por qué no se investigó.
+    if (!result.file) {
+      return console.log(result.quiet
+        ? `= ${result.quiet} informe(s) sin recomendación: no hay qué proponer, quedan para el mes que viene`
+        : '= sin informes pendientes: no se abre propuesta')
+    }
     console.log(`${result.created ? '+' : '='} ${path.relative(opsRoot(), result.file)}`)
     // Un cargo consolida informes de su profesión; un recorrido, las corridas que lo midieron.
     if (typeof result.reports === 'number') {
@@ -170,7 +194,12 @@ function evaluate(agent, caso, cli) {
     }
     // El caso es el posicional que sigue al cargo: `evaluate <cargo> --bench <caso>`. Sin él se arma
     // un banco suelto, para mirarlo a mano; una corrida real pide uno por caso.
-    return console.log(evaluationBench(root, agent, caso, cli.has('--force'), kind))
+    //
+    // Relativa a la raíz, como la de `--record`: esta salida la lee el agente que prepara los bancos,
+    // y de ahí la ruta viaja a los informes y a las propuestas que después lee otro cargo. Absoluta
+    // nombraba el directorio personal de una máquina, y así quedaron mil cuatrocientas ochenta y cinco
+    // citas que dejaron de resolver el día que este repositorio cambió de nombre.
+    return console.log(path.relative(root, evaluationBench(root, agent, caso, cli.has('--force'), kind)))
   }
   try {
     // Los casos, para que un recorrido los ejecute. Sin `--json` no tiene sentido: es entrada de

package/engine/cli/instance.js

@@ -7,7 +7,6 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const { spawnSync } = require('node:child_process')
 const F = require('../core/files')
 const O = require('../core/ownership')
 const CL = require('../core/changelog')
@@ -15,7 +14,6 @@ const M = require('../core/manifest')
 const OB = require('../core/onboarding')
 const P = require('../planning/parser')
 const ST = require('../planning/state')
-const I = require('../integrations/registry')
 const A = require('../automation')
 const { fail } = require('./io')
 
@@ -31,9 +29,14 @@ function providerNames() {
   } catch { return [] }
 }
 
+// Devuelve, por archivo conservado, el digest de lo que el molde **habría** escrito. Adoptar Cauce en
+// un repositorio con contenido es `init --force`, y lo que se conserva ahí lo escribió la empresa: si
+// el manifiesto lo registra hasheando el disco queda declarado como entregado por Cauce con contenido
+// que Cauce nunca entregó, y el `upgrade` siguiente no ve ninguna edición local y lo reemplaza.
 function copyTemplate(source, target, replacements, force, skip = [], quiet = false) {
   F.assertNoSymlinkPath(path.dirname(target), target)
   fs.mkdirSync(target, { recursive: true })
+  const preserved = {}
   for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
     if (skip.includes(entry.name)) continue
     const from = path.join(source, entry.name)
@@ -41,11 +44,14 @@ function copyTemplate(source, target, replacements, force, skip = [], quiet = fa
     // 11.16.0: lo deja afuera en la raíz y en subdirectorios—, 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, quiet)
+    if (entry.isDirectory()) Object.assign(preserved, 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.`)
         if (!quiet) console.log(`= conservado ${to}`)
+        let would = fs.readFileSync(from, 'utf8')
+        for (const [key, value] of Object.entries(replacements)) would = would.replaceAll(key, value)
+        preserved[to] = M.digestText(would)
         continue
       }
       let content = fs.readFileSync(from, 'utf8')
@@ -55,22 +61,29 @@ function copyTemplate(source, target, replacements, force, skip = [], quiet = fa
       if (!quiet) console.log(`+ ${to}`)
     }
   }
+  return preserved
 }
 
+// Devuelve lo conservado igual que `copyTemplate`, y por la misma razón: acá el runtime no lleva
+// reemplazos, así que lo que habríamos escrito es el archivo del paquete tal cual.
 function copyRuntime(source, target, preserve = false, boundary = target, skip = []) {
   F.assertNoSymlinkPath(boundary, target)
   fs.mkdirSync(target, { recursive: true })
+  const preserved = {}
   for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
     if (skip.includes(entry.name)) continue
     const from = path.join(source, entry.name)
     const to = path.join(target, entry.name)
-    if (entry.isDirectory()) copyRuntime(from, to, preserve, boundary, skip)
-    else if (preserve && fs.existsSync(to)) console.log(`= conservado ${to}`)
-    else {
+    if (entry.isDirectory()) Object.assign(preserved, copyRuntime(from, to, preserve, boundary, skip))
+    else if (preserve && fs.existsSync(to)) {
+      console.log(`= conservado ${to}`)
+      preserved[to] = M.digest(from)
+    } else {
       F.assertNoSymlinkPath(boundary, to)
       fs.copyFileSync(from, to)
     }
   }
+  return preserved
 }
 
 // Declara el motor como dependencia exacta: el lockfile decide qué versión corre, no una copia.
@@ -118,7 +131,7 @@ function undeclareEngine(manifest) {
 // 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, {
+  const preserved = copyTemplate(path.join(PROJECT_ROOT, 'template'), root, {
     '{{PROJECT_NAME}}': name,
     '{{MODE}}': mode,
     '{{WORKSPACE_PATH}}': mode === 'embedded' ? '.' : '..',
@@ -126,12 +139,12 @@ function scaffold(root, { name, mode, force = false, quiet = false }) {
   // 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 lo que no aplica dejaba
   // `.github/workflows/` vacío en cada instancia.
-  copyRuntime(
+  Object.assign(preserved, copyRuntime(
     path.join(PROJECT_ROOT, 'automatization', 'hooks'),
     path.join(root, 'automatization', 'hooks'),
     force,
     root,
-  )
+  ))
   const version = require(path.join(PROJECT_ROOT, 'package.json')).version
   // El motor llega como dependencia para que el lockfile fije su versión. El repo ops es un sidecar:
   // declarar npm acá no convierte en Node al servicio de Go de al lado.
@@ -142,6 +155,14 @@ function scaffold(root, { name, mode, force = false, quiet = false }) {
     if (fs.existsSync(dir)) deliveredPaths = M.record(root, relative, O.treeFiles(dir), deliveredPaths)
   }
   deliveredPaths = M.recordPaths(root, O.SYSTEM_FILES, deliveredPaths)
+  // Lo conservado entra con el digest del molde, no con el del disco: la diferencia entre los dos es
+  // justamente lo que `localChanges` tiene que ver para que `upgrade` se detenga antes de pisar el
+  // archivo de la empresa. Sólo se pisan claves que ya están: el manifiesto declara lo que Cauce
+  // rastrea, y un archivo propio fuera de esa frontera no le incumbe.
+  for (const [file, hash] of Object.entries(preserved)) {
+    const relative = path.relative(root, file).split(path.sep).join('/')
+    if (relative in deliveredPaths) deliveredPaths[relative] = hash
+  }
   M.write(root, deliveredPaths)
   // La instancia recuerda de qué versión salió: sin esto no hay actualización posible.
   const configFile = path.join(root, 'ops.config.json')
@@ -307,12 +328,20 @@ function upgrade(dir, cli) {
   const overrides = O.overrides(root)
 
   if (dry) {
+    // Lo editado localmente se informa siempre, antes de mirar versiones: son dos preguntas distintas
+    // —«¿hay algo más nuevo?» y «¿qué tengo editado que se perdería?»— y la segunda tiene respuesta
+    // útil aunque la primera sea que no. Sin esto, el único modo que no toca nada era también el único
+    // que no podía avisar del conflicto, justo en el estado normal entre actualizaciones: `init` fija
+    // la versión exacta, así que instancia y motor coinciden casi todo el tiempo.
+    for (const file of changed) console.log(`  editado localmente: ${file}`)
     if (from === to) {
       // Contra el motor instalado, no contra lo publicado: la comparación es local y sin red. Decirlo
       // importa porque `init` fija la versión exacta, así que el motor no se mueve solo y esta línea,
       // a secas, se leía como «no hay nada nuevo» durante todas las versiones siguientes.
       console.log(`= ${to}: la instancia está al día con el motor instalado`)
-      return console.log('  para traer una versión más nueva: npm install --save-dev @ingeniomaps/cauce@latest')
+      console.log('  para traer una versión más nueva: npm install --save-dev @ingeniomaps/cauce@latest')
+      if (changed.length) process.exit(1)
+      return
     }
     // Hacia atrás también es legítimo —una versión rompió algo y se vuelve—, pero anunciarlo como «hay
     // una versión más nueva» era mentir con el número a la vista. Y lo que corresponde imprimir es lo
@@ -324,7 +353,6 @@ function upgrade(dir, cli) {
       console.log(`⚠ hay una versión más nueva: ${to} (la instancia tiene ${from || 'una previa'})`)
       printChangelog(from, to)
     }
-    for (const file of changed) console.log(`  editado localmente: ${file}`)
     process.exit(1)
   }
 
@@ -429,7 +457,10 @@ function upgrade(dir, cli) {
   for (const override of overrides) {
     console.log(`= conservado ${override.collection}/${override.project}: sobrescribe ${override.system}`)
   }
-  console.log('  planning, organization y todo lo propio quedaron intactos')
+  // Sólo cuando es cierto. Llegar acá con algo en `changed` significa que se corrió con --force y se
+  // descartó contenido de la empresa: las líneas de arriba lo enumeran, y afirmar a continuación que
+  // todo lo propio quedó intacto contradice a la única señal que recibe quien corrió el comando.
+  if (!changed.length) console.log('  planning, organization y todo lo propio quedaron intactos')
   // No se borra: sin la dependencia declarada, quitarle `.ops/` la dejaría sin motor. Se avisa y
   // decide una persona.
   if (fs.existsSync(path.join(root, '.ops', 'engine'))) {

package/engine/cli/ops.js

@@ -4,25 +4,9 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
-const P = require('../planning/parser')
-const B = require('../planning/business-rules')
-const PC = require('../planning/contracts')
-const ST = require('../planning/state')
-const I = require('../integrations/registry')
-const L = require('../agents/learning')
 const A = require('../automation')
-const F = require('../core/files')
-const O = require('../core/ownership')
-const CL = require('../core/changelog')
-const M = require('../core/manifest')
-const SC = require('../core/scan')
-const OB = require('../core/onboarding')
-const C = require('../config/validate')
-const T = require('../flows/registry')
-const AG = require('../agents/catalog')
-const EV = require('../agents/evaluations')
 const { FLAGS, parse } = require('./args')
-const { fail, opsRoot } = require('./io')
+const { fail } = require('./io')
 const IN = require('./instance')
 const PL = require('./planning')
 const CAT = require('./catalog')
@@ -37,8 +21,14 @@ const DEFAULT_TARGET = 'ops'
 // de otra— y el proyecto quedaba llamándose «acme-ops». La carpeta que ya nombra al toolkit es la
 // instancia; no hay una segunda adentro.
 function implicitTarget(cwd) {
-  const base = path.basename(cwd)
-  return base === DEFAULT_TARGET || base.endsWith('-ops') ? '.' : DEFAULT_TARGET
+  return isInstanceDir(cwd) ? '.' : DEFAULT_TARGET
+}
+
+// La misma heurística, aplicada al destino ya resuelto: una carpeta que ya nombra al toolkit **es** la
+// instancia, y el código de la empresa vive al lado.
+function isInstanceDir(dir) {
+  const base = path.basename(dir)
+  return base === DEFAULT_TARGET || base.endsWith('-ops')
 }
 
 // El nombre sale de la carpeta del proyecto, no de la que aloja la instancia: `ops/` y `acme-ops/`
@@ -89,7 +79,12 @@ async function init(target, cli) {
   // install` ya asume —el wiring del runner va al padre, donde se abre la herramienta—, así que lo
   // único que faltaba era que fuera lo que pasa cuando no se elige nada.
   const root = path.resolve(target || implicitTarget(process.cwd()))
-  const mode = cli.value('--mode', target ? 'embedded' : 'sidecar')
+  // El modo lo decide a dónde apunta el destino, no si alguien escribió el argumento. `init` e `init .`
+  // resuelven el mismo directorio y elegían modos opuestos: escribir el punto —la forma más natural de
+  // decir «acá»— daba embedded, y ahí la raíz del workspace pasa a ser la carpeta ops misma, así que
+  // `guard-workspace-boundary` deja de reconocer los repos hermanos y el wiring del runner se escribe
+  // adentro en vez de al lado, donde el dev abre su herramienta.
+  const mode = cli.value('--mode', isInstanceDir(root) ? 'sidecar' : 'embedded')
   if (!['embedded', 'sidecar'].includes(mode)) fail('--mode debe ser embedded o sidecar.', 2)
   const name = cli.value('--name', defaultName(root))
   const force = cli.has('--force')
@@ -170,7 +165,7 @@ function usage() {
   ops automation doctor <ops-root> claude|codex|gemini|antigravity
   ops automation install <ops-root> claude|codex|gemini|antigravity
   ops automation uninstall <ops-root> claude|codex|gemini|antigravity
-  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied [--period <AAAA-MM>]]
+  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied|--archived [--period <AAAA-MM>]]
   ops evaluate <agent|flow> [--flow] [--cases [--json]] [--bench [caso]] [--record [AAAA-MM-DD]]
   ops agents list [ops-root] [--own|--system] [--json]
   ops agents fork <cargo> [ops-root]

package/engine/config/validate.js

@@ -45,10 +45,15 @@ function validateWorkspaces(workspaces, errors) {
       continue
     }
     for (const key of Object.keys(workspace)) {
-      if (!['name', 'path'].includes(key)) {
+      if (!['name', 'path', 'verify'].includes(key)) {
         errors.push(`ops.config.json: workspaceRoots[${index}].${key} no está permitido`)
       }
     }
+    // Opcional: la raíz que no lo declara deja que quien verifica descubra la puerta, como siempre.
+    // Declararlo vacío es peor que no declararlo —promete una puerta y no la da—, así que se rechaza.
+    if ('verify' in workspace && (typeof workspace.verify !== 'string' || !workspace.verify.trim())) {
+      errors.push(`ops.config.json: workspaceRoots[${index}].verify debe ser el comando, o no estar`)
+    }
     if (typeof workspace.name !== 'string' || !workspace.name.trim()) {
       errors.push(`ops.config.json: workspaceRoots[${index}].name es obligatorio`)
     }
@@ -78,4 +83,4 @@ function validateRunner(runner, errors) {
   }
 }
 
-module.exports = { MODES, validateOpsConfig }
+module.exports = { validateOpsConfig }

package/engine/core/onboarding.js

@@ -120,8 +120,5 @@ module.exports = {
   missingSections,
   orphanCredentials,
   guide,
-  OPENING,
-  DIMENSIONS,
-  FOLLOW_UPS,
   PLACEHOLDERS,
 }

package/engine/core/scan.js

@@ -218,4 +218,4 @@ module.exports = {
   workspaceRoots,
   candidates,
   inventory,
-  commandsLine, scan, services, expectedEnv, IGNORED, DEPTH, ENV_MAX }
+  commandsLine, scan, services }

package/engine/hooks/input.js

@@ -124,6 +124,6 @@ function findOpsRoot(start) {
 }
 
 module.exports = {
-  readInput, commandOf, fileOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
+  readInput, commandOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
   gitDirectory, isCommit, stagedFiles, pushAllowed, findOpsRoot,
 }

package/engine/integrations/proposals.js

@@ -79,4 +79,4 @@ function validate(root, provider, workspaces = []) {
   return errors
 }
 
-module.exports = { STATES, TYPES, read, validate }
+module.exports = { read, validate }

package/engine/integrations/providers/jira.js

@@ -161,4 +161,4 @@ async function fetchItems(config, options = {}) {
   return issues.map((issue) => normalizeIssue(issue, config))
 }
 
-module.exports = { adfToMarkdown, deriveAcceptance, fetchItems, normalizeFixture, normalizeIssue, validateConfig }
+module.exports = { fetchItems, normalizeFixture, validateConfig }

package/engine/integrations/registry.js

@@ -397,7 +397,6 @@ function providerState(root, name) {
 
 module.exports = {
   providerState,
-  STATES,
   adapter,
   frontmatter,
   promote,

package/engine/planning/business-rules.js

@@ -53,4 +53,4 @@ function validate(root) {
   return errors
 }
 
-module.exports = { markdownFiles, validate }
+module.exports = { validate }

package/engine/planning/contracts.js

@@ -297,6 +297,14 @@ function validateState({ epics, milestones, done, wip, roles = new Set(), humanA
   for (const milestone of milestones) {
     if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(milestone.slug)) errors.push(`hito con slug inválido: ${milestone.slug}`)
     if (milestoneSlugs.has(milestone.slug)) errors.push(`hito duplicado: ${milestone.slug}`)
+    // La misma puerta que la épica y la tarea, en el nivel que no la tenía. Un hito agrupa trabajo bajo
+    // un nombre, y abrirlo con el nombre puesto para después es el camino natural: nadie promueve una
+    // tarea sin aceptación, y en cambio el título del hito se decide al final, cuando ya se construyó
+    // debajo. El marcador es lo único que se puede juzgar sin leer — un título vago sigue pasando, y
+    // eso es deliberado: acá también un heurístico sobre prosa se equivocaría en los dos sentidos.
+    if (PLACEHOLDERS.test(milestone.title)) {
+      errors.push(`hito ${milestone.slug}: el título no está decidido — "${milestone.title}"`)
+    }
     milestoneSlugs.add(milestone.slug)
     for (const task of milestone.tasks) {
       if (!task.service) errors.push(`BACKLOG ${task.slug}: falta (service: <ruta>)`)
@@ -406,7 +414,6 @@ function oversizedUnits({ epics = [], milestones = [] }) {
 }
 
 module.exports = {
-  testedCriteria,
   validateState,
   oversizedUnits,
   validateAdr,

package/engine/planning/parser.js

@@ -153,6 +153,12 @@ function readCast(rest) {
   }
 }
 
+// El texto de la aceptación, delimitado por las cursivas que lo envuelven. El cierre no es «el
+// próximo guión bajo»: un identificador como `MAX_ATTEMPTS` trae los suyos, y cortar en el primero
+// devolvía `MAX` con `check` en verde, que es la forma cara del error —la tarea se lee completa y no
+// lo está—. Cierra el `_` que markdown cerraría: el que no está entre caracteres de palabra.
+const ACCEPTANCE = /_Aceptaci[oó]n:\s*(.*?\S)_(?![A-Za-z0-9])/i
+
 function readBacklog(dir) {
   const text = withoutComments(read(path.join(dir, 'BACKLOG.md')))
   const milestones = []
@@ -175,7 +181,7 @@ function readBacklog(dir) {
       slug: task[1].trim(), tier: task[2] || '', cast: readCast(rest),
       epic: ((rest.match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
       service: ((rest.match(/\(service:\s*([^)]+)\)/) || [])[1] || '').trim(),
-      acceptance: ((rest.match(/_Aceptaci[oó]n:\s*([^_]+)_/i) || [])[1] || '').trim(),
+      acceptance: ((rest.match(ACCEPTANCE) || [])[1] || '').trim(),
       criteria: criteriaRefs(rest),
       noSplit: noSplitReason(rest),
     })