@ingeniomaps/cauce 0.67.0 → 0.68.0

package/CHANGELOG.md

@@ -14,6 +14,36 @@ 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.68.0] - 2026-09-07
+
+### Cambiado
+
+- **`upgrade` deja de borrar una ruta retirada cuyo contenido no puede probar suyo.** Retirar una ruta
+  nunca volvió al toolkit dueño de lo que hay adentro, y hasta acá se borraba el directorio entero: quien
+  tenía sus propios workflows en `automatization/workflows` los perdía sin confirmación y sin vuelta
+  atrás. De las seis rutas retiradas, cuatro viven bajo `system/` o son un archivo con nombre del
+  toolkit y se siguen retirando igual; las dos que un proyecto también usa para lo suyo
+  —`automatization/runners` y `automatization/workflows`— se conservan.
+
+  **Lo que te pide algo**: esas dos rutas quedan en disco con lo que tengas adentro, la corrida te dice
+  cuántos archivos son, y `check` las cuenta en cada corrida hasta que las muevas o las borres. Si lo
+  que tenés ahí son restos viejos del toolkit y querés limpiarlos, `--force` las retira.
+
+- **La regla R9 dice cómo se prueba una quita.** Una prueba que comprueba que aparece lo nuevo no
+  comprueba que desapareció lo viejo, y lo que se quita tiene dependientes que no se anuncian —el
+  mensaje que afirmaba la invariante, la condición que la deducía—. Sale de una regresión de 0.67.0 que
+  entró exactamente por ahí.
+
+### Corregido
+
+- **El informe de `upgrade` afirmaba descartes que no ocurrieron.** 0.67.0 pasó a conservar los archivos
+  editados y la salida siguió enumerándolos como `− descartado tu cambio en …`, uno por uno, después de
+  la línea que anuncia que terminó bien. En una instancia real fueron diecinueve renglones falsos, y
+  entre ellos iba la única línea destructiva verdadera de esa corrida, indistinguible. Ahora el informe
+  recibe qué pasó —descartado, conservado, pendiente— en vez de deducirlo de una condición que dejó de
+  valer, y la línea «planning, organization y todo lo propio quedaron intactos» sale justo cuando es
+  cierto, que es cuando se conservó algo.
+
 ## [0.67.0] - 2026-09-07
 
 ### Agregado

package/engine/cli/instance.js

@@ -370,10 +370,19 @@ function upgrade(dir, cli) {
 
   // Retirar lo que el toolkit ya no distribuye, después de haber actualizado lo que sí.
   const retired = []
+  const pendientes = []
   for (const relative of O.RETIRED) {
     const target = path.join(root, relative)
     if (!fs.existsSync(target)) continue
     F.assertNoSymlinkPath(root, target)
+    // Retirar una ruta no vuelve al toolkit dueño de lo que hay adentro. En las dos que un proyecto
+    // también usa para lo suyo, borrar el directorio entero se llevaba puesto contenido que nadie
+    // había entregado —un `autobuild.js` propio, los workflows de una empresa— sin confirmación y sin
+    // vuelta atrás. Se conserva y se nombra; `--force` es la salida, igual que para una edición local.
+    const contenido = O.RETIRED_COMPARTIDO.includes(relative) && fs.statSync(target).isDirectory()
+      ? O.treeFiles(target)
+      : []
+    if (contenido.length && !force) { pendientes.push({ relative, files: contenido }); continue }
     fs.rmSync(target, { recursive: true, force: true })
     retired.push(relative)
   }
@@ -404,7 +413,13 @@ function upgrade(dir, cli) {
   // Acá es donde las tres versiones se saben a la vez, así que es donde pueden quedar diciendo lo mismo.
   const pinned = pinEngine(root, to)
 
-  reportUpgrade({ root, from, to, system, changed, retired, added, overrides, pinned, droppedBlocks })
+  // El informe recibe qué pasó y no una condición de la que deducirlo: `changed` es «lo que estaba
+  // editado», y sin `--force` eso se conserva. Deducirlo hizo que 0.67.0 afirmara diecinueve descartes
+  // que no ocurrieron (caso 048).
+  reportUpgrade({
+    root, from, to, system, retired, added, overrides, pinned, droppedBlocks,
+    descartados: force ? changed : [], conservados: [...conservados], pendientes,
+  })
 }
 
 module.exports = { copyTemplate, scaffold, providerNames, upgrade, destroy, PROJECT_ROOT }

package/engine/cli/planning.js

@@ -144,6 +144,15 @@ function check(dir, cli) {
       + '`upgrade` los conserva y no les trae mejoras')
   }
 
+  // Y lo que `upgrade` no retiró porque no pudo demostrar que fuera suyo: queda ahí, sin colgar de
+  // ningún mecanismo, hasta que alguien lo mueva o lo borre. Se cuenta por lo mismo que los congelados
+  // — un resto que no se ve se vuelve permanente.
+  const restos = O.RETIRED_COMPARTIDO.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
+  if (restos.length) {
+    warnings.push(`${restos.length} ruta(s) retiradas siguen en disco con contenido tuyo `
+      + `(${restos.join(', ')}); Cauce ya no las distribuye ni las toca`)
+  }
+
   const integration = I.validate(path.resolve(root, '..'))
   errors.push(...integration.errors)
   warnings.push(...integration.warnings)

package/engine/cli/upgrade-report.js

