@ingeniomaps/cauce 0.87.0 → 0.89.0

package/engine/automation/rules.js

@@ -6,6 +6,7 @@
 // instalar. Y como `upgrade` no reinstala, `check` y `doctor` comparan lo instalado con lo vigente.
 
 const fs = require('node:fs')
+const path = require('node:path')
 const F = require('../core/files')
 const O = require('../core/ownership')
 
@@ -20,14 +21,100 @@ const START_AT = '<!-- cauce:reglas inicio'
 // Lo que un `CLAUDE.md` o un `GEMINI.md` instalado antes de 0.82.0 trae en el lugar del bloque.
 const LEGACY_IMPORT = /^@\S*planning\/rules\/\S+\.md\s*$/
 
+// Una regla que declara `aplica:` rige igual, y se carga sólo cuando se toca esa superficie. Lo que se
+// ahorra está medido: el contexto de arranque de **cada** agente son ~16 K tokens sólo de lo que Cauce
+// pone, y una regla que importa en una tarea de cada cien se leía cien veces (caso 141).
+//
+// El default es lo que vuelve seguro esto: sin el campo, la regla se carga como siempre. Al revés —pedir
+// que declare `siempre` para seguir cargándose— cada instancia habría perdido sus reglas propias en el
+// próximo `upgrade`, una por una y sin que nada lo dijera.
+//
+// `effectiveRules` no cambia: sigue devolviendo todo lo que rige, que es lo que `ops context` le entrega
+// al recorrido. Acá sólo se decide qué se **carga**, y por eso la partición vive de este lado.
+const SURFACE = /^aplica:[ \t]*(\S.*?)[ \t]*$/m
+function surfaceOf(root, file) {
+  try {
+    const text = fs.readFileSync(path.join(root, file), 'utf8')
+    // Sólo en el frontmatter: un `aplica:` en la prosa de una regla es una frase, no una declaración.
+    if (!text.startsWith('---')) return ''
+    const end = text.indexOf('\n---', 3)
+    return end === -1 ? '' : ((text.slice(0, end).match(SURFACE) || [])[1] || '')
+  } catch { return '' }
+}
+
+// Las que se cargan y las que sólo se nombran. Las dos listas salen de la misma lectura para que el
+// bloque que se escribe y el aviso que lo audita no puedan discrepar: con dos recorridos, `doctor`
+// reportaría como faltante la que a propósito no se carga, para siempre y sin forma de callarlo.
+function split(root) {
+  const loaded = []
+  const named = []
+  for (const file of O.effectiveRules(root)) {
+    const surface = surfaceOf(root, file)
+    if (surface) named.push({ file, surface })
+    else loaded.push(file)
+  }
+  return { loaded, named }
+}
+
+// Cuánto pesa lo que el bloque carga, en bytes. En bytes y no en tokens a propósito: los bytes los mide
+// el motor y se pueden comprobar, mientras que la equivalencia en tokens depende del modelo y del
+// tokenizador. Un número estimado en una salida que alguien cita para decidir vale menos que uno exacto.
+//
+// Sólo `loaded`: una regla declarada por superficie no viaja en el arranque, y contarla haría que
+// declararla no sirviera de nada. Vive acá —y no en quien lo imprime— porque lo miran dos, `install` al
+// instalar y `check` en cada corrida, y con dos cuentas separadas se contradicen el día que alguien toque
+// una sola.
+function weight(root) {
+  const { loaded } = split(root)
+  let bytes = 0
+  const files = []
+  for (const file of loaded) {
+    try {
+      const size = fs.statSync(path.join(root, file)).size
+      bytes += size
+      files.push({ file, size })
+    } catch { /* la que no está en disco ya la reporta `check` por su lado */ }
+  }
+  return { count: loaded.length, bytes, files: files.sort((a, b) => b.size - a.size) }
+}
+
+const KB = (bytes) => `${(bytes / 1024).toFixed(1)} KB`
+
+// A partir de dónde el peso deja de ser el costo de arrancar y pasa a ser una decisión que conviene mirar.
+// El piso que Cauce impone —las cuatro reglas del sistema— son 38,3 KB, así que un umbral por debajo de
+// eso avisaría en toda instancia recién creada y se apagaría por ruido el primer día: eso descartó los
+// 60 KB que el caso 141 proponía. 64 KB deja ~26 KB para lo propio, que son varias reglas de tamaño
+// normal, antes de que el aviso hable.
+const HEAVY = 64 * 1024
+
+// La línea que declara el peso, para que la digan igual `install` y `check`. Nombra las dos más grandes
+// porque es lo accionable: saber que el bloque pesa no dice cuál conviene declarar por superficie.
+function weightLine(root) {
+  const { count, bytes, files } = weight(root)
+  const top = files.slice(0, 2).map((one) => path.basename(one.file)).join(', ')
+  return `el bloque de reglas carga ${count} archivo(s), ${KB(bytes)} en cada agente`
+    + (top ? ` (las más grandes: ${top})` : '')
+}
+
+// Sólo cuando pasó el umbral. Devuelve lista porque es lo que `check` empalma con el resto de avisos.
+function heavyRules(root) {
+  return weight(root).bytes > HEAVY ? [weightLine(root)] : []
+}
+
 // Sin raíz el marcador queda como está —así lo leen las pruebas que revisan el texto de un adaptador—: un
 // bloque vacío se leería igual que un proyecto sin reglas, y un marcador sin resolver se ve.
 function fill(text, root) {
   if (!root || !text.includes('{{RULES:')) return text
-  const rules = O.effectiveRules(root)
-  return text.replace(MARKER, (_, format) => [START, ...rules.map((file) => (format === 'imports'
-    ? `@{{OPS_DIR}}${file}`
-    : `- \`{{OPS_DIR}}${file}\``)), END].join('\n'))
+  const { loaded, named } = split(root)
+  return text.replace(MARKER, (_, format) => [
+    START,
+    ...loaded.map((file) => (format === 'imports' ? `@{{OPS_DIR}}${file}` : `- \`{{OPS_DIR}}${file}\``)),
+    // Nombrada y no cargada: pesa una línea en vez de su archivo entero, y quien la lea sabe qué la
+    // dispara. Va en el mismo bloque a propósito — fuera de él, una sesión que no corre un recorrido no
+    // se enteraría de que existe, y una regla que nadie sabe que existe es una que no rige.
+    ...named.map((one) => `- \`{{OPS_DIR}}${one.file}\` (aplica: ${one.surface})`),
+    END,
+  ].join('\n'))
 }
 
 function blockOf(text) {
@@ -69,6 +156,13 @@ function drift(root, name) {
   const { runnerManifest, runnerPaths, resolveItem } = require('./runners')
   const runner = runnerManifest(root, name)
   const paths = runnerPaths(root, name, runner)
+  // Contra todo lo que rige, y no contra la partición: una regla declarada por superficie igual aparece
+  // en el bloque —nombrada en vez de importada—, y `listed` extrae la ruta de las dos formas. Así que el
+  // audit la ve y no la extraña, sin que este lado tenga que saber que la partición existe.
+  //
+  // Se intentó filtrar acá por simetría con `fill` y no cambiaba nada: la mutación que lo revertía dejaba
+  // las pruebas en verde. Queda dicho porque la simetría es tentadora y el código que no altera ninguna
+  // conducta se lee como si sostuviera algo.
   const expected = O.effectiveRules(root)
   const found = []
   for (const item of [...(runner.instructions || []), ...(runner.artifacts || [])]) {
@@ -119,4 +213,4 @@ function staleLines(root) {
   return lines
 }
 
-module.exports = { fill, refresh, drift, driftLine, staleLines }
+module.exports = { fill, refresh, drift, driftLine, staleLines, split, weightLine, heavyRules }

package/engine/automation/runners.js

@@ -122,9 +122,13 @@ function inline(text, automationRoot) {
   })
 }
 
-// `{{OPS_ROOT}}` es la raíz absoluta. La necesita quien no puede deducirla de dónde lo ejecutaron
-// —el puente de Antigravity—, y por eso no reemplaza a `{{OPS_DIR}}`: una ruta absoluta escrita en un
-// archivo se rompe si el proyecto se mueve, así que la lleva sólo el que se queda sin alternativa.
+// `{{OPS_ROOT}}` es la raíz absoluta, y la lleva quien no puede deducirla de dónde lo ejecutaron: el
+// puente de Antigravity, los hooks de Codex y —desde 0.89.0— los recorridos, que dictan comandos a un
+// agente cuyo directorio nadie promete (caso 139).
+//
+// No reemplaza a `{{OPS_DIR}}` en general, y el costo dice por qué: un archivo que lleva la raíz escrita
+// se rompe si el proyecto se mueve de carpeta, y se repara reinstalando el adaptador. Lo paga el que no
+// tiene alternativa; lo que se resuelve contra la carpeta donde se abre la herramienta sigue con el otro.
 const OPS_ROOT = '{{OPS_ROOT}}'
 
 // `{{RULES:…}}` va antes que `{{OPS_DIR}}` por lo mismo que el include: las rutas que escribe llevan el prefijo.

package/engine/cli/catalog.js

@@ -7,6 +7,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const L = require('../agents/learning')
+const LF = require('../agents/learning-files')
 const AG = require('../agents/catalog')
 const EV = require('../agents/evaluations')
 const T = require('../flows/registry')
@@ -242,9 +243,15 @@ function learn(agent, cli) {
     if (cli.has('--archived')) {
       const result = L.archive(opsRoot(), agent, cli.value('--period'), kind)
       const relative = path.relative(opsRoot(), result.file)
+      // Los dos archivados no son lo mismo y el mensaje lo dice: uno es una decisión —se miró y no
+      // cambia nada— y el otro es tirar un andamio que nadie llegó a llenar. Afirmar el primero sobre
+      // el segundo le cuenta a quien archiva que hubo una revisión que no hubo.
+      const porque = result.blank
+        ? 'nadie decidió el cambio y el documento quedó con el molde'
+        : 'se miró y no cambia nada'
       return console.log(result.already
         ? `= ${relative} ya estaba archivada`
-        : `✓ ${relative} queda archivada: se miró y no cambia nada`)
+        : `✓ ${relative} queda archivada: ${porque}`)
     }
     if (cli.has('--applied')) {
       const result = L.seal(opsRoot(), agent, cli.value('--period'), kind)
@@ -282,6 +289,13 @@ function learn(agent, cli) {
         ? `  ${result.reports} corrida(s) consolidada(s), ${result.findings} hallazgo(s)`
         : `  ${result.reports} informe(s) semanal(es) incluidos`)
     }
+    // Lo lee quien automatiza el ciclo para no pedir una firma por un documento que no decide nada, y
+    // también quien lo corre a mano: sin esta línea el archivo se ve terminado y no lo está. Se pregunta
+    // sobre el documento y no sobre lo que devolvió el motor, porque `prepareProposal` sale por cinco
+    // lugares y sólo uno compone: puesto en ése, el dato falta en los otros cuatro.
+    if (LF.blankProposal(result.file)) {
+      console.log('  sin cambio decidido: falta correr agent-propose antes de que esto se pueda firmar')
+    }
   } catch (error) { fail(error.message, 2) }
 }
 

