@ingeniomaps/cauce 0.39.0 → 0.41.0

package/CHANGELOG.md

@@ -14,6 +14,31 @@ desde este repositorio no va, porque el que lee no puede actuar sobre eso. Cuand
 unas pocas líneas casi siempre es porque cuenta cómo se descubrió el problema o por qué se eligió el
 diseño — eso vive en el commit y en el código.
 
+## [0.41.0] - 2026-08-19
+
+### Corregido
+
+- **`destroy` ya no borra el repositorio en modo embebido.** Ahí la instancia **es** el repositorio, así
+  que borrar la carpeta se llevaba el código del producto: pasó de verdad sobre un caso de prueba, y el
+  aviso previo enumeraba épicas y acciones humanas sin nombrar lo único irrecuperable. En embebido saca
+  lo que Cauce escribió —`planning/`, `organization/`, `teams/`, `integrations/`, `automatization/`,
+  `tools/`, la configuración y el manifiesto— y deja el repositorio. En sidecar sigue borrando la
+  carpeta, que ahí no contiene nada más.
+
+## [0.40.0] - 2026-08-19
+
+### Corregido
+
+- **En modo embebido, Codex se quedaba sin instrucciones.** `AGENTS.md` es el único nombre que el runner
+  y la instancia comparten, y ahí `install` conservaba el archivo entero —lo correcto para algo del
+  proyecto—, así que el recorrido que ese runner tenía que seguir nunca llegaba a estar escrito. Ahora su
+  contenido se fusiona adentro, entre marcas: reinstalar reemplaza el bloque en vez de duplicarlo,
+  desinstalar lo saca sin llevarse el archivo, y todo lo que la empresa escribió alrededor queda intacto.
+
+  `doctor` lo tenía al revés en ese archivo: comparando el hash completo avisaba cuando el bloque estaba
+  bien —el texto de la empresa alrededor difiere siempre— y decía «operativo» cuando alguien lo había
+  borrado, que es la falla que importa.
+
 ## [0.39.0] - 2026-08-19
 
 ### Corregido

package/engine/automation/index.js

@@ -438,6 +438,19 @@ function doctor(root, name, output = console) {
   }
   for (const item of runner.instructions || []) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
+    // El archivo compartido no se compara entero: alrededor del bloque vive el texto de la empresa, así
+    // que su hash difiere siempre. Comparado como archivo, `doctor` avisaba cuando el bloque estaba bien
+    // y callaba cuando alguien lo había borrado, que es exactamente al revés.
+    if (esArchivoCompartido(root, resolved.target)) {
+      const contenido = render(resolved.source, opsPrefix(root))
+      if (!fs.existsSync(resolved.target)) errors.push(`falta ${item.target}`)
+      else if (!fs.readFileSync(resolved.target, 'utf8').includes(bloqueInicio(name))) {
+        errors.push(`${item.target}: no tiene las instrucciones de Cauce; reinstalá el adaptador`)
+      } else if (!bloqueAlDia(resolved.target, name, contenido)) {
+        warnings.push(`${item.target}: su bloque de Cauce quedó viejo; reinstalá el adaptador`)
+      }
+      continue
+    }
     // `AGENTS.md` es un nombre compartido entre herramientas y la instancia ya tiene el suyo: en
     // modo embedded el archivo del runner y el de la empresa son el mismo, y pedirle que se
     // referencie a sí mismo no significa nada.
