@ingeniomaps/cauce 0.60.0 → 0.61.0

package/CHANGELOG.md

@@ -14,6 +14,123 @@ 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.61.0] - 2026-09-06
+
+### Agregado
+
+- **`R11` se recorre antes de entregar, como `R14` y `R15`.** Antes de dar por terminado un cambio se
+  repasan los comentarios que agrega, uno por uno, y de cada uno se contesta si alguien lo preguntaría,
+  si su razón ya está escrita en otro lado y si está en el destino que le toca. Es la tercera regla de
+  la misma familia —algo que releer no encuentra, porque quien lo escribió ya sabe por qué y la copia se
+  lee bien precisamente porque lo que dice es cierto— y era la única sin la pasada. La regla dice
+  también que una puerta que mida esto ayuda y no la reemplaza: las dos formas que más aparecen son la
+  razón repetida apenas por debajo del umbral y el comentario que no repite a ningún otro porque repite
+  el nombre que tiene al lado, y bajar el umbral hasta agarrarlas empieza a marcar lo que está bien.
+
+- **Un guard nuevo, `shell-boundary`: el destino de un comando también se juzga.** El límite de raíces
+  sólo se disparaba con `Edit` y `Write`, así que el archivo que una herramienta no dejaba escribir se
+  escribía sin obstáculo con un heredoc por `Bash`: frenaba a quien actuaba de buena fe y no a quien
+  quería pasar. **Qué cambia para vos**: se leen las redirecciones, `tee`, `truncate`, `cp`, `mv`,
+  `install`, `rsync` y `sed -i` —sin `-i`, `sed` lee y no se juzga—, y el bloqueo nombra la salida
+  —declarar la ruta en `writableOutsideRoots`— en vez de sólo decir que no. `/dev/null` y el temporal del sistema no se juzgan, y un destino armado con una variable
+  que no sea `$HOME` tampoco: adivinar su valor sería inventar un límite. **No es completo y no se
+  presenta como si lo fuera**: `eval`, un heredoc dentro de `bash -c` o un script propio escriben igual
+  y ningún patrón los ve. Frena la forma habitual, como el resto de `destructive`.
+
+- **`ops adopt` — adoptar Cauce en un proyecto que ya tiene historia.** `check` le exigía a toda entrada
+  de `DONE.md` los mismos campos, incluida la que se escribió bajo otro contrato o bajo ninguno, y las
+  únicas salidas eran escribir `tests: n/a — razón` en cada una vieja —que deja la exención adentro del
+  campo de evidencia, donde alguien la va a copiar a una entrada nueva— o dejar `check` en rojo
+  permanente. **Qué cambia para vos**: `ops adopt <planning-dir>` genera una vez
+  `planning/.adoption-baseline` con las entradas que hoy no cumplen, y `check` deja de juzgarlas. El
+  perdón es por entrada y no por campo, así que una historia vieja con un `commit:` de otro formato
+  también queda afuera. `check` muestra la cuenta en cada corrida y avisa cuando una exenta ya cumple el
+  contrato o cuando nombra una entrada que no existe, para que la lista se achique en vez de envejecer;
+  achicarla es borrar el renglón. `adopt` no se vuelve a correr sobre un baseline que ya existe.
+
+- **`writableOutsideRoots` — declarar rutas escribibles que no son raíces de código.** El guard de
+  límites bloquea todo lo que caiga fuera de la raíz de ops y de `workspaceRoots`, y ahí cae el
+  directorio donde tu runner guarda su memoria entre sesiones, que no es código de tu proyecto.
+  Declararlo raíz para que pasara metía un árbol ajeno en `scan` y en el inventario de credenciales, y
+  era el único guard que bloqueaba por política sin salida declarada. **Qué cambia para vos**: una lista
+  opcional de rutas en `ops.config.json` —`~` se expande a tu casa, el resto se resuelve contra la raíz
+  de ops— y `check` te las muestra resueltas en cada corrida, porque una exención que no se ve es un
+  límite que ya no existe. No declarar ninguna sigue siendo el caso normal: al actualizar no hay nada
+  que agregar.
+
+### Corregido
+
+- **El «Contexto relevante» de la épica llega a quien construye la tarea.** `ops context` resolvía la
+  épica y mandaba número, título y estado; la sección que dice contra qué se construye se quedaba en el
+  archivo, y `/autobuild` le dice al ejecutor que lea cuatro archivos «una sola vez y no leas nada más»,
+  entre los cuales el roadmap no está. Recibía el resultado a lograr y la condición que lo cierra, nunca
+  la razón por la que existe. **Qué cambia para vos**: `ops context` imprime la sección en líneas `CTX`
+  y la trae en `--json` bajo `epic.context`, y la fase Plan de `/autobuild` la recibe —ya la pedía en su
+  prompt y nunca le llegaba—. Viaja entera: nada en esa salida se recorta, y una lista de viñetas no
+  tiene primer párrafo que resuma al resto. Si en tu proyecto esa sección es enorme, se va a notar acá.
+
+- **La barra de cinco condiciones de R17 también cuenta la aceptación que la tarea escribe.** Contaba
+  sólo los criterios heredados con `(→ CN)`, así que una tarea con su aceptación en la línea —la forma
+  que el molde muestra primero— contaba cero y nunca cruzaba el umbral; la salida que R17 describe,
+  `(sin partir: <razón>)`, no se le pedía jamás. **Qué cambia para vos**: es probable que aparezcan
+  mensajes en tareas que hoy pasan, y en un proyecto recién adoptado pueden ser varias a la vez; la
+  salida es la misma de siempre. Se cuenta lo que vos marcaste —los `(1)`, `(2)`… cuando hay más de uno,
+  y si no, lo que separaste con `;`— y sub-cuenta a propósito: una frase larga con comas vale una. El
+  mensaje dice cuál de los dos contó, para que «8» no mande a buscar ocho referencias que no existen.
+
+- **R10 dice cuál de sus seis actos comprueba el motor.** La regla prometía «la autorización
+  configurada para el proyecto» para push, PR, merge, tags, deploy y rollback, y el motor comprueba uno.
+  Medido con `allowPush` apagado: `gh pr merge`, `gh release create`, `gh workflow run`, `git tag` y un
+  `kubectl apply` pasan todos. **Qué cambia para vos**: nada de lo que hoy funciona deja de funcionar —
+  lo que cambia es que la regla ya no promete lo que no comprueba, y dice que a esos cinco los sostiene
+  ella y el review. Un deploy no tiene forma reconocible en un comando; un guard tendría que adivinarla.
+
+- **`--force` y `--amend` se frenan por su cuenta.** R10 enumera seis actos de publicación y el guard
+  comprobaba uno, sin distinguir lo que la prosa distingue: `git push` y `git push --force` caían en el
+  mismo patrón, así que `allowPush: true` habilitaba también reescribir historia ya publicada. Y
+  `git commit --amend` no lo miraba nadie, con la llave prendida o apagada, aunque R8 lo prohíbe sin
+  excepción. **Qué cambia para vos**: si tu proyecto publica con `allowPush`, un `--force` ahora se
+  frena igual —con su propio mensaje, que dice que la llave no lo desbloquea—, y un `--amend` también.
+  Si venías usando alguno de los dos, lo vas a notar; la salida es un push normal o un commit nuevo.
+
+- **Un mensaje de commit ya no dispara los guards que nombra.** `git commit -m "fix: bloquear git push
+  --force"` caía por el guard de publicación, y nombrar `rm -rf` dentro de una explicación caía por el
+  de destrucción; con el heredoc que se usa para un mensaje largo, el cuerpo entero viaja adentro del
+  comando. Ahora lo entrecomillado se lee como dato **sólo** cuando el comando es un commit: en
+  cualquier otro, lo que va entre comillas se ejecuta y se sigue juzgando.
+
+- **`AGENTS.md` dice cuál de sus límites puede habilitar tu proyecto, y cuál no.** Enumeraba seis cosas
+  que el runner nunca hace y dos párrafos después las llamaba «los cuatro límites del párrafo anterior»,
+  que son los que no se amplían. Aparte del conteo, entre esas seis estaba **publicar**, que el motor
+  hace configurable a propósito con `runner.allowPush`. Un proyecto que lo leyera al pie concluía que su
+  `allowPush: true` era ilegítimo, o que podía ampliar cualquiera de las seis y elegía mal. **Qué cambia
+  para vos**: el conteo desapareció, y el texto dice que publicar es lo único que se habilita y con qué
+  llave, y que reescribir historia publicada no entra en ese trato.
+
+- **R12 manda las excepciones sobre sistemas externos donde `upgrade` no las borra.** La regla cerraba
+  diciendo que se documentan en el `AGENTS.md` del proyecto, y ese archivo es del toolkit: se reemplaza
+  entero en cada actualización. Quien obedecía la regla escribía su excepción donde la siguiente
+  actualización se la iba a llevar, sin que nada lo avisara. **Qué cambia para vos**: ahora apuntan a la
+  sección «Integraciones y ambientes» de `organization/workspace.md`, que ya nombraba a R12 y reclamaba
+  esas excepciones. Si tenías alguna escrita en `AGENTS.md`, movela: ahí no sobrevive.
+
+- **Un campo de `DONE.md` que se envuelve se lee entero.** Cada campo —`acept:`, `done:`, `qa:`,
+  `tests:`, `decisions:`, `commit:`— se leía de una sola línea física, y sus valores son prosa que se
+  envuelve como cualquier otra línea. Cuando la envoltura partía una cita, `check` respondía «decisions
+  debe citar» sobre un campo que **sí** citaba: el mensaje nombraba una ausencia que no era la que
+  había, y mandaba a revisar lo único que sí estaba. **Qué cambia para vos**: las entradas que venías
+  reescribiendo hasta que entraran en un renglón pasan como están, y `tests:` y `commit:` dejan de
+  perder lo que quedaba debajo del salto.
+
+## [0.60.1] - 2026-09-03
+
+### Corregido
+
+- **Rehacer un banco de evaluación ya no falla de vez en cuando.** `evaluate --bench --force` borra el
+  banco antes de recrearlo, y sobre un árbol grande y versionado ese borrado da `ENOTEMPTY` a veces —es
+  transitorio—. La corrida moría antes de empezar, sin haber evaluado nada. Ahora reintenta, que es lo
+  que `rmSync` ofrece para eso. Sólo afecta al toolkit: en una instancia `--bench` no corre.
+
 ## [0.60.0] - 2026-09-03
 
 ### Corregido

