@ingeniomaps/cauce 0.68.0 → 0.69.0

package/CHANGELOG.md

@@ -14,6 +14,26 @@ 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

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/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
@@ -284,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))
 
@@ -299,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}]` : ''}` +
@@ -324,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
@@ -355,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'
@@ -413,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/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',

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.68.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.
+-->