@@ -585,6 +598,16 @@ function uninstall(root, name, output = console) {
     const resolved = { item, ...resolveItem(paths, root, name, item) }
     const key = deliveryKey(name, item.target)
     if (!fs.existsSync(resolved.target)) { delete entregado[key]; continue }
+    if (esArchivoCompartido(root, resolved.target)) {
+      const texto = fs.readFileSync(resolved.target, 'utf8')
+      const limpio = sinBloque(texto, name)
+      if (limpio !== texto.trimEnd()) {
+        F.atomicWrite(resolved.target, `${limpio}\n`)
+        quitados += 1
+      }
+      delete entregado[key]
+      continue
+    }
     const situacion = deliveryState(recorded, name, resolved, prefix)
     if (situacion === 'ajeno') { conservados.push(item.target); continue }
     removeFile(resolved.target, paths.install)
@@ -623,6 +646,41 @@ function uninstall(root, name, output = console) {
   return { removed: quitados, kept: conservados }
 }
 
+// `AGENTS.md` es el único nombre que el runner y la instancia comparten: en modo embebido el archivo de
+// instrucciones de Codex es el mismo que el de la empresa. Conservarlo entero —lo correcto para un
+// archivo del proyecto— dejaba a ese runner sin una sola línea de Cauce, así que su contenido se
+// fusiona adentro, entre marcas, y todo lo demás del archivo queda intacto.
+const bloqueInicio = (name) => `<!-- cauce:${name} inicio — lo reescribe "automation install", no editar -->`
+const bloqueFin = (name) => `<!-- cauce:${name} fin -->`
+
+function esArchivoCompartido(root, target) {
+  return path.resolve(target) === path.resolve(root, 'AGENTS.md')
+}
+
+function sinBloque(text, name) {
+  const desde = text.indexOf(bloqueInicio(name))
+  if (desde === -1) return text
+  const hasta = text.indexOf(bloqueFin(name), desde)
+  if (hasta === -1) return text
+  return `${text.slice(0, desde)}${text.slice(hasta + bloqueFin(name).length)}`.trimEnd()
+}
+
+function fusionarInstruccion(file, name, contenido) {
+  const actual = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : ''
+  const cuerpo = sinBloque(actual, name).trimEnd()
+  const bloque = `${bloqueInicio(name)}\n\n${contenido.trim()}\n\n${bloqueFin(name)}\n`
+  F.atomicWrite(file, cuerpo ? `${cuerpo}\n\n${bloque}` : bloque)
+}
+
+function bloqueAlDia(file, name, contenido) {
+  if (!fs.existsSync(file)) return false
+  const texto = fs.readFileSync(file, 'utf8')
+  const desde = texto.indexOf(bloqueInicio(name))
+  const hasta = texto.indexOf(bloqueFin(name))
+  if (desde === -1 || hasta === -1) return false
+  return texto.slice(desde + bloqueInicio(name).length, hasta).trim() === contenido.trim()
+}
+
 function install(root, name, output = console, options = {}) {
   // `install` arma la superficie de consumo de una empresa: punteros a cada cargo, una copia de los
   // workflows y los guards. Acá los cargos y los workflows son el producto —la copia divergiría— y
@@ -677,6 +735,17 @@ function install(root, name, output = console, options = {}) {
   for (const resolved of resolvedItems) {
     const situacion = state.get(resolved)
     const propio = runner.instructions.includes(resolved.item)
+    if (propio && esArchivoCompartido(root, resolved.target)) {
+      const contenido = render(resolved.source, opsPrefix(root))
+      if (bloqueAlDia(resolved.target, name, contenido)) {
+        output.log(`= ${name}: ${resolved.item.target} ya trae sus instrucciones`)
+      } else {
+        fusionarInstruccion(resolved.target, name, contenido)
+        output.log(`✓ ${name}: sus instrucciones quedaron dentro de ${resolved.item.target}`)
+      }
+      entregado[deliveryKey(name, resolved.item.target)] = M.digest(resolved.target)
+      continue
+    }
     if (situacion === 'ajeno' && propio) {
       output.log(`= ${name}: conservado ${resolved.item.target} (tiene cambios tuyos)`)
     } else if (situacion === 'al día') {

package/engine/cli/ops.js

@@ -831,13 +831,19 @@ function destroy(dir, cli) {
     perdida.contexto && 'el contexto escrito en organization/',
   ].filter(Boolean)
 
+  const embebido = O.mode(root) === 'embedded'
   if (!cli.has('--force')) {
-    console.log(`Borrar ${root} se lleva:`)
+    console.log(embebido
+      ? `Sacar Cauce de ${root} se lleva:`
+      : `Borrar ${root} se lleva:`)
     for (const linea of lineas) console.log(`  − ${linea}`)
     if (!lineas.length) console.log('  − nada escrito todavía: la instancia está como salió de init')
     if (perdida.runners.length) {
       console.log(`  y saca el wiring de: ${perdida.runners.join(', ')} (lo tuyo queda donde está)`)
     }
+    if (embebido) {
+      console.log('  el código del repositorio no se toca: en modo embebido la instancia es él mismo.')
+    }
     console.log('\nNada de esto lo repone un init. Si es lo que querés: repetí con --force.')
     process.exit(1)
   }
@@ -847,6 +853,17 @@ function destroy(dir, cli) {
   }
   // El orden no es negociable: primero el wiring, después la carpeta. Al revés, cada llamada de
   // herramienta del runner queda ejecutando un guard que ya no está.
+  // En modo embebido la instancia **es** el repositorio: borrar la carpeta se lleva el código del
+  // producto, que Cauce nunca escribió y no repone nadie. Ahí se saca lo del toolkit y se deja el repo.
+  if (O.mode(root) === 'embedded') {
+    const suyo = [
+      'planning', 'organization', 'teams', 'integrations', 'automatization', 'tools',
+      'ops.config.json', '.cauce', 'AGENTS.md',
+    ]
+    for (const relative of suyo) fs.rmSync(path.join(root, relative), { recursive: true, force: true })
+    console.log(`✓ ${suyo.length} ruta(s) de Cauce quitadas de ${root}`)
+    return console.log('  tu repositorio queda donde está: en modo embebido la instancia era él mismo.')
+  }
   const adentro = process.cwd() === root || process.cwd().startsWith(`${root}${path.sep}`)
   fs.rmSync(root, { recursive: true, force: true })
   console.log(`✓ ${root} borrado`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",