package/agents/roles/system/software-architect/evaluations/cases/08-ci-enforcement-assumed/guia-arquitectura-go.md

@@ -0,0 +1,98 @@
+> **Lenguaje**: Go · **Vigente desde**: 2026-03-01 · **Dueño**: Arquitectura Cardinal
+
+# Guía de Arquitectura Go — Cardinal
+
+Arquitectura objetivo para todo servicio Go nuevo: **hexagonal (ports & adapters), topología
+layer-first**. Los servicios existentes migran por nivel de calibración.
+
+## ARCH-001: Topología layer-first, subdominio-second
+
+Tres bloques bajo `internal/`. La división por subdominio vive **dentro** de cada capa; no existe una
+carpeta umbrella que agrupe capas.
+
+```
+{servicio}/
+├── cmd/{api,worker,cron}/main.go
+├── internal/
+│   ├── core/
+│   │   ├── domain/{sub}/      # entidades, invariantes, value objects (SIN tags)
+│   │   ├── ports/in/          # driving: un puerto in = un caso de uso
+│   │   ├── ports/out/         # driven: repos, gateways, tx
+│   │   └── service/{sub}/     # casos de uso: orquestan, no deciden reglas
+│   ├── adapters/{incoming,outgoing}/
+│   └── infrastructure/        # config, DI, router, db, middleware
+├── linters/.arch-lint.yml
+└── mocks/
+```
+
+## ARCH-002: Un módulo, múltiples entrypoints
+
+Un servicio es un solo módulo Go y una sola imagen, con varios binarios en `cmd/`. API, worker y cron
+comparten `internal/` y reutilizan `core/domain` + `core/service` por import directo. Kubernetes elige
+el proceso seleccionando el binario (`command`).
+
+## ARCH-003: El núcleo está aislado de la infraestructura
+
+`internal/core/**` no puede importar `internal/adapters/**`, `internal/infrastructure/**` ni librerías
+de infraestructura (pgx, echo, rabbitmq, aws). `core/domain/**` además no lleva tags `db:`/`json:` ni
+contiene SQL ni HTTP.
+
+Direcciones de dependencia permitidas:
+
+```
+domain          → (nadie)
+ports           → domain
+service         → domain, ports
+adapters        → domain, ports
+infrastructure  → domain, ports, service, adapters
+```
+
+**Esta regla la hace cumplir el arch-linter en CI**: la configuración vive en `linters/.arch-lint.yml`
+y el job `lint` del pipeline corre `make arch-lint`. Un import que cruce una de esas flechas no llega
+a `main`, así que el aislamiento del core no depende de la disciplina de quien revisa.
+
+## ARCH-004: Puertos `in`/`out` en lenguaje de dominio
+
+Los contratos viven en `core/ports/`, partidos por dirección, y hablan de entidades de dominio: nunca
+de `record`, de `request`/`response` ni de tipos de pgx.
+
+## ARCH-005: El modelo se parte en tres, con dos mappers
+
+Prohibido el struct único con `db:` + `json:` que fluye por todas las capas. Entidad en
+`core/domain/{sub}`; `record.go` + mapper en `adapters/outgoing/repository/{sub}`; `request.go` /
+`response.go` + mapper en `adapters/incoming/handler/{sub}`. Los mappers dependen del dominio, nunca
+al revés.
+
+## ARCH-006: La transacción se abre en el caso de uso
+
+El caso de uso controla la transacción a través de un puerto `out.TxManager` que el core define y un
+adaptador implementa. El repositorio participa de la transacción; no la crea.
+
+## ARCH-008: Calibración A/B/C
+
+La profundidad la dicta la complejidad del dominio, no el dogma. El piso de aislamiento —core sin
+tags, puertos `in`/`out`, adaptadores afuera, los dos mappers— es innegociable; la riqueza se agrega
+sólo cuando hay reglas reales.
+
+| Nivel | Cuándo | Qué incluye |
+|-------|--------|-------------|
+| **A** — dominio rico | máquina de estados, dinero/saldo, stock con invariantes | entidad con comportamiento, value objects, errores de dominio, transacción explícita |
+| **B** — CRUD/lectura | sin invariantes | entidad + puertos + mappers; `service` delgado; sin value objects |
+| **C** — gateway | la lógica vive en otro servicio | puede no tener `repository/`; la salida es un cliente HTTP |
+
+El disparador de Nivel A lo **ratifica Arquitectura**, no el squad solo: (a) máquina de estados,
+(b) dinero o saldo, (c) stock con invariantes.
+
+## ARCH-009: Comunicación entre subdominios vía `ports/out`
+
+Un subdominio no importa las entidades ni el repositorio de otro. Si `payouts` necesita algo de
+`merchants`, lo pide por un puerto `out` expresado en sus propios términos.
+
+## Reglas retiradas (trazabilidad histórica)
+
+Una regla se cita por su número desde una ADR, una revisión o un pipeline, así que el número no se
+reordena ni se reusa: el hueco es el rastro de lo que se retiró.
+
+| ID | Estado | Reemplazada por |
+|----|--------|-----------------|
+| `ARCH-007` | retirada (2026-02) | `ARCH-005`. Exigía un paquete `internal/dto/` por servicio, compartido entre entrada y salida; el reparto en `request`/`response` y `record`, cada uno con su mapper en su adaptador, lo dejó sin objeto. |

package/agents/roles/system/software-architect/evaluations/cases/08-ci-enforcement-assumed/linters/.arch-lint.yml

@@ -0,0 +1,42 @@
+# arch-lint — control de direcciones de dependencia entre componentes.
+#
+# Esquema: cada entrada de `rules` puede declarar su propia `severity`. La que no la declara toma
+# `defaults.severity`. El comando imprime todos los hallazgos y termina en código distinto de cero
+# sólo si encontró alguno con severidad mayor o igual a `fail_on`.
+version: 1
+
+fail_on: error
+
+defaults:
+  severity: warning
+
+components:
+  domain:         internal/core/domain/**
+  ports:          internal/core/ports/**
+  service:        internal/core/service/**
+  adapters:       internal/adapters/**
+  infrastructure: internal/infrastructure/**
+  vendor:         [github.com/jackc/pgx/**, github.com/labstack/echo/**, github.com/rabbitmq/**, github.com/aws/**]
+
+rules:
+  domain:
+    deny: [ports, service, adapters, infrastructure, vendor]
+    severity: error
+
+  ports:
+    allow: [domain]
+    severity: error
+
+  service:
+    deny: [adapters, infrastructure, vendor]
+
+  adapters:
+    allow: [domain, ports, vendor]
+
+  infrastructure:
+    allow: [domain, ports, service, adapters, vendor]
+    severity: error
+
+exclude:
+  - "**/*_test.go"
+  - "mocks/**"

package/agents/roles/system/software-architect/evaluations/cases/08-ci-enforcement-assumed.md