@@ -72,12 +72,23 @@ function adviceFor(changed) {
 // propias, agentes editados— queda intacto por construcción, no por comparación.
 // Qué le pasó a la instancia en esta actualización, contado a quien la corrió. Recibe el resultado
 // entero en vez de recalcular nada: lo que se informa es exactamente lo que ocurrió.
-function reportUpgrade({ root, from, to, system, changed, retired, added, overrides, pinned, droppedBlocks }) {
+function reportUpgrade({
+  root, from, to, system, retired, added, overrides, pinned, droppedBlocks,
+  descartados, conservados, pendientes,
+}) {
   console.log(`✓ Cauce ${from || '(previa)'} → ${to}`)
   // Descartar con --force es legítimo; hacerlo sin dejar rastro no. Queda en la salida del comando,
-  // que es la evidencia que el protocolo pide para cualquier cambio.
-  for (const file of changed) console.log(`− descartado tu cambio en ${file}`)
+  // que es la evidencia que el protocolo pide para cualquier cambio. Y lo que se conservó no se vuelve
+  // a enumerar acá: ya salió con su consejo antes de escribir nada, y repetirlo con el glifo del
+  // descarte es lo que volvía ilegible el bloque.
+  for (const file of descartados) console.log(`− descartado tu cambio en ${file}`)
+  if (conservados.length) console.log(`= ${conservados.length} archivo(s) conservados por tu edición`)
   for (const relative of retired) console.log(`− retirado ${relative}: Cauce ya no lo distribuye`)
+  // Sin glifo de acción porque no hubo ninguna: la ruta sigue ahí y el contenido también.
+  for (const { relative, files } of pendientes) {
+    console.log(`  ${relative}: ${files.length} archivo(s) que Cauce no entregó; la ruta se retiró y `
+      + 'el contenido queda. Movelo adonde lo quieras y borrala, o repetí con --force.')
+  }
   // Nombrarlos importa tanto como crearlos: existen para que los completes, y uno que aparece sin
   // aviso no lo completa nadie.
   for (const relative of added) console.log(`+ ${relative}: lo agrega esta versión, completalo`)
@@ -90,9 +101,9 @@ function reportUpgrade({ root, from, to, system, changed, retired, added, overri
   for (const override of overrides) {
     console.log(`= conservado ${override.collection}/${override.project}: sobrescribe ${override.system}`)
   }
-  // Sólo cuando es cierto: llegar acá con algo en `changed` es haber descartado contenido de la
-  // empresa con --force, que las líneas de arriba enumeran.
-  if (!changed.length) console.log('  planning, organization y todo lo propio quedaron intactos')
+  // Sólo cuando es cierto, y ahora lo decide lo que pasó y no una condición: se dice justo cuando no
+  // se descartó nada, que incluye la corrida que conservó veinte archivos.
+  if (!descartados.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/core/ownership.js

@@ -231,6 +231,14 @@ const RETIRED = [
 
 // Aprendizaje que quedó dentro de una ruta retirada. Es lo único ahí que no se puede reponer, así
 // que se detecta antes de borrar nada: perderlo en silencio sería peor que dejar el directorio.
+// De las rutas retiradas, las que un proyecto también usa para lo suyo. El resto de la lista vive bajo
+// `system/` o es un archivo con nombre propio del toolkit, y ahí nadie más escribe; éstas dos se llaman
+// como el concepto general, así que quien adoptó Cauce cuando se distribuían tiene los suyos justo ahí.
+//
+// El manifiesto no las puede desempatar: `trackedPaths()` nunca las registró, así que para el toolkit
+// todo su contenido es igual de ajeno. Sin poder demostrar que lo entregó, no lo borra.
+const RETIRED_COMPARTIDO = ['automatization/runners', 'automatization/workflows']
+
 function retiredWithLearning(root) {
   const found = []
   for (const relative of RETIRED) {
@@ -294,6 +302,7 @@ function localChanges(root) {
 
 module.exports = {
   RETIRED,
+  RETIRED_COMPARTIDO,
   TEMPLATE_OWN,
   TEMPLATE_PREFIXES,
   addedPaths,

package/package.json

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

package/template/planning/rules/system/commits.md

@@ -31,6 +31,18 @@ y la cobertura no lo va a decir: mide qué líneas se ejecutan, no qué defectos
 La precondición del caso también cuenta. Si el estado en que arranca no puede ocurrir por el camino de
 producción, lo que prueba tampoco: queda verde para siempre sobre algo que nadie va a vivir.
 
+**Y quitar un comportamiento se prueba al revés que agregarlo.** Una prueba que comprueba que aparece lo
+nuevo no comprueba que desapareció lo viejo: los dos pueden convivir, y ahí el verde dice que la mitad
+del cambio ocurrió. La aserción que hace falta es de ausencia —que la salida vieja ya no esté, que la
+rama vieja ya no corra—, y es la que no se escribe sola porque nadie la extraña.
+
+Lo que se quita, además, tiene dependientes, y no se anuncian. Una invariante que deja de valer se lleva
+puesto a quien la daba por cierta: el mensaje que la afirmaba, la condición que la deducía, el comentario
+que la explicaba. Suelen vivir en otro archivo, que es donde una premisa vieja se pudre sin que nada
+falle. Antes de entregar una quita se busca quién dependía de ella —qué la afirmaba, qué la deducía— y
+cada uno se corrige o se declara. Recorrer la enumeración de la tarea no encuentra esto: la enumeración
+dice qué había que hacer, no qué se apoyaba en lo que había.
+
 ## R10 — Publicación humana por defecto
 
 Push, PR, merge, tags, deploy y rollback requieren la autorización configurada para el proyecto.