package/engine/cli/claims.js

@@ -76,9 +76,15 @@ function claim(dir, slug, cli) {
       + `${CL.DIR}/${slug}.md a mano: soltar lo de otro es una decisión, no un comando.`)
   }
   console.log(`✓ ${slug} tomada por ${me}`)
-  // Un reclamo sin empujar no protege de nada: el otro runner lee lo que hay en su copia. Decirlo acá
-  // es lo único que separa «tomé la tarea» de «creí que la había tomado».
-  if (!cli.has('--json')) console.log(`  commiteá y empujá ${CL.DIR}/${slug}.md para que el equipo lo vea`)
+  if (!cli.has('--json')) {
+    // Un reclamo sin empujar no protege de nada: el otro runner lee lo que hay en su copia. Decirlo acá
+    // es lo único que separa «tomé la tarea» de «creí que la había tomado».
+    console.log(`  commiteá y empujá ${CL.DIR}/${slug}.md para que el equipo lo vea`)
+    // Y con qué id volver. Este dato lo imprimía `ops worktree` al crear el árbol; en sidecar no se crea
+    // ninguno, así que ese comando no corre nunca y el id no quedaba escrito en el único momento en que
+    // alguien lo tiene delante: ahora, que se acaba de guardar en el reclamo.
+    console.log(`  export CAUCE_RUNNER=${from}`)
+  }
 }
 
 function release(dir, slug) {

package/engine/cli/io.js

@@ -10,6 +10,12 @@ function fail(message, code = 1) {
   process.exit(code)
 }
 
+// La fecha de hoy, en un solo lugar: los comandos que la usan tienen que estar mirando el mismo día, y
+// el módulo que calcula vencimientos la recibe en vez de preguntarla. Vive acá desde que la puerta de
+// planning se separó de los comandos que la leen — quedaba en el archivo que se partió, y dejar una copia
+// a cada lado habría roto en silencio lo único que esta función promete.
+const TODAY = () => new Date().toISOString().slice(0, 10)
+
 // La raíz ops de un comando que no la recibe. El shim `tools/ops.js` la exporta porque sabe dónde
 // vive: sin eso, invocarlo desde otra carpeta —lo normal en sidecar— la resolvía contra el cwd.
 function opsRoot(dir) {
@@ -44,4 +50,4 @@ function planningRoot(dir) {
   return root
 }
 
-module.exports = { fail, opsRoot, planningRoot }
+module.exports = { fail, opsRoot, planningRoot, TODAY }

package/engine/cli/ops.js

@@ -9,6 +9,7 @@ const { FLAGS, parse } = require('./args')
 const { fail } = require('./io')
 const IN = require('./instance')
 const PL = require('./planning')
+const VA = require('./validate')
 const AR = require('./archive')
 const CLM = require('./claims')
 const WT = require('./worktree')
@@ -124,7 +125,7 @@ async function init(target, cli) {
     })
   } catch (error) { fail(error.message, 2) }
 