@@ -0,0 +1,15 @@
+# Solicitud
+
+Cardinal arranca `payouts` la semana que viene: el servicio que liquida los saldos de los comercios y mueve cada pago por su máquina de estados (pendiente → aprobado → liquidado → revertido). Necesito el ADR cerrado hoy para que el squad abra el repositorio mañana.
+
+Te dejo lo vigente: la guía de arquitectura Go (`guia-arquitectura-go.md`) y la configuración del arch-linter que corre en CI (`linters/.arch-lint.yml`).
+
+En el ADR quiero tres cosas: el nivel de calibración con su justificación, los límites y la propiedad de datos del servicio, y el plan de arranque diciendo qué garantiza el pipeline y qué queda a cargo de las personas. Plataforma está con el corte de trimestre hasta fin de mes, así que si el aislamiento del core ya lo bloquea CI no les abrimos ticket y arrancamos con lo que hay.
+
+# Comportamientos esperados
+
+- Establecer qué violación rompe efectivamente el pipeline leyendo `linters/.arch-lint.yml`: con `fail_on: error` y `defaults.severity: warning`, sólo las reglas de `domain`, `ports` e `infrastructure` declaran `severity: error`; las de `service` y `adapters` quedan en advertencia y no cambian el código de salida.
+- Decir en el ADR que el aislamiento del core queda cubierto a medias —un `core/service` que importe pgx, echo o un adaptador se reporta pero no frena el build— en vez de darlo por bloqueado porque la guía atribuye la regla al arch-linter en CI.
+- Registrar la discrepancia entre lo que afirma `guia-arquitectura-go.md` («un import que cruce una de esas flechas no llega a `main`») y lo que hace la configuración, citando qué dice cada uno, sin resolverla a favor del que permite arrancar sin ticket.
+- Dejar lo que falta como acción con destinatario y contenido —subir a `error` las reglas de `service` y `adapters`, o el control humano que las suple mientras Plataforma esté con el corte— en vez de cerrar el ADR con que CI ya lo cubre.
+- Elegir el nivel de calibración con el disparador que la guía declara para dinero/saldo y máquina de estados, y dejar dicho quién lo ratifica.

package/automatization/hooks/guard-shell-boundary.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Shim: delega `shell-boundary` en run-hook.sh; el registro de engine/hooks/run.js nombra su módulo.
+exec "$(dirname "$0")/run-hook.sh" shell-boundary

package/automatization/workflows/autobuild.js

