@ingeniomaps/cauce 0.67.0 → 0.69.0

package/CHANGELOG.md

@@ -14,6 +14,56 @@ 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.69.0] - 2026-09-07
+
+### Agregado
+
+- **`planning/RECURRING.md`: el trabajo que vuelve se declara una vez.** Actualizar dependencias, revisar
+  quién tiene acceso a producción, mirar el gasto del mes: una fila con su cadencia —`mensual`,
+  `trimestral`, `semestral` o `anual`— y la celda de tarea escrita como la cola de su línea de BACKLOG,
+  así que la aceptación se decide una vez y no se improvisa en cada vuelta.
+
+  **Nada se dispara.** No hay cron ni cola: el vencimiento se calcula cuando alguien corre el CLI, y rueda
+  desde el período que cerró la última vuelta en `DONE.md` en vez de una celda que haya que acordarse de
+  actualizar. `node tools/ops.js recurring planning` dice qué venció, y `--promote <qué>` emite la línea de
+  esa vuelta —la emite y no la escribe: pegarla en `BACKLOG.md` es el acto de promoción—. `check` rechaza
+  la fila ilegible y avisa la vencida sin frenar nada; `context` la nombra con `DUE`. Postergar se escribe
+  a mano con su razón, compra un período, y tres seguidas se avisan porque ahí lo que falla es la cadencia.
+
+  **Lo que te pide algo**: el archivo llega vacío con esta actualización y, hasta que declares una fila, el
+  motor no dice una palabra. Y si tu runner ya está andando, la regla nueva que necesita está en
+  `AGENTS.md`: una recurrencia vencida no la promueve él, por más que `context` la nombre sola.
+
+## [0.68.0] - 2026-09-07
+
+### Cambiado
+
+- **`upgrade` deja de borrar una ruta retirada cuyo contenido no puede probar suyo.** Retirar una ruta
+  nunca volvió al toolkit dueño de lo que hay adentro, y hasta acá se borraba el directorio entero: quien
+  tenía sus propios workflows en `automatization/workflows` los perdía sin confirmación y sin vuelta
+  atrás. De las seis rutas retiradas, cuatro viven bajo `system/` o son un archivo con nombre del
+  toolkit y se siguen retirando igual; las dos que un proyecto también usa para lo suyo
+  —`automatization/runners` y `automatization/workflows`— se conservan.
+
+  **Lo que te pide algo**: esas dos rutas quedan en disco con lo que tengas adentro, la corrida te dice
+  cuántos archivos son, y `check` las cuenta en cada corrida hasta que las muevas o las borres. Si lo
+  que tenés ahí son restos viejos del toolkit y querés limpiarlos, `--force` las retira.
+
+- **La regla R9 dice cómo se prueba una quita.** Una prueba que comprueba que aparece lo nuevo no
+  comprueba que desapareció lo viejo, y lo que se quita tiene dependientes que no se anuncian —el
+  mensaje que afirmaba la invariante, la condición que la deducía—. Sale de una regresión de 0.67.0 que
+  entró exactamente por ahí.
+
+### Corregido
+
+- **El informe de `upgrade` afirmaba descartes que no ocurrieron.** 0.67.0 pasó a conservar los archivos
+  editados y la salida siguió enumerándolos como `− descartado tu cambio en …`, uno por uno, después de
+  la línea que anuncia que terminó bien. En una instancia real fueron diecinueve renglones falsos, y
+  entre ellos iba la única línea destructiva verdadera de esa corrida, indistinguible. Ahora el informe
+  recibe qué pasó —descartado, conservado, pendiente— en vez de deducirlo de una condición que dejó de
+  valer, y la línea «planning, organization y todo lo propio quedaron intactos» sale justo cuando es
+  cierto, que es cuando se conservó algo.
+
 ## [0.67.0] - 2026-09-07
 
 ### Agregado

package/README.md

@@ -9,6 +9,8 @@ el contexto de cada empresa vive en su propia instancia.
 - Una tarea tiene una sola fuente de verdad durante todo su ciclo de vida.
 - Una sesión interrumpida se recupera desde `WIP.md`, sin reconstruir la intención.
 - Las ideas del agente no entran solas a la cola: quedan en `INBOX.md` hasta promoción humana.
+- El trabajo que vuelve cada tanto se declara una vez en `RECURRING.md`; el CLI dice cuándo venció y
+  nadie lo encola solo.
 - Épicas, criterios, tareas y evidencia son validados de forma determinista.
 - Vive en su propia carpeta `ops/` dentro del repo, como sidecar `proyecto-ops` para varios repos, o
   embebido en la raíz.
