@ingeniomaps/cauce 0.47.0 → 0.49.0

package/CHANGELOG.md

@@ -14,6 +14,63 @@ 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.49.0] - 2026-08-26
+
+### Agregado
+
+- **`R22` — lo que se mide no se toca mientras se mide.** Mientras una medición corre, el sujeto y todo
+  aquello contra lo que resuelve se quedan quietos. Lo difícil es que no avisa: la corrida termina y su
+  resultado se lee igual que uno limpio, así que quien lo reciba decide sin saber que se movió el piso.
+  Y entra por donde no se mira — un banco desechable puede resolver la herramienta por un enlace al
+  repositorio vivo, así que editar ahí cambia lo que la corrida lee sin tocar el banco. Si hace falta
+  trabajar igual, se trabaja donde la medición no mira; y si ya pasó, se dice qué cambió y cuándo: un
+  resultado cuyo entorno se movió es una hipótesis, no un veredicto.
+
+### Corregido
+
+- **Un recorrido que frena da igual la salida que su contrato reserva para no poder.** `change-review`
+  enumera tres veredictos y el tercero es «no poder aprobar»; bloqueado, su informe parcial escribía
+  «No hay veredicto», que no es ninguno de los tres. Con el diff, los importadores y las pruebas a la
+  vista, un revisor **sí** puede firmar que no aprueba: eso es un veredicto, no su ausencia. Vale para
+  cualquier recorrido cuyo contrato tenga esa salida — un destino de «nada que hacer», una
+  recomendación de investigar.
+- **`dependsOn` dejó de ser decorativo: un recorrido corre sus etapas como su contrato las declara.**
+  Hasta ahora el motor las corría en fila y le pasaba a cada una los handoffs de **todas** las
+  anteriores, sin mirar de qué decía depender. `technical-design` existe para tener tres lecturas
+  independientes de un mismo encuadre y no las tenía: su propio guardrail dice que las tres «no negocian
+  entre sí ni ajustan su hallazgo para que cierre con el de otra», y una que ya leyó a la primera no
+  puede cumplirlo. Ahora las etapas se agrupan por nivel de dependencia, las de un mismo nivel corren a
+  la vez, y cada una ve **sólo** los handoffs de aquello de lo que declara depender. Cinco de los siete
+  recorridos del catálogo tienen un nivel con paralelismo real y lo estrenan con esto. Una etapa que
+  **no** declara `dependsOn` sigue viendo todo lo anterior, igual que antes: independencia es una
+  afirmación, y una afirmación se declara. Si una etapa no cumple su gate, el corte es por nivel — las
+  que corrieron con ella entran igual al handoff, y lo que se abandona son los niveles siguientes.
+- **Cambiar el `flow.json` de un recorrido ahora envejece sus veredictos.** El aviso de «el contrato
+  cambió y la última corrida es anterior» miraba sólo el `SKILL.md`, que un recorrido no tiene, así que
+  no se disparaba nunca: se le podía agregar una dimensión a un gate y sus casos aprobados seguían
+  leyéndose vigentes. Qué archivo **es** el contrato depende del sujeto — el de un cargo es su
+  `SKILL.md`, el de un recorrido su `flow.json`— y ahora se mira el que corresponde.
+## [0.49.0] - 2026-08-27
+
+### Corregido
+
+- **`ops context` ya no se traga las acciones humanas cuando no hay tarea en cola.** Se imprimían
+  después del `return` de «sin tarea disponible», así que una instancia recién arrancada —`onboard`
+  deja filas pendientes y ninguna tarea todavía— preguntaba qué toca ahora y recibía «nada», cuando lo
+  que tocaba era que una persona desbloqueara siete cosas. Lo destapó una corrida de un recorrido sobre
+  su banco.
+
+## [0.48.0] - 2026-08-26
+
+### Corregido
+
+- **`destroy` ya no deja el `package.json` que escribió `init`.** En modo `embedded` quitaba sus nueve
+  rutas y decía «tu repositorio queda donde está», dejando un manifiesto cuya única dependencia era el
+  motor. Sobre un repositorio Rust eso es basura conspicua y nadie avisaba. Ahora saca su clave y nada
+  más: si el manifiesto lo había creado `init` —sin dependencias ni scripts propios— se va con él, y si
+  es tuyo se conserva entero con tus scripts y tus dependencias. `node_modules/` y el lockfile no se
+  tocan porque los escribe npm y pueden tener lo tuyo, pero la salida ahora los nombra para que decidas.
+
 ## [0.47.0] - 2026-08-26
 
 ### Agregado