-  if (result.installed) PL.check(path.join(root, 'planning'), NO_FLAGS)
+  if (result.installed) VA.check(path.join(root, 'planning'), NO_FLAGS)
 
   // Una instancia recién instalada funciona y no sabe nada de este proyecto: `organization/` es el molde
   // y el roadmap está vacío. Llenarlo exige leer el repositorio y decidir qué es cada cosa, que es justo
@@ -204,7 +205,7 @@ async function run(cli) {
   if (command === 'init') await init(arg[1], cli)
   else if (command === 'scan') W.scan(arg[1], cli)
   else if (command === 'onboard') W.onboard(arg[1], cli)
-  else if (command === 'check') PL.check(arg[1], cli)
+  else if (command === 'check') VA.check(arg[1], cli)
   else if (command === 'tree') PL.tree(arg[1], cli)
   else if (command === 'context') PL.context(arg[1], cli)
   else if (command === 'recurring') PL.recurring(arg[1], cli)

package/engine/cli/planning.js

@@ -1,32 +1,20 @@
 'use strict'
 
-// Los comandos que leen y validan un planning: qué está mal, qué hay, qué toca ahora y qué se archiva.
-// Los cuatro trabajan sobre el mismo estado, que `planning/state.js` compone una vez.
+// Los comandos que leen un planning y contestan sobre él: qué hay, qué toca ahora, qué vence y con qué
+// se cerró una tarea. Todos trabajan sobre el mismo estado, que `planning/state.js` compone una vez.
+//
+// La puerta no está acá: vive en `validate.js` porque decide en vez de informar, y con ella se fueron
+// quince de los veintiún módulos que este archivo importaba.
 
 const fs = require('node:fs')
 const path = require('node:path')
 const P = require('../planning/parser')
-const B = require('../planning/business-rules')
-const PC = require('../planning/contracts')
-const SR = require('../planning/structure')
-const SZ = require('../planning/sizing')
 const RC = require('../planning/recurring')
-const IB = require('../planning/inbox')
 const CL = require('../planning/claims')
-const R = require('../core/repos')
 const ST = require('../planning/state')
-const AD = require('../planning/adoption')
-const AP = require('../hooks/approval')
-const I = require('../integrations/registry')
 const O = require('../core/ownership')
 const EV = require('../core/evidence')
-const TR = require('../core/trails')
-const OB = require('../core/onboarding')
-const C = require('../config/validate')
-const CP = require('../config/paths')
-const AG = require('../agents/catalog')
-const RL = require('../automation/rules')
-const { fail, planningRoot } = require('./io')
+const { fail, planningRoot, TODAY } = require('./io')
 
 // Qué dimensiones enumera el molde de `organization/` y cuáles dejaron de estar. Un agente que reescribe
 // esos archivos tiende a quedarse con el contenido y perder la estructura: el resultado se lee entero y
@@ -74,178 +62,6 @@ function evidence(dir, cli) {
     + 'que la prueba nombrada haya corrido: eso depende del runner, y varios no la nombran al pasar.')
 }
 