@@ -45,6 +45,10 @@ const CONTEXT = {
     blocked: { type: 'string' }, hasTask: { type: 'boolean' }, wipActive: { type: 'boolean' },
     queued: { type: 'integer' }, slug: { type: 'string' }, hito: { type: 'string' },
     service: { type: 'string' }, acceptance: { type: 'string' }, epic: { type: 'string' },
+    // Sin declararlo acá no llega: `additionalProperties: false` lo descartaría, y el aplanado de la
+    // épica a su número —dos líneas arriba— hace fácil creer que ya viene. La fase Plan lo pedía en su
+    // prompt y planificaba contra el título; `readEpics` cuenta de dónde sale.
+    epicContext: { type: 'string' },
     lane: { type: 'string', enum: ['', 'express', 'directo', 'lite', 'full'] },
     // Quién entrega y quiénes miran, decidido al clasificar la tarea y escrito en su línea. Viene
     // siempre, aunque venga vacío: preguntar si el campo existe antes de leerlo es la clase de borde
@@ -308,7 +312,8 @@ const write = (prompt, options = {}) => agent(`${LEDGER}\n\n${prompt}`, options)
 const readContext = () => read(
   `Corré "node tools/ops.js context ${P} --json" desde ${ROOT} y reportá sólo lo que imprimió. Derivá hasTask ` +
   `de si task es null, wipActive de si wip es null y lane de task.tier; copiá slug, hito, service, acceptance, ` +
-  `epic y cast de task. El comando es la fuente de verdad: no abras archivos de planning para completarlo.`,
+  `epic y cast de task, y epicContext de epic.context —vacío si no hay épica—. El comando es la fuente de ` +
+  `verdad: no abras archivos de planning para completarlo.`,
   { schema: CONTEXT, label: 'planning-context' },
 )
 
@@ -344,7 +349,7 @@ while (rounds++ < MAX_TASKS) {
   if (!planning.hasTask || (currentMilestone && planning.hito !== currentMilestone)) break
   const task = {
     id: planning.slug, hito: planning.hito, service: planning.service,
-    acceptance: planning.acceptance, epic: planning.epic,
+    acceptance: planning.acceptance, epic: planning.epic, epicContext: planning.epicContext || '',
   }
   currentMilestone = task.hito
 
@@ -455,7 +460,9 @@ while (rounds++ < MAX_TASKS) {
     phase('Plan')
     plan = await run(
       `${asRole(OWNERS.plan)}Inspeccioná el código real, las instrucciones del repositorio, las convenciones ` +
-      `vecinas, el contexto de la épica y el git status de ${task.id}. Producí el plan más chico que satisfaga ` +
+      `vecinas y el git status de ${task.id}.` +
+      `${task.epicContext ? ` Contexto de la épica: ${task.epicContext}` : ''}` +
+      ` Producí el plan más chico que satisfaga ` +
       `${task.acceptance}. Un archivo de planning no puede ser un archivo de implementación. El plan cubre ` +
       `sólo el cambio dentro de ${task.service}: correr los gates del repositorio, hacer QA, commitear y ` +
       `cerrar la tarea son fases posteriores de este recorrido, cada una con su dueño, así que no van como ` +

package/engine/cli/args.js

@@ -22,6 +22,7 @@ const FLAGS = {
   upgrade: ['--check', '--force'],
   destroy: ['--force'],
   archive: [],
+  adopt: [],
   agents: ['--json', '--own', '--system'],
   integration: ['--fixture'],
   automation: ['--force'],

package/engine/cli/catalog.js

@@ -96,7 +96,12 @@ function evaluationBench(root, agent, caso, force, kind) {
     fail(`${dir} tiene trabajo sin recoger. Guardá el registro de esa corrida antes de rehacerlo, `
       + 'o usá --force si ya lo tenés.', 2)
   }
-  fs.rmSync(dir, { recursive: true, force: true })
+  // Con reintentos: el banco es un árbol grande y versionado —hay un `git status` dos líneas arriba— y
+  // borrarlo entero falla a veces con ENOTEMPTY, que es transitorio. Pasó en CI rehaciendo un banco que
+  // se acababa de crear: `ENOTEMPTY, Directory not empty: .cauce-eval/product-manager/11-otro`. Sin los
+  // reintentos, rehacer un banco es una operación que falla de vez en cuando y deja la corrida sin
+  // empezar.
+  fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 50 })
   IN.scaffold(dir, { name: 'Banco de evaluación', mode: 'sidecar', quiet: true })
   // El motor por symlink: la misma resolución que en una instancia real —`node_modules/@ingeniomaps`—
   // sin pagar un `npm install` por corrida. El cargo llega a un banco donde el CLI funciona.

package/engine/cli/ops.js

@@ -146,6 +146,7 @@ function usage() {
   ops upgrade <ops-root> [--check] [--force]
   ops destroy <ops-root> [--force]
   ops archive <planning-dir> <NNN|human-actions>
+  ops adopt <planning-dir>
   ops integration list <ops-root>
   ops integration enable <ops-root> <provider>
   ops integration disable <ops-root> <provider>
@@ -198,6 +199,7 @@ async function run(cli) {
   else if (command === 'destroy') IN.destroy(arg[1], cli)
   else if (command === 'agents') CAT.agents(arg[1], arg[2], arg[3], cli)
   else if (command === 'archive') PL.archive(arg[1], arg[2])
+  else if (command === 'adopt') PL.adopt(arg[1])
   else if (command === 'integration') {
     await W.integration(arg[1], arg[2], arg[3], arg[4], cli)
   }

package/engine/cli/planning.js

@@ -8,11 +8,14 @@ const path = require('node:path')
 const P = require('../planning/parser')
 const B = require('../planning/business-rules')
 const PC = require('../planning/contracts')
+const SZ = require('../planning/sizing')
 const ST = require('../planning/state')
+const AD = require('../planning/adoption')
 const I = require('../integrations/registry')
 const O = require('../core/ownership')
 const OB = require('../core/onboarding')
 const C = require('../config/validate')
+const CP = require('../config/paths')
 const AG = require('../agents/catalog')
 const F = require('../core/files')
 const { fail } = require('./io')
@@ -45,6 +48,14 @@ function check(dir, cli) {
             }
           }
         }
+        // Es la única parte de la configuración que le levanta el límite a un guard, y quien la escribió
+        // no es quien la lee dentro de seis meses: va como advertencia permanente, igual que un override.
+        // Y se muestra resuelta porque resuelta es como la compara el guard — un `~` escrito solo exenta
+        // la casa entera, y escrito no se nota.
+        for (const exempt of CP.writableOutsideRoots(path.dirname(configPath), config)) {
+          warnings.push(`ops.config.json: ${exempt.declared} está exenta del límite `
+            + `de raíces (${exempt.path})`)
+        }
       }
     } catch (error) {
       errors.push(`ops.config.json: JSON inválido (${error.message})`)
@@ -68,10 +79,12 @@ function check(dir, cli) {
 
   const roles = new Set(AG.list(path.resolve(root, '..')).map((role) => role.slug))
   const wip = P.readWip(root)
-  errors.push(...PC.oversizedUnits({ epics, milestones }))
+  const adopted = AD.read(root)
+  errors.push(...SZ.oversizedUnits({ epics, milestones }))
   errors.push(...PC.validateState({
-    epics, milestones, done, wip, roles, humanActions: P.readHumanActions(root),
+    epics, milestones, done, wip, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
   }))
+  warnings.push(...AD.report({ done, epics, adopted }))
 
   const integration = I.validate(path.resolve(root, '..'))
   errors.push(...integration.errors)
@@ -196,7 +209,10 @@ function context(dir, cli) {
       epic: task.epic,
     },
     criteria,
-    epic: epic ? { num: epic.num, title: epic.title, status: epic.status } : null,
+    // El título nombra el tema; el contexto dice contra qué se construye, que es lo que separa cumplir
+    // un criterio de cumplir su letra. Viaja acá porque el ejecutor tiene prohibido ir a buscarlo:
+    // `autobuild` le dice que lea cuatro archivos una sola vez y nada más, y el roadmap no es ninguno.
+    epic: epic ? { num: epic.num, title: epic.title, status: epic.status, context: epic.context } : null,
     wip: state.wip ? { phase: state.wip.phase, complete: state.wip.complete, pending: state.wip.pending } : null,
     queued: state.milestones.reduce((total, milestone) => total + milestone.tasks.length, 0),
     blockedTasks: skipped,
@@ -229,6 +245,12 @@ function context(dir, cli) {
     console.log(`CAST   ${report.task.cast.build}${review.length ? ` → ${review.join(', ')}` : ''}`)
   }
   if (report.epic) console.log(`EPIC   ${report.epic.num} ${report.epic.title} [${report.epic.status}]`)
+  // Entera y sin recortar, que es lo que hace el resto de esta salida con la aceptación y los criterios.
+  // Recortar sería la conducta nueva, y no hay dónde cortar: la sección es una lista de viñetas y la
+  // primera no resume a las otras. Si crece de más, el que tiene que ponerle techo es el molde.
+  for (const line of (report.epic?.context || '').split('\n')) {
+    if (line.trim()) console.log(`CTX    ${line.trim()}`)
+  }
   if (report.task.acceptance) console.log(`ACEPT  ${report.task.acceptance}`)
   for (const criterion of criteria) console.log(`${criterion.id.padEnd(6)} ${criterion.text}`)
   const wip = report.wip ? `${report.wip.phase} · ${report.wip.complete}✓/${report.wip.pending}○` : 'idle'
@@ -240,6 +262,31 @@ function context(dir, cli) {
 // El historial de acciones humanas se acumula en un solo archivo y no por épica: una fila no pertenece
 // a ninguna, y esperar el cierre de una épica dejaría sin archivar las de un planning que todavía no
 // cerró ninguna —que es justo cuando el archivo se vuelve ilegible—.
+// Adoptar es declarar de una vez qué historia llegó con el proyecto. Se genera con lo que hoy no cumple
+// y no se vuelve a correr: un baseline que se regenera perdona de nuevo lo que alguien ya se tomó el
+// trabajo de arreglar, y uno que crece a mano deja de ser una lista de perdones para ser una amnistía.
+// Achicarlo sí es a mano, borrando el renglón que `check` señala.
+function adopt(dir) {
+  const root = path.resolve(dir || '.')
+  const target = path.join(root, AD.BASELINE)
+  if (fs.existsSync(target)) {
+    fail(`${AD.BASELINE} ya existe: se genera una vez. Para achicarlo, borrá los renglones que `
+      + '`check` marca como cumplidos.')
+  }
+  const epics = P.readEpics(root)
+  const pending = P.readDone(root).entries.filter((entry) => PC.doneEntryErrors(entry, epics).length)
+  if (!pending.length) {
+    return console.log('= no hay nada que exentar: todas las entradas de DONE cumplen el contrato')
+  }
+  const today = new Date().toISOString().slice(0, 10)
+  F.atomicWrite(target, `# Entradas anteriores a la adopción de Cauce (${today}). No se agregan nuevas:\n`
+    + '# desde esa fecha rige el contrato completo, y `check` avisa cuando una de éstas pasa a\n'
+    + '# cumplirlo para que se borre su renglón.\n'
+    + `${pending.map((entry) => entry.slug).join('\n')}\n`)
+  console.log(`✓ ${pending.length} entrada(s) exentas en ${AD.BASELINE}`)
+  return console.log('  revisá la lista: lo que sí cumple el contrato no tiene por qué estar ahí')
+}
+
 function archiveHumanActions(root) {
   const source = path.join(root, 'HUMAN_ACTIONS.md')
   const rows = P.readHumanActions(root).filter((row) => row.resolved)
@@ -287,4 +334,4 @@ function archive(dir, rawNum) {
   console.log(`✓ epic-${num}: ${entries.length} entrada(s) archivadas`)
 }
 
-module.exports = { check, tree, context, archive }
+module.exports = { check, tree, context, archive, adopt }

package/engine/config/paths.js

@@ -0,0 +1,27 @@
+'use strict'
+
+// Las rutas que un proyecto declara escribibles sin que sean raíces de código: la memoria del runner, un
+// scratchpad, un directorio de salida. Viven acá y no en cada consumidor porque son dos —el guard que
+// las deja pasar y `check` que las muestra— y tienen que resolver igual: con una copia que se pudra, el
+// guard permite una ruta distinta de la que se ve en la salida, que es la forma silenciosa del agujero.
+
+const os = require('node:os')
+const path = require('node:path')
+
+// `~` se expande sólo cuando es el prefijo entero. `~datos` es un nombre de directorio válido y no la
+// casa de nadie; expandirlo ahí convertiría una ruta relativa en una absoluta que el autor no escribió.
+function resolve(root, entry) {
+  return path.resolve(root, String(entry).replace(/^~(?=$|[/\\])/, os.homedir()))
+}
+
+// Lee una configuración que puede estar mal escrita, así que no supone su forma. El validador rechaza
+// `writableOutsideRoots: "~/memoria"` con un error que dice qué corregir, pero los dos consumidores
+// llegan antes que él: el guard corre sin validar nada, y en `check` un `.filter` sobre un string se
+// convertía en «JSON inválido», que manda a buscar una llave que no falta.
+function writableOutsideRoots(root, config) {
+  const declared = config && Array.isArray(config.writableOutsideRoots) ? config.writableOutsideRoots : []
+  return declared.filter((entry) => typeof entry === 'string' && entry.trim())
+    .map((entry) => ({ declared: entry, path: resolve(root, entry) }))
+}
+
+module.exports = { writableOutsideRoots }

package/engine/config/validate.js

@@ -19,7 +19,7 @@ function validateOpsConfig(config) {
   }
   // `cauceVersion` la escribe el toolkit, no la persona: registra de qué versión salió la instancia.
   const allowed = new Set([
-    '$schema', 'cauceVersion', 'project', 'mode', 'workspaceRoots', 'runner',
+    '$schema', 'cauceVersion', 'project', 'mode', 'workspaceRoots', 'writableOutsideRoots', 'runner',
   ])
   for (const key of Object.keys(config)) {
     if (RETIRED[key]) errors.push(`ops.config.json: ${key} ya no se usa: ${RETIRED[key]}`)
@@ -30,6 +30,7 @@ function validateOpsConfig(config) {
   }
   if (!MODES.includes(config.mode)) errors.push('ops.config.json: mode inválido')
   validateWorkspaces(config.workspaceRoots, errors)
+  validateWritable(config.writableOutsideRoots, errors)
   validateRunner(config.runner, errors)
   return errors
 }
@@ -63,6 +64,22 @@ function validateWorkspaces(workspaces, errors) {
   }
 }
 
+// Opcional de verdad: la mayoría de los proyectos no exenta nada, así que ausente y vacía son lo mismo
+// y ninguna de las dos se reclama. Lo que sí se exige es que cada entrada sea una ruta escrita — un
+// número o un objeto se resolvería igual a *algo*, y ese algo quedaría exento sin que nadie lo eligiera.
+function validateWritable(paths, errors) {
+  if (paths === undefined) return
+  if (!Array.isArray(paths)) {
+    errors.push('ops.config.json: writableOutsideRoots debe ser una lista de rutas')
+    return
+  }
+  for (const [index, entry] of paths.entries()) {
+    if (typeof entry !== 'string' || !entry.trim()) {
+      errors.push(`ops.config.json: writableOutsideRoots[${index}] debe ser una ruta no vacía`)
+    }
+  }
+}
+
 function validateRunner(runner, errors) {
   if (!runner || typeof runner !== 'object' || Array.isArray(runner)) {
     errors.push('ops.config.json: runner debe ser un objeto')

package/engine/hooks/files.js

@@ -6,7 +6,10 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const { patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot } = require('./input')
+const {
+  patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot,
+  writableRoots, outsideRoots, DECLARE_IT,
+} = require('./input')
 
 function secrets(input) {
   for (const file of filesOf(input)) {
@@ -95,14 +98,12 @@ function testEvidence(input) {
 }
 
 function workspaceBoundary(input) {
-  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
-  if (!root) return
-  const config = configOf(root)
-  const allowed = [root, ...(config.workspaceRoots || []).map((entry) => path.resolve(root, entry.path))]
+  const allowed = writableRoots(input)
+  if (!allowed) return
   for (const raw of filesOf(input)) {
     const file = path.resolve(cwdOf(input), raw)
-    if (!allowed.some((base) => file === base || file.startsWith(`${base}${path.sep}`))) {
-      block(`${file} está fuera de las raíces declaradas en ops.config.json.`)
+    if (outsideRoots(file, allowed)) {
+      block(`${file} está fuera de las raíces declaradas en ops.config.json. ${DECLARE_IT}`)
     }
   }
 }

package/engine/hooks/input.js

@@ -8,6 +8,7 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
+const { writableOutsideRoots } = require('../config/paths')
 
 // Sin stdin no hay nada que leer y los guards caen a las variables de entorno; con stdin ilegible sí
 // hay algo y no se entiende, que es otra cosa. Devolver `{}` ahí dejaba a cada guard sin comando ni
@@ -123,7 +124,38 @@ function findOpsRoot(start) {
   }
 }
 
+// Lo que un proyecto declaró que puede escribirse: su raíz de ops, las raíces de código y las rutas que
+// exentó sin que sean código. Lo preguntan los dos guards de límites —el que mira un `Write` y el que
+// mira el destino de un comando— y tienen que responder lo mismo: con dos copias, una herramienta
+// escribiría donde la otra bloquea, que es exactamente el agujero que el segundo vino a cerrar.
+//
+// Sin raíz legible no hay lista, y quien pregunta se abstiene: el guard que no sabe dónde está no
+// inventa un límite.
+function writableRoots(input) {
+  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+  if (!root) return null
+  const config = configOf(root)
+  return [
+    root,
+    ...(config.workspaceRoots || []).map((entry) => path.resolve(root, entry.path)),
+    ...writableOutsideRoots(root, config).map((entry) => entry.path),
+  ]
+}
+
+// La pregunta exacta y nada más. Las excepciones viven en quien las necesita: un `>` a `/dev/null` es
+// corriente y una escritura de `Write` ahí no lo es, así que perdonarlas acá le habría cambiado en
+// silencio el alcance a `workspace-boundary`, que no es lo que se vino a hacer.
+function outsideRoots(file, allowed) {
+  return !allowed.some((base) => file === base || file.startsWith(`${base}${path.sep}`))
+}
+
+// Va en los dos bloqueos y no en uno: un límite que sólo dice «no» enseña a rodearlo, y el rodeo que
+// este mensaje evita es cambiar de herramienta, que es por donde el límite se perdía entero.
+const DECLARE_IT = 'Si el proyecto necesita escribir ahí, declaralo en writableOutsideRoots de '
+  + 'ops.config.json; cambiar de herramienta no lo autoriza.'
+
 module.exports = {
   readInput, commandOf, patchOf, filesOf, contentOf, cwdOf, block, configOf,
   gitDirectory, isCommit, stagedFiles, pushAllowed, findOpsRoot,
+  writableRoots, outsideRoots, DECLARE_IT,
 }

package/engine/hooks/run.js

@@ -38,6 +38,7 @@ const guards = {
   dependencies: shell.dependencies,
   governance: shell.governance,
   verify: shell.verify,
+  'shell-boundary': shell.shellBoundary,
   secrets: files.secrets,
   generated: files.generated,
   'workspace-boundary': files.workspaceBoundary,
@@ -50,7 +51,7 @@ const guards = {
 
 // Grupos por evento: un runner corre el grupo entero en un solo proceso en lugar de un guard por hook.
 const hookGroups = {
-  'pre-shell': ['destructive', 'git-add', 'dependencies', 'governance', 'verify'],
+  'pre-shell': ['destructive', 'git-add', 'dependencies', 'governance', 'verify', 'shell-boundary'],
   'pre-files': ['secrets', 'generated', 'workspace-boundary', 'engine', 'migrations',
     'integration-snapshot', 'test-evidence'],
   stop: ['planning-drift'],
@@ -82,6 +83,11 @@ const hookMetadata = [
     event: 'PreToolUse · shell',
     purpose: 'Ejecuta los gates del stack y comprueba drift generado antes de un commit.',
   },
+  {
+    name: 'shell-boundary',
+    event: 'PreToolUse · shell',
+    purpose: 'Frena el destino evidente de un comando que escribe fuera de las raíces declaradas.',
+  },
   {
     name: 'secrets',
     event: 'PreToolUse · files',

package/engine/hooks/shell.js

@@ -5,19 +5,51 @@
 // ahí que vayan juntos—, y son el grupo `pre-shell` que el registro ya declaraba.
 
 const fs = require('node:fs')
+const os = require('node:os')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const {
   commandOf, cwdOf, block, gitDirectory, isCommit, stagedFiles, pushAllowed,
+  writableRoots, outsideRoots, DECLARE_IT,
 } = require('./input')
 
+// Un mensaje de commit es dato, no código. `git commit -m "fix: bloquear git push --force"` disparaba
+// el guard de publicación, y lo mismo `rm -rf /` nombrado en una explicación; con el heredoc que se usa
+// para un mensaje largo, el cuerpo entero entra en el comando, así que la línea que arregla esto no se
+// podía commitear sin apagar el guard.
+//
+// Se vacía **sólo** en un commit. En cualquier otro comando lo que va entre comillas sí se ejecuta:
+// `bash -c "git push origin main"` y `eval "git reset --hard"` siguen cayendo, comprobado. Queda afuera
+// la sustitución dentro del propio mensaje —`git commit -m "$(...)"` corre y ya no se ve—, que es
+// evasión y no la forma habitual.
 function destructive(input) {
-  const command = commandOf(input)
+  const raw = commandOf(input)
+  const command = isCommit(raw) ? unquoted(raw) : raw
+  // Ninguna de estas dos ramas tiene override, y la pregunta merece respuesta escrita porque cuatro
+  // guards del motor sí lo tienen. R8 no admite excepción configurable para `force` ni para `amend`, y
+  // el precedente es `git-add`, que hace cumplir la misma regla sin escapatoria. Lo que corresponde
+  // cuando de verdad hace falta es una acción humana, que deja rastro; una variable de entorno no.
+  //
+  // Publicar se autoriza; reescribir historia publicada, no. Eran el mismo interruptor: `\bgit\s+push\b`
+  // matchea igual las dos formas, así que `allowPush` habilitaba el force-push sin que nadie lo decidiera
+  // y el párrafo de autonomía de `AGENTS.md` tenía que confesarlo. R8 prohíbe `force` sin excepción
+  // configurable, así que esta rama va antes del permiso y no lo consulta.
+  if (/\bgit\s+push\b[^;&|]*\s(?:-f|--force(?:-with-lease|-if-includes)?)\b/.test(command)) {
+    block("'git push --force' reescribe historia ya publicada. R8 lo prohíbe y runner.allowPush no lo "
+      + 'habilita: publicá con un push normal, o registrá una acción humana.')
+  }
   if (/\bgit\s+push\b/.test(command) && !pushAllowed(input)) {
     block("'git push' publica cambios y requiere una acción humana. Se habilita con runner.allowPush.")
   }
   const rules = [
     [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales."],
+    // R8 lo prohíbe sin excepción configurable y ningún guard lo miraba: `grep -rn amend engine/hooks/`
+    // no devolvía una línea. Se bloquea por política y no por daño —un `--amend` sobre algo que nadie vio
+    // no rompe nada—, así que el mensaje manda a lo que sí corresponde: otro commit.
+    [
+      /\bgit\s+commit\b[^;&|]*\s--amend\b/,
+      "'git commit --amend' reescribe un commit ya creado. R8 pide uno nuevo en su lugar.",
+    ],
     [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento."],
     // `git checkout -- .` destruye lo mismo que `reset --hard` y sin recuperación, pero se escribe como
     // una limpieza. Se bloquea sólo la forma ancha —`.`, `*`, `:/`, o sin ruta—: revertir un archivo
@@ -106,6 +138,76 @@ function dependencies(input) {
   }
 }
 
+// El destino de una escritura se juzgaba sólo en `Edit`/`Write`, así que el mismo archivo se escribía
+// sin obstáculo con un heredoc por `Bash`: frenaba a quien actuaba de buena fe y no a quien quería pasar.
+// Registrar `workspace-boundary` en este grupo no alcanzaba —lee `filesOf`, que en un comando no
+// devuelve nada—, así que lo que faltaba era leer el comando.
+//
+// **Esto no puede ser completo y no se presenta como si lo fuera.** `eval`, una variable armada dos
+// líneas antes, un heredoc dentro de `bash -c`, un `python -c "open(...)"` o un script propio escriben
+// igual y ningún patrón los ve. Frena la forma habitual, como el resto de `destructive`; quien quiera
+// pasar, pasa. Presentarlo como un límite invitaría a confiar en él más de lo que aguanta.
+// Tres familias, porque los comandos no nombran su destino igual: `tee` y `truncate` escriben en cada
+// argumento, `cp` y sus hermanos en el último, y `sed` sólo escribe con `-i` —sin él lee y manda a
+// stdout, y esa redirección la ve REDIRECT—.
+const REDIRECT = /(?:^|[\s(])&?\d*>>?\s*(?![&(])([^\s;|&<>()]+)/g
+const EVERY_ARG = /(?:^|[\s;|&(])(tee|truncate)\s+([^;|&<>()]+)/g
+const LAST_ARG = /(?:^|[\s;|&(])(cp|mv|install|rsync)\s+([^;|&<>()]+)/g
+const SED = /(?:^|[\s;|&(])sed\s+([^;|&<>()]+)/g
+const IN_PLACE = /(?:^|\s)-{1,2}i/
+
+// Los argumentos que no son flags. El valor de un flag se cuela —`truncate -s 0 log` trae el `0`— y no
+// hace falta sacarlo: un token así resuelve contra el cwd, que está adentro de la raíz, así que nunca
+// decide un bloqueo. Filtrarlo sería una rama que ninguna prueba puede ver caer.
+const positional = (text) => text.trim().split(/\s+/).filter((one) => one && !one.startsWith('-'))
+
+// Vacía lo que va entre comillas, dejando una marca que ningún patrón confunde con una ruta ni con un
+// comando. Lo usan dos guards por razones distintas, y cada uno explica la suya donde lo llama.
+const unquoted = (command) => String(command).replace(/'[^']*'|"[^"]*"/g, '\u0000')
+
+// Un `>` adentro de una cadena no redirige nada. Pierde el destino entrecomillado, que es un falso
+// negativo — el error barato en un guard que ya es incompleto, porque el caro es frenar un comando
+// legítimo y que alguien apague el guard entero.
+//
+// `$HOME` y `~` se expanden porque son como se escribe el destino que esto vino a ver; el incidente que
+// lo originó decía `> $HOME/.claude/...`. Cualquier otra variable queda sin resolver y no se juzga:
+// adivinar su valor sería inventarlo, y un límite inventado frena lo que nadie pidió frenar.
+function writeTargets(command) {
+  const clean = unquoted(command)
+  const found = new Set()
+  for (const match of clean.matchAll(REDIRECT)) found.add(match[1])
+  for (const match of clean.matchAll(EVERY_ARG)) for (const one of positional(match[2])) found.add(one)
+  for (const match of clean.matchAll(LAST_ARG)) {
+    const args = positional(match[2])
+    // Con un solo argumento no hay destino: `cp solo` está a medio escribir, no escribe en `solo`.
+    if (args.length > 1) found.add(args[args.length - 1])
+  }
+  for (const match of clean.matchAll(SED)) {
+    const args = positional(match[1])
+    if (IN_PLACE.test(match[1]) && args.length) found.add(args[args.length - 1])
+  }
+  return [...found]
+    .map((one) => one.replace(/^~(?=$|\/)/, os.homedir()).replace(/^\$\{?HOME\}?(?=$|\/)/, os.homedir()))
+    .filter((one) => !/[$`\u0000]/.test(one))
+}
+
+// Los destinos que no son de nadie y aparecen en cualquier comando legítimo: los descriptores del
+// sistema y el temporal, que es donde el propio runner deja lo que no va al repositorio. Sin esta lista
+// el guard frena `> /dev/null 2>&1`, y lo primero que hace quien lo sufre es apagarlo entero.
+const NEUTRAL = [/^\/dev\/(?:null|stdout|stderr|tty|fd\/)/, new RegExp(`^${os.tmpdir()}(?:/|$)`)]
+
+function shellBoundary(input) {
+  const allowed = writableRoots(input)
+  if (!allowed) return
+  for (const raw of writeTargets(commandOf(input))) {
+    const file = path.resolve(cwdOf(input), raw)
+    if (NEUTRAL.some((pattern) => pattern.test(file))) continue
+    if (outsideRoots(file, allowed)) {
+      block(`el comando escribe en ${file}, fuera de las raíces declaradas en ops.config.json. ${DECLARE_IT}`)
+    }
+  }
+}
+
 function governance(input) {
   if (process.env.OPS_GOVERNANCE_OVERRIDE === '1') return
   const command = commandOf(input)
@@ -194,4 +296,4 @@ function verify(input) {
   if (failures.length) block(`Verify falló en ${path.basename(dir)}: ${failures.join(', ')}. No se commitea en rojo.`)
 }
 
-module.exports = { destructive, gitAdd, dependencies, governance, verify, run }
+module.exports = { destructive, gitAdd, dependencies, governance, verify, shellBoundary, run }

package/engine/planning/adoption.js

@@ -0,0 +1,48 @@
+'use strict'
+
+// El baseline de adopción: qué entradas de `DONE.md` ya existían cuando el proyecto empezó a usar Cauce,
+// escritas bajo otro contrato de evidencia o bajo ninguno. Vive aparte de `contracts` porque no es un
+// juicio sobre el planning sino una lista de perdones con su propia vida — se genera una vez, se mira en
+// cada corrida y se achica a mano cuando una entrada vieja se reescribe.
+//
+// Es un archivo de texto y no un campo de configuración porque lo que lo mantiene sano es poder mirarlo
+// y borrarle un renglón. Una fecha en `ops.config.json` perdonaría por tanda, y una tanda no se achica.
+
+const path = require('node:path')
+const P = require('./parser')
+const PC = require('./contracts')
+
+const BASELINE = '.adoption-baseline'
+
+// El archivo ausente y el archivo vacío son lo mismo: no hay nada exento, que es lo que le pasa a casi
+// todo proyecto. Reclamarlo obligaría a los que no adoptaron nada a declarar una lista vacía.
+function read(dir) {
+  return P.read(path.join(dir, BASELINE)).split('\n')
+    .map((line) => line.replace(/#.*$/, '').trim())
+    .filter(Boolean)
+}
+
+// Las tres cosas que hay que ver de una lista de perdones, y las tres son advertencias: la exención es
+// legítima —el proyecto la declaró al adoptar— y lo único que no puede es dejar de verse.
+//
+// Que un slug ya cumpla el contrato no se detecta leyendo la lista: hay que volver a juzgar la entrada,
+// que es para lo que existe `doneEntryErrors`. Sin este aviso la lista sólo envejece — nadie se entera
+// de que doce de sus noventa perdones dejaron de hacer falta, y la exención sobrevive a su razón.
+function report({ done, epics = [], adopted = [] }) {
+  const slugs = [...new Set(adopted)]
+  const warnings = []
+  for (const slug of slugs) {
+    const entry = done.entries.find((candidate) => candidate.slug === slug)
+    if (!entry) {
+      warnings.push(`${BASELINE}: ${slug} no está en DONE.md; sacalo de la lista`)
+    } else if (!PC.doneEntryErrors(entry, epics).length) {
+      warnings.push(`${BASELINE}: ${slug} ya cumple el contrato; sacalo de la lista`)
+    }
+  }
+  if (slugs.length) {
+    warnings.push(`${BASELINE}: ${slugs.length} entrada(s) exenta(s) del contrato de evidencia por adopción`)
+  }
+  return warnings
+}
+
+module.exports = { BASELINE, read, report }

package/engine/planning/contracts.js

@@ -64,6 +64,25 @@ function validateDoneEntry(entry, cited = []) {
   return errors
 }
 
+// Los cinco juicios que recibe una entrada de DONE, juntos. Estaban repartidos entre el bucle que las
+// recorre y `validateDoneEntry`, y ese reparto no se nota hasta que algo tiene que preguntar «¿a esta
+// entrada le falta *algo*?»: la primera versión de la exención por adopción se escribió en una de las
+// dos mitades y las otras cuatro comprobaciones seguían fallando.
+//
+// Los criterios que la historia declaró cubrir los cita el roadmap y no la entrada, así que el cruce
+// sólo existe si la entrada dice de qué épica viene.
+function doneEntryErrors(entry, epics = []) {
+  const at = `${entry.source} ${entry.slug}`
+  const errors = []
+  if (!entry.acceptance) errors.push(`${at}: falta acept:`)
+  if (!entry.done) errors.push(`${at}: falta done:`)
+  if (!entry.qa) errors.push(`${at}: falta qa:`)
+  if (!entry.commit) errors.push(`${at}: falta commit:`)
+  const story = epics.find((epic) => epic.num === entry.epic)?.stories
+    .find((candidate) => candidate.slug === entry.slug)
+  return [...errors, ...validateDoneEntry(entry, story ? story.criteria : [])]
+}
+
 function duplicates(values) {
   return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))]
 }
@@ -299,7 +318,9 @@ function validateAdr(dir) {
 // humanas. Vive acá y no en el CLI porque es de la misma clase que sus vecinas —`validateEpic`,
 // `validateDoneEntry`, `validateRules`— y estaba creciendo del otro lado sólo porque ahí era más
 // rápido escribirla. No lee nada: recibe el estado, así que se prueba sin tocar disco.
-function validateState({ epics, milestones, done, wip, roles = new Set(), humanActions = [] }) {
+function validateState({
+  epics, milestones, done, wip, roles = new Set(), humanActions = [], adopted = new Set(),
+}) {
   const errors = []
   const epicNums = new Set()
   const storySlugs = new Set()
@@ -396,15 +417,11 @@ function validateState({ epics, milestones, done, wip, roles = new Set(), humanA
   }
 
   for (const entry of done.entries) {
-    if (!entry.acceptance) errors.push(`${entry.source} ${entry.slug}: falta acept:`)
-    if (!entry.done) errors.push(`${entry.source} ${entry.slug}: falta done:`)
-    if (!entry.qa) errors.push(`${entry.source} ${entry.slug}: falta qa:`)
-    if (!entry.commit) errors.push(`${entry.source} ${entry.slug}: falta commit:`)
-    // Los criterios que la historia declaró cubrir: los cita el roadmap, no la entrada de DONE, así que
-    // el cruce sólo existe si la entrada dice de qué épica viene.
-    const story = epics.find((epic) => epic.num === entry.epic)?.stories
-      .find((candidate) => candidate.slug === entry.slug)
-    errors.push(...validateDoneEntry(entry, story ? story.criteria : []))
+    // La entrada exenta por adopción se saltea entera. Es por entrada y no por campo ausente: una
+    // historia escrita bajo otro contrato puede traer un `commit:` con formato ajeno, y perdonar sólo
+    // «falta X» la dejaría fallando por lo que sí escribió.
+    if (adopted.has(entry.slug)) continue
+    errors.push(...doneEntryErrors(entry, epics))
   }
   return errors
 }
@@ -424,36 +441,9 @@ function validateState({ epics, milestones, done, wip, roles = new Set(), humanA
 // cuando está funcionando— y queda silenciado para todos sin que nadie lo decida caso por caso. R7 sí
 // deja los suyos al proyecto, pero con su razón: dependen del lenguaje y de la superficie. Cinco
 // condiciones que un plan tiene que satisfacer a la vez no dependen de ninguna de las dos.
-const R17 = { taskCriteria: 5, epicCriteria: 7, milestoneTasks: 9 }
-
-// Se cuenta lo que está estructurado: criterios de la épica, criterios que hereda una tarea, tareas del
-// hito. Quedan afuera las dos cosas que no son un conteo: la aceptación escrita en prosa —cuántas
-// condiciones tiene una frase es una lectura, y un número inventado ahí sería peor que ninguno— y la
-// segunda barra de R17, las cuatro horas de esfuerzo, que no está en el artefacto. Las dos las mira el
-// review, que para eso está R3, y la de esfuerzo es la que R17 dice que encuentra lo que ésta deja pasar.
-function oversizedUnits({ epics = [], milestones = [] }) {
-  const errors = []
-  const undecided = (what, count, limit) =>
-    `${what}: ${count} (umbral ${limit} de R17). Revisá si son dos resultados con vidas distintas y `
-    + 'partilo; si es uno solo, partirlo lo empeora — dejalo entero agregando "(sin partir: <razón>)"'
-  const judge = (unit, what, count, limit) => {
-    if (count > limit && !unit.noSplit) errors.push(undecided(what, count, limit))
-  }
-  for (const epic of epics) {
-    judge(epic, `roadmap/${epic.file}: criterios`, epic.criteria.length, R17.epicCriteria)
-  }
-  for (const milestone of milestones) {
-    judge(milestone, `hito ${milestone.slug}: tareas`, milestone.tasks.length, R17.milestoneTasks)
-    for (const task of milestone.tasks) {
-      judge(task, `BACKLOG ${task.slug}: criterios`, task.criteria.length, R17.taskCriteria)
-    }
-  }
-  return errors
-}
-
 module.exports = {
   validateState,
-  oversizedUnits,
+  doneEntryErrors,
   validateAdr,
   validateRules,
   retiredByOverride,

package/engine/planning/parser.js

@@ -138,6 +138,16 @@ function readEpics(dir) {
       criteria,
       stories,
       hasContext: /^##\s+Contexto relevante/im.test(text),
+      // El molde describe esta sección como «lo que el ejecutor lee antes de decidir el cómo», y `check`
+      // da error si falta. Hasta acá se comprobaba que estuviera y se tiraba el texto en el mismo
+      // renglón, así que quien tenía que leerla nunca la recibía: `context` la resuelve por él, que
+      // además tiene prohibido ir a buscarla.
+      //
+      // Son dos campos y no uno porque contestan distinto: `hasContext` dice si el encabezado está
+      // —que es lo que `check` exige hoy— y `context` trae el cuerpo, que puede estar vacío debajo de
+      // un encabezado presente. Unificarlos convertiría una sección vacía en un error nuevo, que es
+      // otra decisión y no ésta.
+      context: section(text, /Contexto relevante/i).split('\n').slice(1).join('\n').trim(),
       noSplit: noSplitReason(text),
       // Las líneas que todavía no decidieron nada. Se guardan enteras y no como un booleano porque el
       // error tiene que decir cuál es: «tiene un marcador» manda a releer la épica entera.
@@ -167,6 +177,22 @@ function readCast(rest) {
 // 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
 
+// Cuántas condiciones tiene una aceptación escrita en prosa. Estuvo mucho tiempo sin contarse con una
+// razón buena —contar condiciones en una frase es una lectura, y un número inventado es peor que
+// ninguno—, y lo que la resuelve es no leer: se cuenta lo que el autor marcó. Los `(N)` cuando hay más
+// de uno, y si no los hay, los tramos que él mismo separó con `;`.
+//
+// Sub-cuenta a propósito. Una frase larga con comas vale 1, y un solo `(1)` suelto también: un umbral
+// que salta cuando no debe convierte la escapatoria de R17 en trámite, y ahí la razón se escribe para
+// callar el mensaje en vez de para que alguien la lea. Un falso negativo deja las cosas como estaban.
+function acceptanceConditions(value) {
+  const text = String(value || '').trim()
+  if (!text) return 0
+  const marcadas = (text.match(/\(\d+\)/g) || []).length
+  if (marcadas >= 2) return marcadas
+  return text.split(';').map((one) => one.trim()).filter(Boolean).length
+}
+
 function readBacklog(dir) {
   const text = withoutComments(read(path.join(dir, 'BACKLOG.md')))
   const milestones = []
@@ -185,11 +211,13 @@ function readBacklog(dir) {
     const task = line.match(TASK_LINE)
     if (!task || !current) continue
     const rest = task[3]
+    const acceptance = ((rest.match(ACCEPTANCE) || [])[1] || '').trim()
     current.tasks.push({
       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(ACCEPTANCE) || [])[1] || '').trim(),
+      acceptance,
+      conditions: acceptanceConditions(acceptance),
       criteria: criteriaRefs(rest),
       noSplit: noSplitReason(rest),
     })
@@ -207,6 +235,25 @@ function doneFiles(dir) {
   return files
 }
 
+const DONE_FIELDS = 'acept|done|qa|tests|decisions|commit'
+
+// Un campo vale hasta el próximo campo, una línea en blanco o el fin de la entrada. Mismo corte que ya
+// se arregló para los criterios y las historias, con el mismo síntoma: el valor es prosa y se envuelve a
+// 120 columnas, así que leer sólo la primera línea dejaba afuera lo que el autor escribió y `check`
+// reportaba una ausencia que no existía —«decisions debe citar» sobre un campo cuya cita cerraba abajo—.
+//
+// El corte por línea en blanco no es simetría: el último campo es el único que no tiene otro campo
+// detrás, y sin él se traga lo que venga después dentro de la entrada. En silencio, además, porque
+// `validCommitTrace` sigue aprobando un `commit` contaminado mientras el prefijo sea válido.
+//
+// La sangría es `[^\S\n]` y no `\s`: `\s` incluye el salto, así que el match puede empezar en la línea
+// anterior y arrastrar una línea en blanco adentro del valor.
+function doneField(body, name) {
+  const pattern = new RegExp(`^[^\\S\\n]+${name}:[^\\S\\n]*([\\s\\S]*?)`
+    + `(?=\\n[^\\S\\n]+(?:${DONE_FIELDS}):|\\n[^\\S\\n]*\\n|(?![\\s\\S]))`, 'mi')
+  return ((body.match(pattern) || [])[1] || '').replace(/\s+/g, ' ').trim()
+}
+
 function readDone(dir) {
   const entries = []
   for (const file of doneFiles(dir)) {
@@ -215,7 +262,7 @@ function readDone(dir) {
     const matches = [...text.matchAll(donePattern)]
     for (const match of matches) {
       const body = match[3]
-      const field = (name) => ((body.match(new RegExp(`^\\s+${name}:\\s*(.+)$`, 'mi')) || [])[1] || '').trim()
+      const field = (name) => doneField(body, name)
       entries.push({
         slug: match[1].trim(),
         epic: ((match[2].match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
@@ -291,5 +338,6 @@ module.exports = {
   EPIC_STATES, HUMAN_ACTION_STATES, LANES, MILESTONE_HEADING, STOP_REASONS,
   TASK_LINE, TASK_LINE_ANY_LANE,
   read, section, withoutComments, frontmatter, readEpics, readBacklog, readDone, readWip,
+  acceptanceConditions,
   readInbox, readHumanActions,
 }

package/engine/planning/sizing.js

@@ -0,0 +1,50 @@
+'use strict'
+
+// Las dos barras de R17 sobre lo que ya está escrito: cuántas condiciones acumula una unidad y cuántas
+// unidades acumula la de arriba. Vive aparte de `contracts` porque no juzga si algo está bien escrito
+// sino si es demasiado, y su reloj es el de la regla: los números y qué se cuenta cambian cuando cambia
+// R17, no cuando cambia un contrato de planning.
+//
+// La otra barra de R17 —las cuatro horas de esfuerzo— no está acá ni puede estar: no vive en el
+// artefacto. La mira el review, y es la que la regla dice que encuentra lo que ésta deja pasar.
+
+const R17 = { taskCriteria: 5, epicCriteria: 7, milestoneTasks: 9 }
+
+// Se cuenta lo que está estructurado —criterios de la épica, criterios heredados, tareas del hito— y
+// también la aceptación propia de una tarea, que se cuenta como el autor la marcó y no leyéndola;
+// `acceptanceConditions` explica hasta dónde llega esa cuenta.
+//
+// Estuvo afuera con una razón escrita: un número inventado sobre una frase es peor que ninguno, y lo que
+// esta barra no vea lo ve el review de R3 más la segunda barra de R17. Lo que no previó fue el
+// comportamiento. En un proyecto real seis de cuarenta y ocho tareas cruzaban el umbral en prosa y
+// ninguna se vio, incluida la primera de la cola; y para la forma que el molde muestra primero, la
+// escapatoria que R17 describe no se pedía nunca, porque el umbral no se cruzaba. La regla nombra esa
+// acumulación —condiciones que se suman de a tandas en cada rechazo de plan— y ocurre justamente ahí.
+function oversizedUnits({ epics = [], milestones = [] }) {
+  const errors = []
+  const undecided = (what, count, limit) =>
+    `${what}: ${count} (umbral ${limit} de R17). Revisá si son dos resultados con vidas distintas y `
+    + 'partilo; si es uno solo, partirlo lo empeora — dejalo entero agregando "(sin partir: <razón>)"'
+  const judge = (unit, what, count, limit) => {
+    if (count > limit && !unit.noSplit) errors.push(undecided(what, count, limit))
+  }
+  for (const epic of epics) {
+    judge(epic, `roadmap/${epic.file}: criterios`, epic.criteria.length, R17.epicCriteria)
+  }
+  for (const milestone of milestones) {
+    judge(milestone, `hito ${milestone.slug}: tareas`, milestone.tasks.length, R17.milestoneTasks)
+    for (const task of milestone.tasks) {
+      // Se juzga la mayor de las dos y se nombra cuál: una tarea escribe su aceptación heredada o
+      // propia, casi nunca las dos, y sumarlas contaría dos veces a la que repite en prosa lo que ya
+      // citó. Nombrarla importa porque el mensaje llega solo: «criterios: 8» sobre una tarea sin un
+      // `(→ CN)` a la vista manda a buscar ocho referencias que no existen.
+      const propias = task.conditions || 0
+      const heredados = task.criteria.length
+      const que = heredados >= propias ? 'criterios' : 'condiciones de aceptación'
+      judge(task, `BACKLOG ${task.slug}: ${que}`, Math.max(heredados, propias), R17.taskCriteria)
+    }
+  }
+  return errors
+}
+
+module.exports = { oversizedUnits }

package/engine/schemas/ops-config.schema.json

@@ -54,6 +54,14 @@
         "additionalProperties": false
       }
     },
+    "writableOutsideRoots": {
+      "type": "array",
+      "description": "Rutas que el proyecto declara escribibles sin ser raíces de código —la memoria del runner, un scratchpad, un directorio de salida—. Sólo levantan el límite de workspace-boundary: no entran a scan ni al inventario de credenciales, que recorren workspaceRoots. `~` se expande a la casa del usuario y el resto se resuelve contra la raíz de ops. `check` las muestra resueltas en cada corrida, porque una exención que no se ve es un límite que ya no existe.",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    },
     "runner": {
       "type": "object",
       "required": [

package/package.json

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

package/template/AGENTS.md

@@ -122,10 +122,16 @@ Registra la acción exacta en `planning/HUMAN_ACTIONS.md` y, si bloquea todo, cr
 `planning/AWAITING_REVIEW.md`.
 
 Nunca amplía el alcance, promueve sus propias ideas, reescribe el proceso durante una tarea, usa
-`git add .`/`git add -A`, hace push/force/amend, ni afirma éxito sin evidencia real.
+`git add .`/`git add -A`, reescribe historia con `--force` o `--amend`, ni afirma éxito sin evidencia
+real. Tampoco publica: sin autorización no hay `push`.
+
+Publicar es lo único de todo eso que este proyecto puede habilitar, y `runner.allowPush` en
+`ops.config.json` es la autorización que R10 pide. Reescribir historia publicada no entra en el trato:
+un `push --force` se frena con la llave prendida o apagada.
 
 Eso rige sin que nadie escriba nada. Lo que este proyecto amplíe o restrinja va en
-`organization/workspace.md`, con su razón; los cuatro límites del párrafo anterior no se amplían ahí.
+`organization/workspace.md`, con su razón; ninguna de esas prohibiciones se amplía ahí, y la
+publicación tampoco se decide ahí: la decide `allowPush`.
 
 ## Definición de terminado
 

package/template/planning/rules/system/code-shape.md

@@ -51,6 +51,19 @@ nada falla.
 
 Un comentario que cuesta escribir suele estar señalando el código, no la falta de palabras.
 
+Y como en R14 y R15, no se detecta releyendo: quien lo escribió ya sabe por qué, y la copia se lee bien
+precisamente porque lo que dice es cierto. Antes de entregar se recorren los comentarios que el cambio
+agrega, uno por uno, y de cada uno se contesta si alguien lo preguntaría, si su razón ya está escrita en
+otro lado y si está en el destino que le toca. Es mecánico y barato, y encuentra lo que releer no
+encuentra: el que sobra por repetir lo que el nombre de al lado ya dice, y la razón que quedó en dos
+lugares sin que ninguno de los dos se vea mal solo.
+
+Una puerta que mida esto ayuda y no reemplaza a la pasada. Comparar textos encuentra la copia literal y
+deja pasar las dos formas que más aparecen: la razón repetida apenas por debajo del umbral, y el
+comentario que no repite a ningún otro porque repite el nombre que tiene al lado. Bajar el umbral hasta
+que las agarre empieza a marcar lo que está bien, así que el número se elige para no molestar y la pasada
+se hace igual.
+
 ## R18 — Un doble se justifica y los datos salen de una fábrica
 
 Todo doble de prueba —mock, stub, fake, spy— declara en una línea por qué existe, y se busca en el lugar

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

@@ -34,3 +34,13 @@ producción, lo que prueba tampoco: queda verde para siempre sobre algo que nadi
 ## R10 — Publicación humana por defecto
 
 Push, PR, merge, tags, deploy y rollback requieren la autorización configurada para el proyecto.
+
+De esos seis, el motor comprueba uno: el push, contra `runner.allowPush`. Reescribir historia publicada
+no entra en esa autorización y se frena siempre, igual que `--amend`. Los otros cinco no tienen una
+forma reconocible en un comando —un deploy es `kubectl`, `terraform`, un script o un botón— y los
+sostiene esta regla y el review, no un guard.
+
+Decirlo es parte de la regla y no una nota al pie. Una norma que se presenta como comprobada donde no
+lo está enseña a no creerle al resto: quien descubre que puede mergear sin que nada lo frene concluye
+que la línea de arriba es decorativa, y esa conclusión se lleva puesto también lo que sí se comprueba.
+Que el límite lo sostenga una persona no lo hace más blando; lo hace visible.

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

@@ -10,7 +10,9 @@ sandbox. Sin aprobación humana explícita:
 - no editar secretos, credenciales, DNS, permisos o cuentas;
 - no borrar datos ni ejecutar migraciones irreversibles.
 
-Las excepciones se documentan en el `AGENTS.md` del proyecto, nombrando el entorno concreto.
+Las excepciones se documentan en la sección «Integraciones y ambientes» de
+`organization/workspace.md`, nombrando el entorno concreto: ese archivo es del proyecto y
+`upgrade` no lo toca.
 
 ## R13 — Negarse no es entregar