package/automatization/workflows/flow.js

@@ -206,16 +206,59 @@ const blocked = []
 // corre `autobuild`, y sólo después de que una persona promueva la épica al BACKLOG.
 const discovery = contract.stages.filter((stage) => stage.phase === 'discovery')
 if (!discovery.length) return stop('sin-descubrimiento', `${FLOW} no declara etapas de discovery`)
-for (const stage of discovery) {
-  const previous = handoffs.length
-    ? `Handoffs previos:\n${handoffs.map((entry) => `- ${entry.id}: ${entry.summary}`).join('\n')}`
-      + (openConditions(handoffs).length
+
+// Qué handoffs ve una etapa: los de aquello de lo que declara depender, y lo que aquéllos dependían.
+// No los de sus hermanas. Una etapa que **no** declara `dependsOn` depende de todo lo anterior, que es
+// como se comportaba esto antes: independencia es una afirmación y una afirmación se declara.
+function ancestors(stage, index) {
+  if (!stage.dependsOn) return discovery.slice(0, index).map((one) => one.id)
+  const out = new Set()
+  const pending = [...stage.dependsOn]
+  while (pending.length) {
+    const id = pending.pop()
+    if (out.has(id)) continue
+    out.add(id)
+    const found = discovery.find((one) => one.id === id)
+    const arriba = found && found.dependsOn ? found.dependsOn : []
+    for (const up of arriba) pending.push(up)
+  }
+  return [...out]
+}
+
+// Los niveles del grafo: cada uno son las etapas cuyas dependencias ya cerraron, y corren a la vez.
+// `technical-design` existe para tener tres lecturas independientes de un mismo encuadre, y corriéndolas
+// en fila con el handoff de la anterior adentro no las tiene: su propio guardrail dice que las tres «no
+// negocian entre sí ni ajustan su hallazgo para que cierre con el de otra», y una que ya leyó a la
+// primera no puede cumplirlo. Lo destapó una corrida: `interface` escribió «Coincido» sobre un supuesto
+// de `service` y armó su hallazgo principal sobre el K6 de `service`. El contrato lo declaraba desde el
+// principio en `dependsOn` y el motor lo ignoraba.
+function levels(stages) {
+  const out = []
+  const done = new Set()
+  let rest = stages.map((stage, index) => ({ stage, index, needs: ancestors(stage, index) }))
+  while (rest.length) {
+    const level = rest.filter((one) => one.needs.every((id) => done.has(id)))
+    // Una dependencia que no cierra nunca deja el resto afuera. No puede pasar —`flow check` rechaza
+    // una dependencia inexistente o posterior— pero un bucle que no avanza cuelga la corrida entera.
+    if (!level.length) { out.push(rest); break }
+    out.push(level)
+    for (const one of level) done.add(one.stage.id)
+    rest = rest.filter((one) => !level.includes(one))
+  }
+  return out
+}
+
+const runStage = (stage, index) => {
+  const visible = handoffs.filter((entry) => ancestors(stage, index).includes(entry.id))
+  const abiertas = openConditions(visible)
+  const previous = visible.length
+    ? `Handoffs previos:\n${visible.map((entry) => `- ${entry.id}: ${entry.summary}`).join('\n')}`
+      + (abiertas.length
         ? '\n\nCondiciones que dejaron las etapas anteriores y tenés que respetar:\n'
-          + openConditions(handoffs).map((one) => `- ${one}`).join('\n')
+          + abiertas.map((one) => `- ${one}`).join('\n')
         : '')
     : 'Sos la primera etapa: no hay handoff previo.'
-
-  const result = await agent(
+  return agent(
     `${RULES}\n\n${previous}\n\nActuá como ${stage.agent}, respetando su contrato en ` +
     `${stage.skill || `${WORKDIR}/agents/roles/${stage.agent}/SKILL.md`} y sus límites. ` +
     `Etapa "${stage.id}": producí ` +
@@ -235,16 +278,27 @@ for (const stage of discovery) {
     `En summary va, en 150 ` +
     `palabras o menos, lo que la etapa siguiente necesita para decidir —no un resumen de tu análisis, ` +
     `sino lo que le cambia el trabajo—, porque eso se le reenvía a cada etapa posterior.`,
-    { schema: STAGE, label: `stage:${stage.id}` },
-  )
-  if (!result) return stop('stage-unavailable', `la etapa ${stage.id} no devolvió resultado`)
+    { schema: STAGE, label: `stage:${stage.id}` })
+}
 
-  handoffs.push({ id: stage.id, agent: stage.agent, ...result })
-  if (result.gate === 'no-cumplido') {
-    blocked.push({ stage: stage.id, missing: result.missing || '', action: result.humanAction || '' })
-    log(`Gate no cumplido en ${stage.id}: ${result.missing || 'sin detalle'}`)
-    break
+// Nivel por nivel, y las de un mismo nivel a la vez. Si una de ellas no cumple su gate, el recorrido
+// para: las hermanas que corrieron con ella entran igual al handoff —su trabajo está hecho y pagado— y
+// lo que se abandona son los niveles siguientes.
+for (const level of levels(discovery)) {
+  const results = await parallel(level.map((one) =>
+    () => runStage(one.stage, one.index).then((result) => ({ stage: one.stage, result }))))
+  for (const one of results) {
+    if (!one || !one.result) return stop('stage-unavailable', 'una etapa del nivel no devolvió resultado')
+    handoffs.push({ id: one.stage.id, agent: one.stage.agent, ...one.result })
+  }
+  for (const one of results) {
+    if (one.result.gate !== 'no-cumplido') continue
+    blocked.push({
+      stage: one.stage.id, missing: one.result.missing || '', action: one.result.humanAction || '',
+    })
+    log(`Gate no cumplido en ${one.stage.id}: ${one.result.missing || 'sin detalle'}`)
   }
+  if (blocked.length) break
 }
 
 if (blocked.length) {
@@ -291,6 +345,11 @@ if (blocked.length) {
     `**entrega parcial** desde el título: qué quedó establecido y con qué evidencia, qué no se pudo ` +
     `y por qué, y qué haría falta para completarlo —"${blocked[0].missing}"—. No completes con ` +
     `supuestos lo que la etapa bloqueada iba a resolver: lo que falta se nombra, no se rellena.\n\n` +
+    `Y si el recorrido enumera una salida para «no se pudo» —un veredicto de no poder aprobar, un ` +
+    `destino de «nada que hacer», una recomendación de investigar—, ésa es la respuesta y hay que ` +
+    `darla. Frenar no exime de la salida que el contrato reserva justo para esto: «no hay veredicto» ` +
+    `no es ninguna de las que el contrato enumera, y quien pidió la revisión se queda sin la única que ` +
+    `sí podías firmar con lo que tenías.\n\n` +
     `Eso vale para lo que necesita el insumo que falta, y sólo para eso. Lo que el material que ya ` +
     `tenés alcanza para establecer se entrega acá, aunque en el recorrido completo lo hubiera ` +
     `producido una etapa posterior: esa etapa no va a correr, así que reservárselo no se lo guarda ` +

package/engine/agents/evaluations.js

@@ -125,8 +125,15 @@ function behaviors(root, agent, kind) {
 // La comparación es por día y no por instante porque el registro guarda fecha y no hora: un contrato
 // que cambia y se vuelve a medir el mismo día no dispara el aviso. Es el caso que menos importa
 // —quien lo cambió hoy sabe que lo cambió—, y afinar más pediría una hora que el registro no tiene.
-function contractChangedAt(dir) {
-  const git = spawnSync('git', ['-C', dir, 'log', '-1', '--format=%cs', '--', 'SKILL.md'], { encoding: 'utf8' })
+//
+// Y qué archivo **es** el contrato depende del sujeto: el de un cargo es su `SKILL.md` y el de un
+// recorrido es su `flow.json`. Mirando sólo el primero, un recorrido no disparaba el aviso nunca —no
+// tiene `SKILL.md`— así que se le podía agregar una dimensión al gate y sus veredictos anteriores
+// seguían leyéndose vigentes. Pasó el mismo día que esto se escribió: `change-review` ganó la pregunta
+// por las superficies críticas y sus tres casos aprobados no dijeron una palabra.
+function contractChangedAt(dir, kind) {
+  const file = kind === 'flow' ? 'flow.json' : 'SKILL.md'
+  const git = spawnSync('git', ['-C', dir, 'log', '-1', '--format=%cs', '--', file], { encoding: 'utf8' })
   return git.status === 0 ? (git.stdout || '').trim() : ''
 }
 
@@ -255,7 +262,7 @@ function validate(root, agent, kind) {
   if (state.failed.length) {
     warnings.push(`${state.failed.length} caso(s) no pasan: ${state.failed.join(', ')}`)
   }
-  const cambio = contractChangedAt(subject(root, agent, kind))
+  const cambio = contractChangedAt(subject(root, agent, kind), kind)
   if (cambio && cambio > state.oldest) {
     const parte = state.oldest === state.newest ? 'la última corrida es' : 'el veredicto más viejo es'
     warnings.push(`el contrato cambió el ${cambio} y ${parte} del ${state.oldest}: `

package/engine/cli/instance.js

@@ -82,6 +82,34 @@ function declareEngine(manifest, version) {
   F.atomicWriteJson(manifest, pkg)
 }
 
+// La inversa exacta de `declareEngine`: saca la clave que puso y nada más. El resto del manifiesto es
+// del repo anfitrión aunque hoy no tenga otra cosa —un `package.json` vacío puede ser lo que alguien
+// escribió para tener scripts— así que el archivo se borra sólo si es idéntico al que `declareEngine`
+// habría creado desde cero, sin dependencias, sin scripts y con su `version: 0.0.0`.
+//
+// Lo que no se toca nunca es `node_modules/` ni el lockfile: los escribe npm, pueden tener dependencias
+// del proyecto y borrarlos por nuestra cuenta destruye trabajo ajeno. Se nombran en la salida, que es
+// la mitad que faltaba: `destroy` decía «tu repositorio queda donde está» y dejaba un `package.json`
+// cuya única dependencia era Cauce. En un repo Rust eso es basura conspicua y nadie avisaba.
+function undeclareEngine(manifest) {
+  if (!fs.existsSync(manifest)) return []
+  let pkg
+  try { pkg = JSON.parse(fs.readFileSync(manifest, 'utf8')) } catch { return [] }
+  const dev = pkg.devDependencies || {}
+  if (!('@ingeniomaps/cauce' in dev)) return []
+  delete dev['@ingeniomaps/cauce']
+  pkg.devDependencies = dev
+  const generado = !Object.keys(dev).length && !Object.keys(pkg.dependencies || {}).length
+    && !Object.keys(pkg.scripts || {}).length && pkg.private === true && pkg.version === '0.0.0'
+  if (generado) {
+    fs.rmSync(manifest, { force: true })
+    return ['package.json (lo había creado init: sin dependencias ni scripts propios)']
+  }
+  if (!Object.keys(dev).length) delete pkg.devDependencies
+  F.atomicWriteJson(manifest, pkg)
+  return ['package.json: se quitó la dependencia del motor y el resto queda como estaba']
+}
+
 // Proveedores que el toolkit conoce, para saltearlos al copiar la plantilla: su andamiaje
 // —configuración, staging/, proposed/— no se materializa hasta que alguien lo habilite. Antes cada
 
@@ -212,6 +240,13 @@ function destroy(dir, cli) {
     ]
     for (const relative of ownPath) fs.rmSync(path.join(root, relative), { recursive: true, force: true })
     console.log(`✓ ${ownPath.length} ruta(s) de Cauce quitadas de ${root}`)
+    for (const line of undeclareEngine(path.join(root, 'package.json'))) console.log(`✓ ${line}`)
+    const npm = ['node_modules', 'package-lock.json']
+      .filter((one) => fs.existsSync(path.join(root, one)))
+    if (npm.length) {
+      console.log(`  queda ${npm.join(' y ')}: lo escribe npm y puede tener lo tuyo. Borralo vos si el`)
+      console.log('  repositorio no usaba npm antes de instalar Cauce.')
+    }
     return console.log('  tu repositorio queda donde está: en modo embedded la instancia era él mismo.')
   }
   const inside = process.cwd() === root || process.cwd().startsWith(`${root}${path.sep}`)

package/engine/cli/planning.js

@@ -205,7 +205,15 @@ function context(dir, cli) {
     const row = humanActions.find((action) => skipped.includes(action.task)) || humanActions[0]
     return console.log(`BLOCKED  blocked-on-human — ${row.task}: ${row.action}`)
   }
-  if (!report.task) return console.log('TASK   (sin tarea disponible)')
+  // Sin tarea no se corta la salida: las acciones humanas van igual. Estaban después del `return`, así
+  // que una instancia recién arrancada —`onboard` deja filas pendientes y ninguna tarea todavía—
+  // respondía «sin tarea disponible» y se tragaba las siete cosas que una persona tenía que desbloquear.
+  // Es el comando que existe para decir qué toca ahora, contestando «nada» cuando lo que toca es eso.
+  if (!report.task) {
+    console.log('TASK   (sin tarea disponible)')
+    for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
+    return
+  }
   console.log(`TASK   ${report.task.slug}${report.task.tier ? ` [${report.task.tier}]` : ''}` +
     `${report.task.service ? `  service: ${report.task.service}` : ''}` +
     `${report.task.hito ? `  hito: ${report.task.hito}` : ''}`)

package/flows/system/change-review/evaluations/cases/05-el-cambio-chico/cambio-formato-fecha-PR-934.md

@@ -36,10 +36,7 @@ Test Suites: 1 passed, 1 total
 
 `format.ts` no tiene test propio. `order-payload.ts` tampoco. Los seis que pasaron son del listado.
 
-## De la instancia — organization/company.md, «Qué no se puede romper»
+## Lo que no consta en este documento
 
-| Superficie | Qué se detiene si falla | A quién alcanza | Dónde vive |
-|---|---|---|---|
-| Alta de pedido | No entra ninguna venta | Todos los compradores | `src/checkout/` |
-| Acceso a la plataforma | Nadie puede entrar | Todos los usuarios | `src/auth/` |
-| Listado y reportes | Nadie consulta lo ya vendido | Operación interna | `src/pages/orders/`, `src/reports/` |
+Si alguna de estas rutas está declarada como crítica, no lo dice el PR: eso vive en la instancia, en
+`organization/company.md`. Quien revise tiene que ir a mirarlo — acá no está.

package/flows/system/change-review/evaluations/cases/05-el-cambio-chico.md

@@ -10,7 +10,9 @@ Te dejo el diff y el contexto de la instancia.
 
 - Notar que el helper que se toca no lo usa sólo el listado: lo importan también el resumen del pedido
   y el componente que arma el cuerpo de la orden antes de enviarla.
-- Nombrar qué se detiene si eso falla, con lo que la empresa ya declaró, en vez de estimarlo.
+- Ir a buscar a la instancia si alguna de esas rutas está declarada como crítica, en vez de estimarlo
+  desde el documento del PR o darlo por sabido. Si la declaración está sin llenar, decirlo: no saberlo
+  no es lo mismo que no serlo.
 - Decir qué verificación pide un cambio de una línea cuando cae donde cae, y qué de eso no se hizo:
   los tests que pasaron son los del listado.
 - Cerrar con uno de los tres veredictos, sin confundir «el diff es chico» con «el riesgo es chico».

package/package.json

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

package/template/planning/rules/README.md

@@ -2,8 +2,8 @@
 
 `system/` pertenece a Cauce y se reemplaza completo en cada actualización:
 
-- `system/process.md` — R1..R4, R16, R17, R20, R21: planificación, alcance, review, sincronización de estado,
-  medición y retomar lo interrumpido.
+- `system/process.md` — R1..R4, R16, R17, R20..R22: planificación, alcance, review, sincronización de
+  estado, medición y retomar lo interrumpido.
 - `system/code-shape.md` — R5..R7, R11, R18: simplicidad y forma del cambio.
 - `system/commits.md` — R8..R10: historia versionada y entrega.
 - `system/conduct.md` — R12..R15, R19: trato con sistemas externos, lo que llega de ellos, y la

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

@@ -155,3 +155,24 @@ aparecieron, cuánto se gastó. La sesión que originó esta regla creyó estar
 volvió a correr entero dos veces: siete millones de tokens para un solo veredicto, con los archivos de
 las etapas ya cumplidas a la vista en el directorio de trabajo, y con el filtro que lo evitaba escrito
 por quien reanudaba tres horas antes.
+
+## R22 — Lo que se mide no se toca mientras se mide
+
+Mientras una medición corre, el sujeto y todo aquello contra lo que resuelve se quedan quietos. No se
+edita el contrato que se está midiendo, ni el motor que la corrida usa, ni el entorno del que lee.
+
+Lo que lo vuelve difícil de ver es que no avisa. La corrida termina, entrega su resultado y **ese
+resultado se lee exactamente igual que uno limpio**: no hay señal que diga «esto midió dos versiones».
+Quien lo reciba va a decidir sobre él sin saber que se movió el piso.
+
+Y el camino por el que entra casi nunca es el archivo obvio. Un banco desechable puede resolver la
+herramienta por un enlace al repositorio vivo, así que editar ahí cambia lo que la corrida lee sin que
+nada del banco se haya tocado. La pregunta no es «¿toqué el sujeto?» sino «¿toqué algo que el sujeto
+alcanza?».
+
+Si hace falta trabajar igual, se trabaja donde la medición no mira: otra copia, otra rama sin
+materializar, o se espera. Esperar es más barato que descubrir que la tanda no vale.
+
+Y si ya pasó, se dice: qué medición, qué cambió y cuándo. Un resultado cuyo entorno se movió es una
+hipótesis, no un veredicto —lo mismo que R21 nombra para lo que quedó a medias—, y guardarlo sin esa
+marca es la forma cara del error, porque el número sobrevive a la sesión que sabía.