@@ -175,6 +177,11 @@ idea → INBOX → roadmap → BACKLOG → WIP → DONE → done/epic-NNN.md
 5. Tras Build, Review, Verify y QA, mueve la entrada a `DONE.md` con evidencia.
 6. Al cerrar la épica, ejecuta `ops archive` para mover su evidencia a un histórico inmutable.
 
+Lo que vuelve cada tanto —actualizar dependencias, revisar accesos, mirar el gasto del mes— entra por
+un costado: se declara una vez en `RECURRING.md` con su cadencia, y `ops recurring planning` dice qué
+venció y emite la línea de esa vuelta. Nada se dispara; pegarla en `BACKLOG.md` es el paso 3 de
+arriba, hecho por una persona.
+
 Lee [template/planning/PROTOCOL.md](template/planning/PROTOCOL.md) para el contrato completo y
 [template/planning/FLOW.md](template/planning/FLOW.md) para operar el ciclo.
 

package/engine/cli/args.js

@@ -7,7 +7,7 @@
 // Banderas que consumen el argumento siguiente: su valor no es un posicional.
 const VALUED_FLAGS = new Set([
   '--name', '--mode', '--fixture', '--period', '--record', '--runner', '--integration',
-  '--task',
+  '--task', '--promote',
 ])
 
 // Qué acepta cada comando, y a la vez qué comandos existen. Una bandera desconocida se rechaza en vez
@@ -20,6 +20,7 @@ const FLAGS = {
   check: ['--json'],
   tree: ['--json', '--no-color'],
   context: ['--json'],
+  recurring: ['--json', '--promote'],
   evidence: ['--json', '--task'],
   upgrade: ['--check', '--force'],
   destroy: ['--force'],

package/engine/cli/instance.js

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

package/engine/cli/ops.js

@@ -143,6 +143,7 @@ function usage() {
   ops check <planning-dir> [--json]
   ops tree <planning-dir> [--no-color] [--json]
   ops context <planning-dir> [--json]
+  ops recurring <planning-dir> [--promote <qué>] [--json]
   ops evidence <planning-dir> [--task <slug>] [--json]
   ops upgrade <ops-root> [--check] [--force]
   ops destroy <ops-root> [--force]
@@ -196,6 +197,7 @@ async function run(cli) {
   else if (command === 'check') PL.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)
   else if (command === 'evidence') PL.evidence(arg[1], cli)
   else if (command === 'upgrade') IN.upgrade(arg[1], cli)
   else if (command === 'destroy') IN.destroy(arg[1], cli)

package/engine/cli/planning.js

@@ -9,6 +9,7 @@ const P = require('../planning/parser')
 const B = require('../planning/business-rules')
 const PC = require('../planning/contracts')
 const SZ = require('../planning/sizing')
+const RC = require('../planning/recurring')
 const ST = require('../planning/state')
 const AD = require('../planning/adoption')
 const AP = require('../hooks/approval')
@@ -66,6 +67,10 @@ 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 = path.resolve(dir || '.')
   const errors = []
@@ -125,6 +130,12 @@ function check(dir, cli) {
     epics, milestones, done, wip, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
   }))
   warnings.push(...AD.report({ done, epics, adopted }))
+  // 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.
+  const recurring = RC.read(root)
+  errors.push(...RC.validate(recurring))
+  warnings.push(...RC.warnings(RC.status({ ...recurring, done, today: TODAY() })))
   warnings.push(...AD.sealWarnings(root))
   // Una aprobación vale para el conjunto que nombra, así que olvidada sigue autorizando
   // esas mismas rutas la próxima vez que alguien las stagee. No caduca sola: lo que la cierra es que se
@@ -144,6 +155,15 @@ function check(dir, cli) {
       + '`upgrade` los conserva y no les trae mejoras')
   }
 
+  // Y lo que `upgrade` no retiró porque no pudo demostrar que fuera suyo: queda ahí, sin colgar de
+  // ningún mecanismo, hasta que alguien lo mueva o lo borre. Se cuenta por lo mismo que los congelados
+  // — un resto que no se ve se vuelve permanente.
+  const restos = O.RETIRED_COMPARTIDO.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
+  if (restos.length) {
+    warnings.push(`${restos.length} ruta(s) retiradas siguen en disco con contenido tuyo `
+      + `(${restos.join(', ')}); Cauce ya no las distribuye ni las toca`)
+  }
+
   const integration = I.validate(path.resolve(root, '..'))
   errors.push(...integration.errors)
   warnings.push(...integration.warnings)