-// La fecha de hoy, en un solo lugar: los comandos que la usan tienen que estar mirando el mismo día, y
-// el módulo que calcula vencimientos la recibe en vez de preguntarla.
-const TODAY = () => new Date().toISOString().slice(0, 10)
-
-function check(dir, cli) {
-  const root = planningRoot(dir)
-  const errors = []
-  const warnings = []
-  // El plan no está: `wip/` es local y gitignoreado, así que un clon nuevo no lo trae y eso no es un
-  // error. Ausente se lee como IDLE, que es lo que significa.
-  const required = ['BACKLOG.md', 'INBOX.md', 'HUMAN_ACTIONS.md', 'PROTOCOL.md']
-  // `DONE.md` se retiró: la evidencia vive en un archivo por tarea. Un `DONE.md` que quede en disco
-  // ya no lo lee nadie, y eso no se nota — las épicas dejan de poder cerrar y sus historias figuran
-  // sin evidencia, que es lo mismo que se vería si nunca se hubieran hecho.
-  // `WIP.md` se retiró por lo mismo que `DONE.md`: era uno solo y lo escribían todos los que corren sobre
-  // una instancia sidecar. Uno que quede en disco ya no lo lee nadie, y su plan a medias se pierde sin
-  // que nada lo diga.
-  if (fs.existsSync(path.join(root, 'WIP.md'))) {
-    errors.push('WIP.md ya no se lee: el plan de cada runner vive en `wip/<runner>.md`; movelo y borralo')
-  }
-  if (fs.existsSync(path.join(root, 'DONE.md'))) {
-    errors.push('DONE.md ya no se lee: pasá cada entrada a su propio `done/<slug>.md` y borralo')
-  }
-  for (const file of required) if (!fs.existsSync(path.join(root, file))) errors.push(`falta ${file}`)
-
-  const configPath = path.join(root, '..', 'ops.config.json')
-  let config = null
-  if (fs.existsSync(configPath)) {
-    try {
-      const raw = fs.readFileSync(configPath, 'utf8')
-      config = JSON.parse(raw)
-      if (!raw.includes('{{')) {
-        errors.push(...C.validateOpsConfig(config))
-        warnings.push(...C.configWarnings(config))
-        if (Array.isArray(config.workspaceRoots)) {
-          for (const workspace of config.workspaceRoots) {
-            if (workspace && workspace.name && workspace.path
-              && !fs.existsSync(path.resolve(path.dirname(configPath), workspace.path))) {
-              errors.push(`ops.config.json: no existe la raíz ${workspace.name} (${workspace.path})`)
-            }
-          }
-        }
-        // 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})`)
-    }
-  } else {
-    warnings.push(`no existe ${path.relative(root, configPath)}`)
-  }
-
-  const epics = P.readEpics(root)
-  const milestones = P.readBacklog(root)
-  const done = P.readDone(root)
-  errors.push(...B.validate(path.join(root, 'business-rules')))
-  errors.push(...SR.validateRoadmapStructure(root))
-  errors.push(...SR.validateBacklogStructure(root))
-  errors.push(...SR.validateRules(root))
-  errors.push(...SR.validateAdr(root))
-  const backlog = milestones.flatMap((milestone) => milestone.tasks)
-  const backlogSlugs = new Set(backlog.map((task) => task.slug))
-  const epicNums = new Set()
-  const storySlugs = new Set()
-
-  const roles = new Set(AG.list(path.resolve(root, '..')).map((role) => role.slug))
-  const wips = P.readWips(root)
-  const adopted = AD.read(root)
-  errors.push(...SZ.oversizedUnits({ epics, milestones }))
-  errors.push(...PC.validateState({
-    epics, milestones, done, wips, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
-  }))
-  warnings.push(...AD.report({ done, epics, adopted }))
-  warnings.push(...PC.doneCeremonyWarnings(done, new Set(adopted)))
-  warnings.push(...R.coverageWarnings(path.resolve(root, '..'), done))
-  // Sin `RECURRING.md` no dice una palabra: una instancia que actualiza y no declara trabajo recurrente
-  // no tiene por qué enterarse de que el contrato existe. Vencida avisa y no frena — lo que frena vive
-  // en `HUMAN_ACTIONS.md`, y un aviso que salta siempre se termina apagando.
-  // Un reclamo que nombra una tarea que no existe bloquea la cola sin que nada lo explique, y uno viejo
-  // la bloquea para siempre. Lo primero es error; lo segundo avisa, porque abandonar no es un defecto.
-  const claims = CL.read(root)
-  errors.push(...CL.validate({ claims, milestones, done }))
-  // Si la rama de cada tarea tomada se movió, que es lo único barato que distingue una tarea larga de
-  // una abandonada. Sin repositorio resoluble el mapa queda vacío y el aviso vuelve a mirar sólo la
-  // fecha, que es lo que había antes: degrada, no rompe.
-  const activity = new Map()
-  for (const claim of claims.filter((one) => !done.set.has(one.slug))) {
-    const at = R.lastCommit(R.repoOf(path.join(root, '..'), claim.service), CL.branchOf(claim.slug))
-    if (at) activity.set(claim.slug, at)
-  }
-  warnings.push(...CL.warnings({ claims, done, today: TODAY(), activity }))
-  const recurring = RC.read(root)
-  errors.push(...RC.validate(recurring))
-  warnings.push(...RC.warnings(RC.status({ ...recurring, done, today: TODAY() })))
-  warnings.push(...IB.warnings(root, done, config))
-  warnings.push(...AD.sealWarnings(root))
-  warnings.push(...R.unrecordedHumanActions(path.resolve(root, '..'), P.readHumanActions(root)))
-  warnings.push(...AP.warnings(path.resolve(root, '..')))
-  warnings.push(...TR.warnings(path.resolve(root, '..')))
-
-  // Lo que `upgrade` conserva por estar editado deja de recibir mejoras, y eso es una deuda que no
-  // avisa sola: la instancia queda con medio molde viejo y todo se ve normal. Sale acá para que se vea
-  // en cada corrida y no sólo el día que alguien actualiza.
-  const congelados = O.localChanges(path.resolve(root, '..'))
-  if (congelados.length) {
-    warnings.push(`${congelados.length} archivo(s) del molde congelados por edición local; `
-      + '`upgrade` los conserva y no les trae mejoras')
-  }
-
-  // Y lo que `upgrade` no retiró porque no pudo demostrar que fuera suyo: queda ahí, sin colgar de
-  // ningún mecanismo, hasta que alguien lo mueva o lo borre. Se cuenta por lo mismo que los congelados
-  // — un resto que no se ve se vuelve permanente.
-  const restos = O.RETIRED_COMPARTIDO.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
-  if (restos.length) {
-    warnings.push(`${restos.length} ruta(s) retiradas siguen en disco con contenido tuyo `
-      + `(${restos.join(', ')}); Cauce ya no las distribuye ni las toca`)
-  }
-
-  const integration = I.validate(path.resolve(root, '..'))
-  errors.push(...integration.errors)
-  warnings.push(...integration.warnings)
-
-  warnings.push(...SR.competingSections(root))
-  // Sobrescribir una entrada de system/ es legítimo y esperado; lo que no puede pasar es que
-  // ocurra en silencio, porque esa entrada deja de recibir las mejoras del toolkit.
-  for (const override of O.overrides(path.resolve(root, '..'))) {
-    // Y con qué se queda el proyecto: un override sano redefine lo que reemplaza, y el que deja IDs
-    // afuera los retira sin decirlo. Nombrarlos es lo único que separa una decisión de un descuido.
-    const retired = override.collection === 'planning/rules'
-      ? SR.retiredByOverride(root, override.project)
-      : []
-    warnings.push(`${override.collection}/${override.project} sobrescribe ${override.system} `
-      + `(override explícito)${retired.length ? `; deja de regir ${retired.join(', ')}` : ''}`)
-  }
-  // Y lo que instaló cada runner, contra esas mismas reglas (caso 099).
-  warnings.push(...RL.staleLines(path.resolve(root, '..')))
-  // Misma regla para los cargos, que es donde más caro sale: un fork se hace una vez y se olvida.
-  const FK = require('../agents/fork')
-  for (const entry of FK.drift(path.resolve(root, '..'))) warnings.push(FK.driftLine(entry))
-
-  warnings.push(...OB.missingSections(path.resolve(root, '..')))
-  warnings.push(...OB.orphanCredentials(path.resolve(root, '..')))
-
-  if (cli.has('--json')) {
-    console.log(JSON.stringify({
-      ok: !errors.length,
-      epics: epics.length,
-      queued: backlog.length,
-      done: done.entries.length,
-      wips: wips.map((one) => one.task),
-      errors,
-      warnings,
-    }))
-    if (errors.length) process.exit(1)
-    return
-  }
-
-  for (const warning of warnings) console.warn(`⚠ ${warning}`)
-  for (const error of errors) console.error(`✗ ${error}`)
-  if (errors.length) fail(`\n${errors.length} error(es), ${warnings.length} advertencia(s)`)
-  console.log(
-    `✓ planning válido: ${epics.length} épica(s), ${backlog.length} tarea(s) en cola, ` +
-      `${done.entries.length} terminada(s)`,
-  )
-}
-
 // Estado observable de planning sin mutar nada; base común de `tree` y de sus salidas.
 function treeJson({ epics, milestones, done, wips, inbox, queued, claims }) {
   const state = (slug) => done.set.has(slug) ? 'done' : queued.has(slug) ? 'queued' : 'pending'
@@ -407,6 +223,18 @@ function context(dir, cli) {
   // Tu propio nombre en una tarea «ajena» es la señal de que sos vos desde otro runner, y sin decirlo se
   // lee como que alguien te ganó la tarea.
   const dueño = (one) => (one.owner === report.owner ? `${one.owner} — vos, desde otro runner` : one.owner)
+  // Que el reclamo sea tuyo desde otro id ya se decía; que además haya un **plan escrito** bajo ese id, no.
+  // Esa es la mitad que cuesta la sesión: los pasos ya hechos están en un archivo que nadie nombra, y el id
+  // que lo recupera es justo el que esta sesión no supo deducir. Los dos datos están en el reclamo.
+  const tomadas = () => {
+    for (const one of report.taken) {
+      console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+      if (one.owner === report.owner && one.wip) {
+        console.log(`PLAN   ${one.slug}: su plan está en wip/${one.wip} — retomalo con `
+          + `\`export CAUCE_RUNNER=${one.runner}\``)
+      }
+    }
+  }
   const espera = () => {
     for (const one of report.waiting) {
       console.log(`WAIT   ${one.slug}: espera a ${one.dep}${one.owner ? ` (${one.owner})` : ''}`)
@@ -424,7 +252,7 @@ function context(dir, cli) {
     if (next) console.log(`EPIC   ${next.num}: ${next.title} — sin promover`)
     // Mismo motivo que `blocked` arriba, con otra causa: acá la cola no la traba una persona, la tiene
     // el equipo, y lo que corresponde es hablar con quien la tiene.
-    for (const one of report.taken) console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+    tomadas()
     espera()
     for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
     due()
@@ -452,7 +280,7 @@ function context(dir, cli) {
   console.log(report.claimed
     ? `CLAIM  tuya desde el reclamo (${report.owner})`
     : `CLAIM  libre — tomala con \`ops claim <planning> ${report.task.slug}\``)
-  for (const one of report.taken) console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+  tomadas()
   espera()
   if (report.blockedTasks.length) console.log(`SKIP   ${report.blockedTasks.join(', ')} (acción humana abierta)`)
   for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
@@ -489,4 +317,4 @@ function recurring(dir, cli) {
   }
 }
 
-module.exports = { check, evidence, tree, context, recurring }
+module.exports = { evidence, tree, context, recurring }