@ingeniomaps/cauce 0.38.0 → 0.40.0

package/CHANGELOG.md

@@ -14,6 +14,32 @@ 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.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
+
+- **`check` nombra las credenciales que nadie se llevó.** El arranque tiene que dejar una fila por cada
+  variable que el proyecto declara, y en cuatro corridas reales se cumplió en proporción a lo que se
+  habló: las que sólo estaban en el inventario quedaron afuera —entre ellas el broker por donde entran
+  los datos y el servicio al que se le mandan errores—. Ahora `check` nombra las que no aparecen ni en el
+  mapa ni en `HUMAN_ACTIONS.md`. Mira sólo cuando la instancia ya tiene contexto escrito, porque antes no
+  hay dónde tendrían que estar, y avisa en vez de fallar: una variable sin dueño no rompe nada hoy, rompe
+  el día que alguien tiene que desplegar.
+
 ## [0.38.0] - 2026-08-19
 
 ### Añadido

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

@@ -465,6 +465,31 @@ function seccionesPerdidas(root) {
   return avisos
 }
 
+// Credenciales que el proyecto declara y que no aparecen en ningún contrato. El arranque tiene que
+// dejar una fila por cada una —quién la carga y dónde— y en la práctica cubre las que se hablaron en la
+// conversación: las que sólo estaban en el inventario se pierden, y con ellas el servicio externo que
+// hay detrás. Una variable sin dueño no rompe nada hoy; rompe el día que alguien tiene que desplegar.
+//
+// Sólo cuando la instancia ya tiene contexto escrito: antes del arranque no hay dónde estuvieran.
+function credencialesSinDueño(root) {
+  if (OB.guide(root).fresh) return []
+  const contratos = ['AGENTS.md', path.join('planning', 'HUMAN_ACTIONS.md')]
+    .map((file) => { try { return fs.readFileSync(path.join(root, file), 'utf8') } catch { return '' } })
+    .join('\n')
+  if (!contratos) return []
+  const huerfanas = []
+  for (const service of inventory(root)) {
+    for (const nombre of (service.env || {}).names || []) {
+      if (!contratos.includes(nombre)) huerfanas.push(`${nombre} (${service.path})`)
+    }
+  }
+  if (!huerfanas.length) return []
+  const lista = huerfanas.length > 4
+    ? `${huerfanas.slice(0, 4).join(', ')} y ${huerfanas.length - 4} más`
+    : huerfanas.join(', ')
+  return [`el proyecto declara ${lista} y no aparecen en el mapa ni en HUMAN_ACTIONS: nadie las carga`]
+}
+
 function check(dir, cli) {
   const root = path.resolve(dir || '.')
   const errors = []
@@ -578,6 +603,7 @@ function check(dir, cli) {
   for (const entry of FK.drift(path.resolve(root, '..'))) warnings.push(FK.driftLine(entry))
 
   warnings.push(...seccionesPerdidas(path.resolve(root, '..')))
+  warnings.push(...credencialesSinDueño(path.resolve(root, '..')))
 
   if (cli.has('--json')) {
     console.log(JSON.stringify({

package/package.json

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