@@ -275,6 +295,11 @@ function context(dir, cli) {
     queued: state.milestones.reduce((total, milestone) => total + milestone.tasks.length, 0),
     blockedTasks: skipped,
     humanActions,
+    // Sólo las vencidas: la fila que todavía no vence no tiene nada que decirle a quien va a tomar una
+    // tarea, y una recurrencia que hablara siempre sería ruido en el único comando que se corre en cada
+    // vuelta. Que aparezca es la señal.
+    recurring: RC.status({ ...RC.read(root), done: state.done, today: TODAY() })
+      .filter((one) => one.overdue),
   }
   if (cli.has('--json')) return console.log(JSON.stringify(report))
 
@@ -290,9 +315,16 @@ function context(dir, cli) {
   // que una instancia recién arrancada —`onboard` deja filas pendientes y ninguna tarea todavía—
   // respondía «sin tarea disponible» y se tragaba las siete cosas que una persona tenía que desbloquear.
   // Es el comando que existe para decir qué toca ahora, contestando «nada» cuando lo que toca es eso.
+  const due = () => {
+    for (const one of report.recurring) {
+      const when = one.overdueDays === 0 ? 'vence hoy' : `vencida hace ${one.overdueDays} día(s)`
+      console.log(`DUE    ${one.id}: ${when}`)
+    }
+  }
   if (!report.task) {
     console.log('TASK   (sin tarea disponible)')
     for (const action of report.humanActions) console.log(`HUMAN  ${action.task}: ${action.action}`)
+    due()
     return
   }
   console.log(`TASK   ${report.task.slug}${report.task.tier ? ` [${report.task.tier}]` : ''}` +
@@ -315,6 +347,36 @@ function context(dir, cli) {
   console.log(`WIP    ${wip}`)
   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}`)
+  due()
+}
+
+// Qué trabajo recurrente vence, y la línea con la que se promueve. Emite esa línea y no la escribe:
+// `BACKLOG.md` es la cola de lo aprobado y la escribe una persona — ningún comando del motor la toca,
+// ni siquiera `integration promote`, que aterriza en el roadmap. Pegarla es el acto de promoción.
+function recurring(dir, cli) {
+  const root = path.resolve(dir || '.')
+  const file = RC.read(root)
+  if (!file.exists) return console.log(`= este planning no declara trabajo recurrente (${RC.FILE})`)
+  const state = RC.status({ ...file, done: P.readDone(root), today: TODAY() })
+  const promote = cli.value('--promote')
+  if (promote) {
+    const one = state.find((candidate) => candidate.id === promote)
+    if (!one) return fail(`${RC.FILE} no declara ${promote}`, 2)
+    // La línea sale sola por stdout para que se pueda pegar o redirigir sin recortar nada; el destino,
+    // que es lo único que falta decidir, va por stderr.
+    console.error(`Pegala en el hito que corresponda de BACKLOG.md:`)
+    return console.log(RC.taskLine(one, TODAY().slice(0, 7)))
+  }
+  if (cli.has('--json')) return console.log(JSON.stringify(state))
+  if (!state.length) return console.log(`= ${RC.FILE} no declara ninguna fila legible`)
+  for (const one of state) {
+    const when = one.overdue
+      ? (one.overdueDays === 0 ? 'vence hoy' : `vencida hace ${one.overdueDays} día(s)`)
+      : `vence ${one.due}`
+    const last = one.last ? `última ${one.last}` : 'nunca corrió'
+    const held = one.postponed ? `, postergada ${one.postponed}` : ''
+    console.log(`${one.overdue ? 'DUE' : 'OK '}  ${one.id.padEnd(16)} ${when}  (${last}${held})`)
+  }
 }
 
 // El historial de acciones humanas se acumula en un solo archivo y no por épica: una fila no pertenece
@@ -346,7 +408,7 @@ function adopt(dir) {
   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)
+  const today = TODAY()
   const slugs = pending.map((entry) => entry.slug)
   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'
@@ -404,4 +466,4 @@ function archive(dir, rawNum) {
   console.log(`✓ epic-${num}: ${entries.length} entrada(s) archivadas`)
 }
 
-module.exports = { check, evidence, tree, context, archive, adopt }
+module.exports = { check, evidence, tree, context, archive, adopt, recurring }

package/engine/cli/upgrade-report.js

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

package/engine/core/ownership.js

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

package/engine/planning/parser.js

@@ -193,6 +193,26 @@ function acceptanceConditions(value) {
   return text.split(';').map((one) => one.trim()).filter(Boolean).length
 }
 
+// Una línea de tarea, leída en un solo lugar: `readBacklog` la usa para armar la cola y `recurring.js`
+// para juzgar la línea que va a emitir. Es el mismo motivo por el que `TASK_LINE` no está duplicado —
+// lo que emite una y lee la otra tiene que ser la misma forma, o el emisor produce lo que el lector
+// descarta.
+function taskFromLine(line) {
+  const task = line.match(TASK_LINE)
+  if (!task) return null
+  const rest = task[3]
+  const acceptance = ((rest.match(ACCEPTANCE) || [])[1] || '').trim()
+  return {
+    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,
+    conditions: acceptanceConditions(acceptance),
+    criteria: criteriaRefs(rest),
+    noSplit: noSplitReason(rest),
+  }
+}
+
 function readBacklog(dir) {
   const text = withoutComments(read(path.join(dir, 'BACKLOG.md')))
   const milestones = []
@@ -208,19 +228,8 @@ function readBacklog(dir) {
       continue
     }
     if (/^##\s+/.test(line)) current = null
-    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,
-      conditions: acceptanceConditions(acceptance),
-      criteria: criteriaRefs(rest),
-      noSplit: noSplitReason(rest),
-    })
+    const task = current ? taskFromLine(line) : null
+    if (task) current.tasks.push(task)
   }
   return milestones
 }
@@ -302,16 +311,24 @@ const SEPARADORES = /^\|\s*:?-+/
 // afectada —`archive` reescribe `raw`, la línea original, no las celdas—, así que quitarlo no pierde nada.
 const celda = (cell) => cell.trim().replace(/\\\|/g, '|')
 
-function readHumanActions(dir) {
-  const lineas = withoutComments(read(path.join(dir, 'HUMAN_ACTIONS.md'))).split('\n')
-  // En markdown la cabecera es la fila anterior a la de separadores, diga lo que diga su primera celda.
-  // Se marcan todas y no la primera: un archivo con una tabla por sección tiene una cabecera por tabla,
-  // y con `findIndex` la segunda y la tercera vuelven a leerse como datos. Nada más se mueve, porque una
-  // fila de datos nunca está inmediatamente antes de los guiones.
+// Las filas de datos de las tablas de un texto, con las celdas ya normalizadas. Vive acá y no en cada
+// lector porque el escape del pipe tiene que leerse igual en los dos archivos que traen tabla: escrito
+// dos veces, una de las dos copias se pudre sin que nada falle.
+//
+// En markdown la cabecera es la fila anterior a la de separadores, diga lo que diga su primera celda.
+// Se marcan todas y no la primera: un archivo con una tabla por sección tiene una cabecera por tabla,
+// y con `findIndex` la segunda y la tercera vuelven a leerse como datos. Nada más se mueve, porque una
+// fila de datos nunca está inmediatamente antes de los guiones.
+function tableRows(text) {
+  const lineas = text.split('\n')
   const cabeceras = new Set(lineas.map((line, i) => (SEPARADORES.test(line) ? i - 1 : -1)))
-  const rows = lineas
+  return lineas
     .filter((line, i) => /^\|/.test(line) && !SEPARADORES.test(line) && !cabeceras.has(i))
     .map((line) => ({ line, cells: line.split(SEPARADOR).slice(1, -1).map(celda) }))
+}
+
+function readHumanActions(dir) {
+  const rows = tableRows(withoutComments(read(path.join(dir, 'HUMAN_ACTIONS.md'))))
   // El literal queda como resguardo de la tabla escrita sin su fila de separadores: markdown no la
   // renderiza como tabla, y este parser lee sus filas igual.
   return rows.filter(({ cells }) => cells.length >= 4 && !/^tarea$/i.test(cells[0]))
@@ -362,6 +379,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,
+  acceptanceConditions, tableRows, taskFromLine,
   readInbox, readHumanActions,
 }

package/engine/planning/recurring.js

@@ -0,0 +1,148 @@
+'use strict'
+
+// El contrato de `RECURRING.md`: qué se declaró que vuelve, cuándo vence y qué línea se promueve.
+// No ejecuta ni encola —eso lo decide una persona editando `BACKLOG.md`—; acá se lee el archivo y se
+// calcula una fecha, que es todo lo que la máquina puede aportar sin decidir por nadie.
+//
+// La fecha de hoy entra por parámetro. Preguntarla adentro dejaría cada prueba de vencimiento válida
+// sólo el día que se escribió, y el vencimiento es justamente lo único que este módulo calcula.
+
+const path = require('node:path')
+const P = require('./parser')
+
+const FILE = 'RECURRING.md'
+
+// Vocabulario cerrado, en meses, por la misma razón que el estado de `HUMAN_ACTIONS.md`. `semanal` no
+// está y no es un olvido: el período viaja en el slug de cada vuelta con grano de mes, así que dos
+// vueltas de la misma semana no se distinguirían.
+const CADENCES = { mensual: 1, trimestral: 3, semestral: 6, anual: 12 }
+
+const ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+const DATE = /^\d{4}-\d{2}-\d{2}$/
+// `- **qué** AAAA-MM-DD — razón`. El nombre en negrita adelante es la misma convención del INBOX, y por
+// el mismo motivo: es con lo que se cita la fila desde otro lado.
+const POSTPONEMENT = /^-\s+\*\*([^*]+)\*\*\s+(\S+)\s+[—-]\s+(.+)$/
+
+// Suma meses sobre `AAAA-MM-DD` en UTC. El día se recorta al último del mes destino: un ancla escrita
+// el 31 no puede caer en un 31 de febrero, y correrla al 3 de marzo movería la vuelta de mes.
+function addMonths(iso, months) {
+  const [year, month, day] = iso.split('-').map(Number)
+  const target = new Date(Date.UTC(year, month - 1 + months, 1))
+  const last = new Date(Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0)).getUTCDate()
+  target.setUTCDate(Math.min(day, last))
+  return target.toISOString().slice(0, 10)
+}
+
+function daysBetween(from, to) {
+  return Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 86400000)
+}
+
+// Las dos listas del archivo, cada una acotada a su sección. Buscarlas en el texto entero haría que una
+// viñeta de la prosa —el archivo explica sus propias columnas con viñetas— entrara como postergación.
+function read(dir) {
+  const text = P.withoutComments(P.read(path.join(dir, FILE)))
+  if (!text.trim()) return { exists: false, rows: [], postponements: [] }
+  const rows = P.tableRows(P.section(text, /Recurrencias/))
+    // El literal, por el mismo motivo que en `readHumanActions`, donde está escrito.
+    .filter(({ cells }) => cells.length >= 4 && !/^qué$/i.test(cells[0]))
+    .map(({ line, cells }) => ({
+      id: cells[0], cadence: cells[1], since: cells[2], task: cells[3], raw: line,
+    }))
+  const postponements = P.section(text, /Postergaciones/).split('\n')
+    .filter((line) => /^-\s/.test(line))
+    .map((line) => {
+      const match = line.match(POSTPONEMENT)
+      return match
+        ? { id: match[1].trim(), date: match[2], reason: match[3].trim(), raw: line }
+        : { id: '', date: '', reason: '', raw: line }
+    })
+  return { exists: true, rows, postponements }
+}
+
+// La línea que se pega en BACKLOG. La celda de la tabla es literalmente la cola de esa línea, así que
+// lo que una persona escribió una vez es lo que se promueve, sin retipear.
+function taskLine(row, period) {
+  return `- [ ] **${row.id}-${period}** — ${row.task}`
+}
+
+function validate({ exists, rows, postponements }) {
+  if (!exists) return []
+  const errors = []
+  const seen = new Set()
+  for (const row of rows) {
+    const at = `${FILE} ${row.id || '(fila sin nombre)'}`
+    if (!ID.test(row.id)) errors.push(`${at}: el identificador va en minúsculas, sin espacios`)
+    else if (seen.has(row.id)) errors.push(`${FILE}: identificador duplicado ${row.id}`)
+    seen.add(row.id)
+    if (!CADENCES[row.cadence]) {
+      errors.push(`${at}: cadencia "${row.cadence}" fuera de ${Object.keys(CADENCES).join(' | ')}`)
+    }
+    if (!DATE.test(row.since)) errors.push(`${at}: Desde debe ser AAAA-MM-DD`)
+    // Se juzga la línea armada y no la celda suelta: lo que se promueve es esa línea, y quien la va a
+    // leer es el mismo lector de BACKLOG. Una celda que pasa acá y una línea que BACKLOG rechaza es el
+    // error que aparece un mes después, con la tarea ya pegada.
+    const task = P.taskFromLine(taskLine(row, '0000-00'))
+    if (!task) errors.push(`${at}: la celda no arma una línea de tarea`)
+    else {
+      if (!task.acceptance) errors.push(`${at}: la tarea no declara _Aceptación: ..._`)
+      if (!task.service) errors.push(`${at}: la tarea no declara (service: <ruta>)`)
+    }
+  }
+  for (const one of postponements) {
+    if (!one.id) {
+      errors.push(`${FILE}: una postergación se escribe "- **qué** AAAA-MM-DD — razón": ${one.raw.trim()}`)
+      continue
+    }
+    if (!DATE.test(one.date)) errors.push(`${FILE}: postergación de ${one.id}: la fecha va en AAAA-MM-DD`)
+    if (!seen.has(one.id)) errors.push(`${FILE}: postergación de ${one.id}, que la tabla no declara`)
+  }
+  return errors
+}
+
+// El último período cerrado, leído de DONE y no de una celda: una fecha que alguien tiene que acordarse
+// de actualizar miente a los tres meses, y la entrada de DONE es además la evidencia de que se hizo.
+function lastPeriod(id, done) {
+  const pattern = new RegExp(`^${id}-(\\d{4}-\\d{2})$`)
+  const periods = done.entries.map((entry) => (entry.slug.match(pattern) || [])[1]).filter(Boolean)
+  return periods.sort().pop() || ''
+}
+
+function status({ rows, postponements, done, today }) {
+  return rows
+    .filter((row) => ID.test(row.id) && CADENCES[row.cadence] && DATE.test(row.since))
+    .map((row) => {
+      const months = CADENCES[row.cadence]
+      const last = lastPeriod(row.id, done)
+      // Cerrada una vuelta, la siguiente se cuenta desde el período que la cerró; sin ninguna, desde el
+      // ancla escrita al declarar la fila. Es lo que hace rodante al vencimiento: saltearse una vuelta
+      // corre la próxima en vez de deber dos.
+      const base = last ? addMonths(`${last}-01`, months) : row.since
+      // Y las postergaciones que cuentan son las escritas después de que terminó el período cerrado:
+      // las anteriores ya las absorbió ese cierre, que es lo que reinicia el contador.
+      const from = last ? addMonths(`${last}-01`, 1) : row.since
+      const postponed = postponements.filter((one) => one.id === row.id && one.date >= from).length
+      const due = addMonths(base, months * postponed)
+      const overdueDays = daysBetween(due, today)
+      return {
+        id: row.id, cadence: row.cadence, task: row.task, last, due, postponed,
+        overdueDays, overdue: overdueDays >= 0,
+      }
+    })
+}
+
+function warnings(state) {
+  const lines = []
+  for (const one of state.filter((candidate) => candidate.overdue)) {
+    const when = one.overdueDays === 0 ? 'vence hoy' : `vencida hace ${one.overdueDays} día(s)`
+    lines.push(`${FILE}: ${one.id} ${when} (${one.due})`)
+  }
+  // Tres seguidas no son un atraso: son una fila que no se va a hacer con la cadencia que declara. El
+  // contador es la alarma, y por eso se cuenta desde el último cierre y no desde siempre.
+  for (const one of state.filter((candidate) => candidate.postponed >= 3)) {
+    lines.push(`${FILE}: ${one.id} postergada ${one.postponed} veces desde el último cierre; `
+      + 'revisá la cadencia o la fila')
+  }
+  return lines
+}
+
+module.exports = { FILE, read, validate, status, warnings, taskLine }

package/package.json

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

package/template/AGENTS.md

@@ -153,6 +153,8 @@ muta nada.
 - `node tools/ops.js context planning` — gate, mutex de WIP y la tarea que corresponde ahora, con su
   aceptación y sus criterios. Es la entrada correcta para empezar a trabajar.
 - `node tools/ops.js tree planning` — panorama de roadmap, backlog, WIP, inbox y done.
+- `node tools/ops.js recurring planning [--promote <qué>]` — qué trabajo recurrente venció y con
+  qué línea se promueve. Emite esa línea; escribirla en `BACKLOG.md` es de una persona.
 - `node tools/ops.js check planning` — validación de contratos y trazabilidad.
 - `node tools/ops.js evidence planning [--task <slug>]` — contrasta la evidencia de una entrada de DONE
   contra lo que no escribió su autor: si el artefacto que `tests:` nombra existe en las raíces de
@@ -161,8 +163,8 @@ muta nada.
   nombrada haya corrido —eso depende del runner, y varios no la nombran al pasar— ni reemplaza a leer
   su fuente, que es lo que R9 pide.
 
-Los cuatro aceptan `--json`. Leer `BACKLOG.md`, `WIP.md` o `HUMAN_ACTIONS.md` completos sólo cuando haga
-falta editarlos o cuando el CLI no responda la pregunta.
+Los cinco aceptan `--json`. Leer `BACKLOG.md`, `WIP.md`, `HUMAN_ACTIONS.md` o `RECURRING.md` completos
+sólo cuando haga falta editarlos o cuando el CLI no responda la pregunta.
 
 ## Autonomía
 
@@ -178,6 +180,11 @@ Nunca amplía el alcance, promueve sus propias ideas, reescribe el proceso duran
 `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`.
 
+Una recurrencia vencida tampoco la promueve, y ésta es la que más se parece a una excepción: la
+aceptación ya está escrita, la fecha la calculó el CLI y `context` la nombra sola. Nada de eso es la
+aprobación que pide BR-OPS-002 — `context` la nombra para que la vea una persona, y quien la pega en
+`BACKLOG.md` es esa persona.
+
 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.

package/template/Makefile

@@ -1,6 +1,6 @@
 .DEFAULT_GOAL := help
 
-.PHONY: help check tree context upgrade destroy automation-check
+.PHONY: help check tree context recurring upgrade destroy automation-check
 .PHONY: integration-check integration-sync require-key integration-promote
 .PHONY: require-agent agent-learn agent-propose agent-evaluate require-flow flow-list flow-check flow-show
 .PHONY: install-claude install-codex install-gemini install-antigravity
@@ -23,6 +23,9 @@ tree: ## Muestra roadmap, backlog, WIP y Done
 context: ## Muestra el contexto mínimo de la tarea vigente
 	@node tools/ops.js context planning
 
+recurring: ## Muestra qué trabajo recurrente vence y con qué línea se promueve
+	@node tools/ops.js recurring planning
+
 # `init` fija la versión exacta del motor, así que `npm update` no la mueve: hay que pedir @latest.
 # Sin este primer paso `upgrade` compara contra el motor instalado y contesta «al día» para siempre.
 destroy: ## Muestra qué se pierde al borrar esta instancia (borrar exige --force a mano)

package/template/planning/FLOW.md

@@ -15,6 +15,8 @@ INBOX ──promoción humana──▶ roadmap ──historias listas──▶ B
 
 ## Preparar
 
+0. Si `ops recurring planning` nombra una recurrencia vencida, decidir si esta vuelta se promueve —el
+   comando emite su línea— o se posterga con su razón.
 1. Curar una idea desde INBOX.
 2. Escribir una épica con resultados observables, contexto actual y criterios `C1..CN`.
 3. Descomponerla en historias de máximo cuatro horas, cada una rastreada a uno o más criterios.

package/template/planning/PROTOCOL.md

@@ -20,6 +20,11 @@ invariantes.
   en el vocabulario cerrado `pendiente | resuelta` —la fecha puede ir detrás—. Mientras la fila no
   esté resuelta, su tarea no se toma; un estado fuera del vocabulario es un error de `check` y no un
   bloqueo silencioso.
+- Recurrencia: fila `| qué | cada | desde | tarea y aceptación |` bajo `## Recurrencias`, con `cada` en
+  el vocabulario cerrado `mensual | trimestral | semestral | anual` y la celda de tarea escrita como la
+  cola de su línea de BACKLOG. Vencer no bloquea: cada vuelta se promueve con el período en el slug
+  —`<qué>-AAAA-MM`— y esa promoción la escribe una persona. Postergar se registra bajo
+  `## Postergaciones` con `- **qué** AAAA-MM-DD — razón`.
 - WIP activo: frontmatter y checklist; inactivo: `status: IDLE`.
 
 ## Gates de arranque

package/template/planning/README.md

@@ -19,6 +19,7 @@ Se decide antes de ejecutar y no cambia dentro de una tarea.
 | Pieza | Responsabilidad |
 |---|---|
 | `INBOX.md` | Ideas y deuda sin autorización de ejecución. |
+| `RECURRING.md` | Trabajo que vuelve cada tanto; declarado, nunca encolado solo. |
 | `roadmap/` | Especificaciones de épicas y criterios del QUÉ. |
 | `adr/` | Decisiones arquitectónicas durables. |
 | `business-rules/` | Invariantes observables de negocio y operación. |

package/template/planning/RECURRING.md

@@ -0,0 +1,77 @@
+# Trabajo que vuelve
+
+Lo que hay que hacer cada tanto y no una vez: actualizar dependencias, revisar quién tiene acceso a
+producción, mirar el gasto del mes, recorrer el INBOX entero. No es una categoría de trabajo —puede ser
+cualquier cosa— sino una forma de declararlo: acá vive el enunciado, y cada vuelta se promueve a
+`BACKLOG.md` como una tarea más.
+
+**Nada se dispara.** Este archivo no ejecuta ni encola: declara cada cuánto algo debería mirarse, y el
+vencimiento se calcula cuando alguien corre el CLI. Promover sigue siendo un acto humano, igual que en
+`INBOX.md`. Lo que la máquina aporta es que no se te pase, no decidir por vos.
+
+## Cada fila
+
+- **Qué** — un identificador estable, en minúsculas y sin espacios. No cambia nunca: es lo que ata la
+  fila a las vueltas que ya se hicieron.
+- **Cada** — vocabulario cerrado: `mensual`, `trimestral`, `semestral`, `anual`. No hay expresiones de
+  cron, y esa ausencia es el enunciado: si hiciera falta una, lo que estarías declarando es otra cosa.
+  Tampoco hay `semanal`, porque el slug de cada vuelta tiene grano de mes.
+- **Desde** — `AAAA-MM-DD`. Ancla la primera vuelta y después no se toca.
+- **Tarea y aceptación** — lo que se va a promover, con su aceptación observable escrita una sola vez y
+  con calma. Improvisada en cada vuelta, la misma recurrencia termina significando cosas distintas sin
+  que nadie lo decida.
+
+## Cuándo vence
+
+Se cuenta desde la última vez que se cerró, no desde un día fijo del calendario: una recurrencia
+atrasada no debe tres vueltas, debe una, la que no se hizo.
+
+La fecha de ese último cierre **no se escribe acá**. Sale de `DONE.md` — la entrada más nueva cuyo slug
+sea `<qué>-AAAA-MM`—, que es la evidencia de que efectivamente se hizo y no la afirmación de que se
+hizo. Una celda que alguien tiene que acordarse de actualizar miente a los tres meses, y el estado no se
+copia para representar progreso.
+
+Por eso cada vuelta se promueve con su período en el slug —`deps-2026-10`, después `deps-2026-11`— y no
+con el identificador pelado. Reusarlo tiene además su propio castigo: dos entradas de DONE con el mismo
+slug son un error de `check`, y ese error llega un mes tarde.
+
+## Lo que este archivo no es
+
+- **No bloquea.** Una recurrencia vencida no frena ninguna tarea. Lo que sí frena vive en
+  `HUMAN_ACTIONS.md`; ponerlo acá entrena a ignorar lo que vence, que es lo único que este archivo hace.
+- **No es una cola.** Nada de acá está aprobado para ejecutarse. `BACKLOG.md` sigue siendo la única cola
+  y se escribe a mano.
+- **No es el INBOX.** Una idea se promueve una vez y se borra; esto vuelve, y por eso se queda.
+
+## Recurrencias
+
+| Qué | Cada | Desde | Tarea y aceptación observable |
+|---|---|---|---|
+
+<!--
+| deps | mensual | 2026-09-01 | Actualizar dependencias. _Aceptación: `npm outdated` no deja una versión mayor sin decisión escrita y la puerta queda verde._ |
+| accesos | trimestral | 2026-07-01 | Revisar quién tiene acceso a producción. _Aceptación: cada cuenta activa figura en `organization/`, y las demás están dadas de baja._ |
+| costos | mensual | 2026-09-01 | Revisar el gasto de infraestructura del mes. _Aceptación: cada línea que subió más de 20% tiene una razón escrita._ |
+| inbox | trimestral | 2026-08-01 | Recorrer el INBOX entero. _Aceptación: ninguna viñeta queda sin decisión de promover, dejar o borrar._ |
+-->
+
+## Postergaciones
+
+Saltear una vuelta es legítimo y se escribe. Lo que no puede perderse es la razón: sin ella queda una
+recurrencia atrasada y nadie sabe si fue una decisión o un olvido.
+
+Postergar compra **un período**, no una fecha elegida: la vuelta siguiente vuelve a preguntar. Las
+postergaciones se cuentan desde el último cierre y el contador se reinicia al cerrar. Tres seguidas no
+son un atraso — son una recurrencia mal declarada, y lo que hay que revisar es la cadencia o la fila
+entera.
+
+La salida definitiva es borrar la fila. «Esto ya no lo hacemos» es un diff que alguien revisa; un estado
+`retirada` es una línea que nadie vuelve a leer.
+
+Cada una se escribe con el nombre de su fila en negrita, la fecha y la razón —`- **qué** AAAA-MM-DD —
+razón`—, igual que un ítem del INBOX y por el mismo motivo: el nombre es con lo que se cita la fila.
+Sólo se agrega al final; una línea escrita acá no se edita ni se borra.
+
+<!--
+- **deps** 2026-10-02 — Esperando el release de la 2.0; subir dependencias antes lo ensucia.
+-->

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

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