@ingeniomaps/cauce 0.53.2 → 0.54.0

package/engine/agents/learning-files.js

@@ -9,7 +9,6 @@ const fs = require('node:fs')
 const path = require('node:path')
 const catalog = require('./catalog')
 const ownership = require('../core/ownership')
-const { section } = require('../planning/parser')
 
 const REQUIRED_SECTIONS = [
   'Hallazgos',
@@ -83,6 +82,12 @@ function frontmatterState(text, fallback) {
   return ((text.match(/^status:\s*(\S+)\s*$/m) || [])[1] || fallback).toLowerCase()
 }
 
+// La vigente de un período: con revisiones abiertas, la última. La usan componer y cerrar.
+function lastOfPeriod(dir, period) {
+  const names = proposalFiles(dir).filter((name) => name.match(PROPOSAL_NAME)[1] === period)
+  return names.length ? names[names.length - 1] : ''
+}
+
 function proposalState(text) {
   return frontmatterState(text, 'proposed')
 }
@@ -107,5 +112,5 @@ function reportFiles(dir) {
 module.exports = {
   REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME,
   assertWritableTeam, assertWritable, isoDate, month,
-  proposalOrder, proposalFiles, frontmatterState, proposalState, reportFiles,
+  proposalOrder, proposalFiles, frontmatterState, proposalState, reportFiles, lastOfPeriod,
 }

package/engine/agents/learning-seal.js

@@ -0,0 +1,123 @@
+'use strict'
+
+// Cerrar una propuesta: los dos destinos que la sacan del ciclo y el historial que los registra.
+//
+// Vive aparte de `learning.js` porque son dos propósitos con vidas distintas: allá se **compone** una
+// propuesta —leyendo informes y veredictos, decidiendo si hay algo que decir—, y acá se la **cierra**,
+// que es un cambio de estado sobre un documento que ya existe. El umbral de 500 líneas fue lo que lo
+// hizo mirar; lo que decidió la división es que ninguna de las dos mitades necesita a la otra.
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { atomicWrite } = require('../core/files')
+const { isoDate, proposalFiles, proposalState, assertWritable, lastOfPeriod } = require('./learning-files')
+const { section } = require('../planning/parser')
+
+// El cuerpo sin sellar, en los dos estados que produce el ciclo: «pendiente» lo escribe el molde y
+// «aprobada» la firma. Lo lee la guarda de más abajo y lo reemplaza el sello, así que vive una vez.
+const UNSEALED = /^-[ \t]*Estado:[ \t]*(?:pendiente|aprobada)[ \t]*$/mi
+
+// El estado terminal del ciclo. Existía la firma, la aplicación y el historial, y faltaba justo el
+// paso que vuelve irrepetible lo ya hecho: `status:` nacía en `proposed` y nadie lo movía nunca.
+//
+// No era un dato desprolijo. `agent-promote` busca la propuesta más nueva y aplica si el estado dice
+// aprobada con responsable — y «aprobada y aplicada» cumple eso—, así que volver a correrlo sobre una
+// propuesta ya aplicada la aplicaba de nuevo. Como los cambios son aditivos por diseño, el resultado
+// no es un error visible sino un contrato con cada viñeta y cada fuente duplicadas.
+function seal(root, agent, period = '', kind = 'agent') {
+  const file = proposalFile(root, agent, period, kind)
+  const dir = path.dirname(file)
+  const text = fs.readFileSync(file, 'utf8')
+  const state = proposalState(text)
+  // Sellado es el documento entero, no su frontmatter. Mirando sólo `status` la salida temprana daba
+  // por hecho lo que faltaba: si algo movió el campo antes que el sello —quien aplica edita archivos, y
+  // mover `status` se le parece a su trabajo— el cuerpo se quedaba en «aprobada» para siempre, que es
+  // la contradicción que sellar existe para cerrar. Pasó con `growth-marketer/2026-09`.
+  if (state === 'applied' && !UNSEALED.test(text)) return { file, already: true }
+  if (!/^status:\s*\S+\s*$/m.test(text)) throw new Error(`${file} no declara status en su frontmatter.`)
+  // Un cargo llega acá después de `agent-promote`, que se niega si «Aprobación humana» no está firmada.
+  // Un recorrido no tiene ese workflow, así que sin esta puerta `--applied` sellaba una propuesta con
+  // «Estado: pendiente» y «Cambio propuesto: Por definir»: el frontmatter decía `applied` y el cuerpo
+  // decía lo contrario, dentro del mismo documento. Se comprueba para los dos porque la contradicción
+  // no depende de quién sea el sujeto, y para el cargo la puerta ya la pasó quien firmó.
+  const responsible = (text.match(/^-\s*Responsable:\s*(.+)$/m) || [])[1] || ''
+  const change = section(text, /Cambio propuesto/i).split('\n').slice(1).join('\n').trim()
+  const undecided = (value) => !value || /^(por definir|pendiente)\b/i.test(value)
+  if (undecided(responsible.trim()) || undecided(change)) {
+    throw new Error(
+      `${path.basename(file)} todavía no la decidió nadie: «Aprobación humana» necesita un responsable `
+      + 'y «Cambio propuesto» tiene que decir qué cambia. Aplicar es un acto humano y esto lo registra.',
+    )
+  }
+  const stamped = text
+    .replace(/^status:\s*\S+\s*$/m, 'status: applied')
+    // `aprobada` además de `pendiente`: cuando `seal` corre, la firma ya pasó y `sign-proposal.yml`
+    // dejó «aprobada», así que buscar sólo «pendiente» no reemplazaba nunca por el camino real. Las 24
+    // propuestas aplicadas del repositorio quedaron con `status: applied` y «- Estado: aprobada»: la
+    // contradicción entre frontmatter y cuerpo que la guarda de arriba dice evitar. La prueba no lo veía
+    // porque su fixture firmaba dejando «pendiente», un estado que producción no produce.
+    .replace(UNSEALED, '- Estado: aplicada')
+    .replace(/^-[ \t]*Fecha:[ \t]*por definir[ \t]*$/mi, `- Fecha: ${isoDate(new Date())}`)
+  atomicWrite(file, stamped)
+  // El historial sólo lo escribe alguien para los cargos —`agent-promote`— y nadie para los recorridos,
+  // así que el registro que la plantilla promete no existía nunca. Se escribe acá porque es determinista:
+  // la fecha, el documento, quién aprobó y qué dice que cambia, todo sale de lo que se acaba de sellar.
+  if (kind === 'flow') appendHistory(path.dirname(path.dirname(dir)), file, responsible.trim(), change)
+  return { file, already: false }
+}
+
+// Archivar es el tercer destino de una propuesta, y hasta ahora no existía: aplicarla, dejarla
+// esperando, o **mirarla y decidir que no cambia nada**. Ese tercero se venía haciendo mergeando el PR
+// sin firmar, que deja el documento en `proposed` para siempre — indistinguible de una que espera
+// trabajo. En septiembre quedaron dieciséis así, y el CLI iba a decir «1 sin aplicar» de cada una
+// mientras nadie tuviera nada que hacer con ellas.
+//
+// Se niega sobre una propuesta firmada, y ésa es toda la guarda que hace falta: firmar es autorizar un
+// cambio, así que lo que corresponde después es aplicarlo. Sin esto, archivar sería la vía para hacer
+// desaparecer trabajo autorizado sin ejecutarlo ni decirlo, que es peor que el contador ruidoso.
+// `--period 2026-08` nombra el período, no un archivo: con revisiones abiertas la que se resuelve es la
+// vigente de ese período. Resolverlo siempre a `2026-08.md` devolvía «ya estaba aplicada» y dejaba la
+// revisión sin sellar, que es justo el estado en que `agent-promote` la vuelve a aplicar. Una revisión
+// concreta se nombra entera —`--period 2026-08-r2`— y entonces manda ésa.
+function proposalFile(root, agent, period = '', kind = 'agent') {
+  const dir = path.join(assertWritable(root, agent, kind), 'learning', 'proposals')
+  const names = proposalFiles(dir)
+  if (!names.length) throw new Error(`${agent} no tiene propuestas en learning/proposals/.`)
+  const name = period
+    ? (/^\d{4}-\d{2}$/.test(period) ? lastOfPeriod(dir, period) : `${period}.md`)
+    : names[names.length - 1]
+  if (!name || !names.includes(name)) throw new Error(`${agent} no tiene la propuesta ${period || name}.`)
+  return path.join(dir, name)
+}
+
+function archive(root, agent, period = '', kind = 'agent') {
+  const file = proposalFile(root, agent, period, kind)
+  const text = fs.readFileSync(file, 'utf8')
+  const state = proposalState(text)
+  if (state === 'archived') return { file, already: true }
+  if (state === 'applied') throw new Error(`${path.basename(file)} ya está aplicada: archivarla la borraría del ciclo.`)
+  if (/^-[ \t]*Estado:[ \t]*aprobada[ \t]*$/mi.test(text)) {
+    throw new Error(
+      `${path.basename(file)} está firmada: lo que sigue es aplicarla con agent-promote, no archivarla. `
+      + 'Archivar es para lo que se miró y no cambia nada.',
+    )
+  }
+  atomicWrite(file, text
+    .replace(/^status:\s*\S+\s*$/m, 'status: archived')
+    .replace(/^-[ \t]*Estado:[ \t]*pendiente[ \t]*$/mi, '- Estado: archivada')
+    .replace(/^-[ \t]*Fecha:[ \t]*por definir[ \t]*$/mi, `- Fecha: ${isoDate(new Date())}`))
+  return { file, already: false }
+}
+
+// Una fila por propuesta aplicada. El cambio va en una línea: el documento entero está a un enlace, y
+// una tabla que lo repite entero deja de leerse.
+function appendHistory(target, file, responsible, change) {
+  const history = path.join(target, 'learning', 'HISTORY.md')
+  if (!fs.existsSync(history)) return
+  const line = change.split('\n').map((one) => one.trim()).filter(Boolean)[0] || ''
+  const row = `| ${isoDate(new Date())} | \`${path.basename(file)}\` | aplicada | ${responsible} `
+    + `| ${line.slice(0, 160)} |\n`
+  fs.appendFileSync(history, `${fs.readFileSync(history, 'utf8').endsWith('\n') ? '' : '\n'}${row}`)
+}
+
+module.exports = { seal, archive }

package/engine/agents/learning-sources.js

@@ -12,6 +12,26 @@ const {
   REQUIRED_SECTIONS, SUMMARY_MAX, frontmatterState, proposalFiles, proposalState, reportFiles,
 } = require('./learning-files')
 
+// Una propuesta firmada y sin aplicar no espera lo mismo que una sin firmar: en la primera la decisión
+// ya se tomó y el trabajo quedó detenido; la segunda está bien quieta hasta que alguien la lea.
+// `proposalState` no las distingue —mira el frontmatter, y la firma la escribe `sign-proposal.yml` en
+// el cuerpo—, así que las dos caían en el mismo `pending` y la que ya tenía autoridad para avanzar se
+// veía igual que la que no. Sin este aviso hay que acordarse, y dos propuestas firmadas el 2026-09-01
+// se habrían quedado ahí sin que nada lo dijera.
+const SIGNED = /^-[ \t]*Estado:[ \t]*aprobada[ \t]*$/mi
+// Los dos destinos que cierran una propuesta. `archived` es «se miró y no cambia nada»: no espera
+// trabajo, así que contarla como pendiente deja al cargo reportando deuda que nadie va a pagar — el
+// mismo defecto que el comentario de abajo describe para una aplicada.
+const CLOSED = new Set(['applied', 'archived'])
+
+// No es un error: firmar y aplicar son actos separados a propósito —OPS-004— y entre uno y otro puede
+// pasar tiempo legítimamente. Lo que no puede es no verse.
+function signedWarning(signed) {
+  if (!signed.length) return []
+  return [`${signed.length} propuesta(s) firmada(s) sin aplicar (${signed.join(', ')}): `
+    + 'la autorización ya está, falta `agent-promote`']
+}
+
 function evaluateTeam(root, slug) {
   const dir = path.dirname(require('../flows/registry').read(root, slug).file)
   const errors = []
@@ -21,14 +41,19 @@ function evaluateTeam(root, slug) {
   }
   const proposals = proposalFiles(path.join(dir, 'learning', 'proposals'))
   let pending = 0
+  const signed = []
   for (const name of proposals) {
     const text = fs.readFileSync(path.join(dir, 'learning', 'proposals', name), 'utf8')
     if (!/^automatic_apply:\s*false$/m.test(text)) errors.push(`${name}: automatic_apply debe ser false`)
     for (const section of REQUIRED_SECTIONS) {
       if (!text.includes(`## ${section}`)) errors.push(`${name}: falta sección ${section}`)
     }
-    if (proposalState(text) !== 'applied') pending += 1
+    if (!CLOSED.has(proposalState(text))) {
+      pending += 1
+      if (SIGNED.test(text)) signed.push(name)
+    }
   }
+  warnings.push(...signedWarning(signed))
   return { errors, warnings, proposals: proposals.length, pending, cases: 0 }
 }
 
@@ -135,6 +160,7 @@ function evaluate(root, agent) {
   }
   const proposals = proposalFiles(path.join(target, 'learning', 'proposals'))
   let pending = 0
+  const signed = []
   for (const name of proposals) {
     const text = fs.readFileSync(path.join(target, 'learning', 'proposals', name), 'utf8')
     if (!/^automatic_apply:\s*false$/m.test(text)) errors.push(`${name}: automatic_apply debe ser false`)
@@ -143,8 +169,12 @@ function evaluate(root, agent) {
     }
     // Contar sólo las que esperan algo. Una propuesta aplicada contada como propuesta deja al cargo
     // reportando trabajo pendiente para siempre, y es la misma confusión que permitía reaplicarla.
-    if (proposalState(text) !== 'applied') pending += 1
+    if (!CLOSED.has(proposalState(text))) {
+      pending += 1
+      if (SIGNED.test(text)) signed.push(name)
+    }
   }
+  warnings.push(...signedWarning(signed))
   // Los hallazgos que todavía no llegaron al contrato. No es un error —la propuesta que los tome
   // puede no haberse abierto aún—, pero sin decirlo un informe escrito y olvidado se ve igual que uno
   // ya incorporado: los dos son un archivo en `reports/`.
@@ -163,4 +193,4 @@ function evaluate(root, agent) {
   return { errors, warnings, proposals: proposals.length, pending, cases }
 }
 
-module.exports = { SOURCE_TIERS, CADENCES, cadence, evaluate, evaluateTeam }
+module.exports = { SOURCE_TIERS, cadence, evaluate, evaluateTeam }

package/engine/agents/learning.js

@@ -6,12 +6,13 @@ const catalog = require('./catalog')
 const { atomicWrite } = require('../core/files')
 // La misma lectura de secciones que usa el planning: repetirla acá sería una segunda copia del mismo
 // hecho, y una de las dos se pudre sin que nada falle (R11).
-const { section } = require('../planning/parser')
 const {
-  REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME, assertWritableTeam, assertWritable,
+  REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME, assertWritableTeam, assertWritable, lastOfPeriod,
   isoDate, month, proposalOrder, proposalFiles, frontmatterState, proposalState, reportFiles,
 } = require('./learning-files')
-const { SOURCE_TIERS, CADENCES, cadence, evaluate, evaluateTeam } = require('./learning-sources')
+// Cerrar una propuesta vive en su propio módulo; se reexporta para no mover a cada llamador.
+const { seal, archive } = require('./learning-seal')
+const { SOURCE_TIERS, cadence, evaluate, evaluateTeam } = require('./learning-sources')
 
 // El informe que ya entró a una propuesta. Nace en `draft` y nada lo movía nunca, así que el que se
 // consolidó y el que se escribió tarde —después de que la propuesta del período ya existía, y por eso
@@ -31,67 +32,6 @@ function markConsolidated(file) {
   atomicWrite(file, text.replace(front[0], `---\n${front[1]}\nstatus: consolidated\n---\n`))
 }
 
-// El estado terminal del ciclo. Existía la firma, la aplicación y el historial, y faltaba justo el
-// paso que vuelve irrepetible lo ya hecho: `status:` nacía en `proposed` y nadie lo movía nunca.
-//
-// No era un dato desprolijo. `agent-promote` busca la propuesta más nueva y aplica si el estado dice
-// aprobada con responsable — y «aprobada y aplicada» cumple eso—, así que volver a correrlo sobre una
-// propuesta ya aplicada la aplicaba de nuevo. Como los cambios son aditivos por diseño, el resultado
-// no es un error visible sino un contrato con cada viñeta y cada fuente duplicadas.
-function seal(root, agent, period = '', kind = 'agent') {
-  const dir = path.join(assertWritable(root, agent, kind), 'learning', 'proposals')
-  const names = proposalFiles(dir)
-  if (!names.length) throw new Error(`${agent} no tiene propuestas en learning/proposals/.`)
-  // `--period 2026-08` nombra el período, no un archivo: con revisiones abiertas la que se sella es la
-  // vigente de ese período. Resolverlo siempre a `2026-08.md` habría devuelto «ya estaba aplicada» y
-  // dejado la revisión sin sellar, que es justo el estado en que `agent-promote` la vuelve a aplicar.
-  // Una revisión concreta se puede nombrar entera —`--period 2026-08-r2`— y entonces manda esa.
-  const name = period
-    ? (/^\d{4}-\d{2}$/.test(period) ? lastOfPeriod(dir, period) : `${period}.md`)
-    : names[names.length - 1]
-  if (!name || !names.includes(name)) throw new Error(`${agent} no tiene la propuesta ${period || name}.`)
-  const file = path.join(dir, name)
-  const text = fs.readFileSync(file, 'utf8')
-  const state = proposalState(text)
-  if (state === 'applied') return { file, already: true }
-  if (!/^status:\s*\S+\s*$/m.test(text)) throw new Error(`${file} no declara status en su frontmatter.`)
-  // Un cargo llega acá después de `agent-promote`, que se niega si «Aprobación humana» no está firmada.
-  // Un recorrido no tiene ese workflow, así que sin esta puerta `--applied` sellaba una propuesta con
-  // «Estado: pendiente» y «Cambio propuesto: Por definir»: el frontmatter decía `applied` y el cuerpo
-  // decía lo contrario, dentro del mismo documento. Se comprueba para los dos porque la contradicción
-  // no depende de quién sea el sujeto, y para el cargo la puerta ya la pasó quien firmó.
-  const responsible = (text.match(/^-\s*Responsable:\s*(.+)$/m) || [])[1] || ''
-  const change = section(text, /Cambio propuesto/i).split('\n').slice(1).join('\n').trim()
-  const undecided = (value) => !value || /^(por definir|pendiente)\b/i.test(value)
-  if (undecided(responsible.trim()) || undecided(change)) {
-    throw new Error(
-      `${path.basename(file)} todavía no la decidió nadie: «Aprobación humana» necesita un responsable `
-      + 'y «Cambio propuesto» tiene que decir qué cambia. Aplicar es un acto humano y esto lo registra.',
-    )
-  }
-  const stamped = text
-    .replace(/^status:\s*\S+\s*$/m, 'status: applied')
-    .replace(/^-[ \t]*Estado:[ \t]*pendiente[ \t]*$/m, '- Estado: aplicada')
-    .replace(/^-[ \t]*Fecha:[ \t]*por definir[ \t]*$/mi, `- Fecha: ${isoDate(new Date())}`)
-  atomicWrite(file, stamped)
-  // El historial sólo lo escribe alguien para los cargos —`agent-promote`— y nadie para los recorridos,
-  // así que el registro que la plantilla promete no existía nunca. Se escribe acá porque es determinista:
-  // la fecha, el documento, quién aprobó y qué dice que cambia, todo sale de lo que se acaba de sellar.
-  if (kind === 'flow') appendHistory(path.dirname(path.dirname(dir)), file, responsible.trim(), change)
-  return { file, already: false }
-}
-
-// Una fila por propuesta aplicada. El cambio va en una línea: el documento entero está a un enlace, y
-// una tabla que lo repite entero deja de leerse.
-function appendHistory(target, file, responsible, change) {
-  const history = path.join(target, 'learning', 'HISTORY.md')
-  if (!fs.existsSync(history)) return
-  const line = change.split('\n').map((one) => one.trim()).filter(Boolean)[0] || ''
-  const row = `| ${isoDate(new Date())} | \`${path.basename(file)}\` | aplicada | ${responsible} `
-    + `| ${line.slice(0, 160)} |\n`
-  fs.appendFileSync(history, `${fs.readFileSync(history, 'utf8').endsWith('\n') ? '' : '\n'}${row}`)
-}
-
 function prepareReport(root, agent, now = new Date()) {
   const reports = path.join(assertWritable(root, agent), 'learning', 'reports')
   const file = path.join(reports, `${isoDate(now)}.md`)
@@ -143,7 +83,7 @@ propuesta consolidada. -->
 // El molde de los apartados que una persona escribe queda; lo que deja de quedar es `## Hallazgos` en
 // blanco. Una revisión que no puede decir qué la motiva no puede producir un cambio, y hasta acá se
 // llega sólo con material: el llamador ya se negó a abrirla sin él.
-function reviseProposal(root, agent, dir, previous, period, findings = [], consumed = []) {
+function reviseProposal(agent, dir, previous, period, findings = [], consumed = []) {
   const parsed = previous.match(PROPOSAL_NAME)
   const revision = Number(parsed[2] || 1) + 1
   const file = path.join(dir, `${period}-r${revision}.md`)
@@ -200,15 +140,19 @@ sólo que pase.
 }
 
 // La última propuesta del período, si la hay: es contra ella que se decide si abrir una revisión.
-function lastOfPeriod(dir, period) {
-  const names = proposalFiles(dir).filter((name) => name.match(PROPOSAL_NAME)[1] === period)
-  return names.length ? names[names.length - 1] : ''
-}
-
 // De qué aprende un recorrido: de cada registro sin sellar entran los casos que no pasaron, con su
 // contraste y de qué corrida salen. Si no hay ninguno, eso también es un resultado — el recorrido
 // aguantó y no hay qué corregir. Por qué es esto y no una investigación, en `pendingRuns`.
-const VERDICT = /\n### ([^\n]+)\n\n- Veredicto: (pasa|no pasa)\n([\s\S]*?)(?=\n### |$)/g
+// El contraste termina donde empieza **el caso siguiente**, y un caso se reconoce por su línea de
+// veredicto, no por ser un `###`. Cortando en cualquier `###` se cortaba en el primero que la respuesta
+// del cargo usara para su propia estructura: 285 de los 774 veredictos del repositorio quedaban
+// truncados —`06-adversarial-runbook` conservaba 1.057 de 48.991 caracteres, y un `06-adversarial-docs`
+// llegó a 49 de 20.119—. Nada lo delataba: la propuesta se compone igual y se lee entera.
+const VERDICT = /\n### ([^\n]+)\n\n- Veredicto: (pasa|no pasa)\n([\s\S]*?)(?=\n### [^\n]+\n\n- Veredicto: |$)/g
+
+// La nota que el juez deja sobre el contrato: una línea propia debajo del veredicto, no enterrada en el
+// contraste. Va a un documento que se firma, así que tiene que poder extraerse sin interpretar prosa.
+const CONTRACT_NOTE = /^-\s*Para el contrato:\s*(.+)$/m
 
 function verdicts(text) {
   return [...text.matchAll(VERDICT)]
@@ -242,10 +186,26 @@ function verdictFindings(root, dir) {
       latest.set(item.id, { ...item, file, name, failures: (before ? before.failures : 0) + (item.passed ? 0 : 1) })
     }
   }
-  const findings = [...latest.values()].filter((item) => !item.passed).map((item) =>
-    `### ${item.id} — ${item.name.slice(0, -3)}\n\n`
-    + `Corrida: \`${path.relative(root, item.file)}\``
-    + `${item.failures > 1 ? ` — falló en ${item.failures} corridas de esta tanda` : ''}\n\n${item.detail}`)
+  const findings = [...latest.values()].flatMap((item) => {
+    const corrida = `Corrida: \`${path.relative(root, item.file)}\``
+    if (!item.passed) {
+      return [`### ${item.id} — ${item.name.slice(0, -3)}\n\n${corrida}`
+        + `${item.failures > 1 ? ` — falló en ${item.failures} corridas de esta tanda` : ''}\n\n${item.detail}`]
+    }
+    // Un caso que pasa también trae material, y hasta acá no tenía por dónde entrar. El juez ve el
+    // contrato entero mientras juzga y a veces encuentra lo que **no** pide: una conducta que ningún
+    // comportamiento esperado nombra, y que por eso ningún caso podía atrapar. No es un fallo del sujeto
+    // —eso lo dice el veredicto— así que no puede viajar como rojo, y sin esta rama moría en la prosa del
+    // contraste. Pasó el 2026-08-30: el juez anotó que el cargo debía citar verbatim o decir «paráfrasis»,
+    // el caso pasó, y la revisión que lo recogió hubo que escribirla a mano.
+    // De la primera línea y no de cualquier parte: después del veredicto viene la respuesta del sujeto,
+    // y ahí una línea con este prefijo sería una nota que el sujeto se escribe a sí mismo.
+    const note = (item.detail.split('\n', 1)[0].match(CONTRACT_NOTE) || [])[1]
+    return note
+      ? [`### ${item.id} — ${item.name.slice(0, -3)} · el caso pasa\n\n${corrida}\n\n`
+        + `Lo que el contrato no cubre: ${note.trim()}`]
+      : []
+  })
   return { consumed: unsealed.map((name) => path.join(results, name)), findings }
 }
 
@@ -278,7 +238,7 @@ function pendingReports(target, sealing) {
 // veredicto en contra, no una fuente nueva.
 // Recibe los hallazgos ya compuestos: el llamador los necesita antes para decidir si abre documento,
 // y volver a leerlos acá sería leer dos veces lo mismo para responder la misma pregunta.
-function proposeFromRuns(root, agent, target, file, period, { consumed, findings }) {
+function proposeFromRuns(agent, file, period, { consumed, findings }) {
   fs.writeFileSync(file, `---
 flow: ${agent}
 period: ${period}
@@ -303,6 +263,9 @@ Por definir. Lo que se corrige es el recorrido: un \`exitGate\` que dejó pasar
 una etapa que dependía de otra sin necesidad, un guardrail que nadie podía cumplir, un agente
 condicional que hacía falta siempre. No cambiar el contrato de ningún cargo desde acá.
 
+La primera línea de esta sección es la que viaja al historial al aplicar: que diga el cambio, no una
+advertencia sobre él.
+
 ## Riesgos y regresiones
 
 Qué caso pasaba con el recorrido actual y podría dejar de pasar. Un gate más duro frena de más, y eso
@@ -349,8 +312,8 @@ function prepareProposal(root, agent, now = new Date(), period = '', kind = 'age
   if (kind === 'flow') {
     const red = verdictFindings(root, target)
     if (!red.findings.length) return { file: '', created: false, reports: 0 }
-    if (previous) return reviseProposal(root, agent, proposalDir, previous, sealing, red.findings, red.consumed)
-    return proposeFromRuns(root, agent, target, path.join(proposalDir, `${sealing}.md`), sealing, red)
+    if (previous) return reviseProposal(agent, proposalDir, previous, sealing, red.findings, red.consumed)
+    return proposeFromRuns(agent, path.join(proposalDir, `${sealing}.md`), sealing, red)
   }
 
   // Los dos materiales de un cargo, y dicen cosas distintas: un informe sin consolidar dice que cambió
@@ -368,9 +331,24 @@ function prepareProposal(root, agent, now = new Date(), period = '', kind = 'age
   if (!reports.length && !red.findings.length) return { file: '', created: false, reports: 0 }
 
   const reportPaths = reports.map((name) => path.join(reportDir, name))
+  // La misma regla que la rama de recorridos, por el mismo motivo: un documento que no puede decir qué
+  // corregir no cambia ningún contrato y cuesta igual la firma humana que uno que sí. Un informe puede
+  // encontrar cosas y no proponer ningún cambio —resultado legítimo—, y un mes entero así abría una
+  // propuesta cuyas entradas decían todas «Sin recomendación registrada»: se lee entera, no propone
+  // nada, y nadie la iba a firmar.
+  //
+  // No se sellan, y es a propósito. Sellar toca archivos, y en el ciclo automático eso abre un PR con
+  // puros sellos: la misma firma que se quería ahorrar, ahora sin siquiera un documento que leer. Lo
+  // que queda es que el job vuelva a no encontrar nada el mes siguiente —barato: sin modelo y sin PR—
+  // y que estos informes entren al documento el mes que alguno sí proponga algo, como «Sin
+  // recomendación registrada». Ahí ese texto es histórico, no ruido.
+  if (!red.findings.length && !reportPaths.some((file) => recommendationOf(file))) {
+    return { file: '', created: false, reports: 0, quiet: reportPaths.length }
+  }
+
   const findings = [...reportPaths.map((file) => reportSummary(root, file)), ...red.findings]
   const consumed = [...reportPaths, ...red.consumed]
-  if (previous) return reviseProposal(root, agent, proposalDir, previous, sealing, findings, consumed)
+  if (previous) return reviseProposal(agent, proposalDir, previous, sealing, findings, consumed)
 
   const file = path.join(proposalDir, `${sealing}.md`)
   const summaries = findings
@@ -413,21 +391,36 @@ Pendiente.
   return { file, created: true, reports: reports.length, findings: red.findings.length }
 }
 
+// El patrón vive una sola vez porque dos lugares preguntan lo mismo por motivos distintos:
+// `reportSummary` para copiar la recomendación, y `prepareProposal` para decidir si hay algo que
+// proponer. Duplicado, una de las dos copias deja de coincidir con el andamio y nada falla.
+//
+// Sin `m`: con esa bandera el `$` casa fin de *línea*, así que la búsqueda no ávida cortaba en el
+// primer salto y la propuesta consolidaba una sola línea de una recomendación de diez. Comprobado en
+// node v24.18.0: el mismo patrón con `m` devuelve la primera línea y sin `m` devuelve el bloque.
+//
+// `[^\S\n]*\n` y no `\s*\n` para cerrar la línea del título: `\s` incluye el salto, así que con la
+// sección vacía se comía también el salto que precede al título siguiente, la captura arrancaba en
+// «## Preguntas abiertas» y el lookahead ya no encontraba nada. La propuesta terminaba presentando la
+// sección de al lado como si fuera la recomendación a firmar. Comprobado en node v24.18.0 sobre un
+// informe con «## Recomendación» vacía: con `\s*` captura «## Preguntas abiertas…» y con `[^\S\n]*`
+// captura la cadena vacía, que es lo que hace falta para poder distinguir «no recomendó nada».
+const RECOMMENDATION = /\n## Recomendación[^\S\n]*\n([\s\S]*?)(?=\n## |$)/
+
+// Qué recomienda un informe, o cadena vacía si no recomienda nada.
+function recommendationOf(report) {
+  return ((fs.readFileSync(report, 'utf8').match(RECOMMENDATION) || [])[1] || '').trim()
+}
+
 // La recomendación de un informe, que es lo único que la propuesta consolida de él.
 function reportSummary(root, report) {
   const name = path.basename(report)
-  const text = fs.readFileSync(report, 'utf8')
-  // Sin `m`: con esa bandera el `$` casa fin de *línea*, así que la búsqueda no ávida cortaba en el
-  // primer salto y la propuesta consolidaba una sola línea de una recomendación de diez. Comprobado en
-  // node v24.18.0: el mismo patrón con `m` devuelve la primera línea y sin `m` devuelve el bloque.
-  const match = text.match(/\n## Recomendación\s*\n([\s\S]*?)(?=\n## |$)/) || []
-  const recommendation = (match[1] || 'Sin recomendación registrada.').trim()
+  const recommendation = recommendationOf(report) || 'Sin recomendación registrada.'
   return `### ${name.slice(0, -3)}\n\nFuente interna: \`${path.relative(root, report)}\`\n\n${recommendation}`
 }
 
 
 module.exports = {
   SOURCE_TIERS,
-  CADENCES,
   cadence, pendingRuns,
-  SUMMARY_MAX, prepareReport, prepareProposal, evaluate, evaluateTeam, proposalState, seal }
+  SUMMARY_MAX, prepareReport, prepareProposal, evaluate, evaluateTeam, proposalState, seal, archive }

package/engine/automation/hooks.js

@@ -7,7 +7,6 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const H = require('../hooks/run')
-const O = require('../core/ownership')
 const M = require('../core/manifest')
 const { packagedAutomation } = require('./runners')
 

package/engine/automation/index.js

@@ -4,8 +4,6 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const F = require('../core/files')
-const H = require('../hooks/run')
-const P = require('../planning/parser')
 const catalog = require('../agents/catalog')
 const O = require('../core/ownership')
 const M = require('../core/manifest')

package/engine/cli/args.js

@@ -25,7 +25,7 @@ const FLAGS = {
   agents: ['--json', '--own', '--system'],
   integration: ['--fixture'],
   automation: ['--force'],
-  learn: ['--flow', '--proposal', '--applied', '--period'],
+  learn: ['--flow', '--proposal', '--applied', '--archived', '--period'],
   evaluate: ['--cases', '--json', '--bench', '--force', '--record', '--flow'],
   flow: ['--json'],
 }
@@ -54,4 +54,4 @@ function parse(argv) {
   }
 }
 
-module.exports = { FLAGS, VALUED_FLAGS, parse }
+module.exports = { FLAGS, parse }

package/engine/cli/catalog.js

@@ -132,6 +132,16 @@ function learn(agent, cli) {
     // aplicada editando frontmatter a mano es justo el paso que un agente hace mal en silencio.
     // Un recorrido aprende de sus corridas y un cargo de su profesión: mismo ciclo, distinto insumo.
     const kind = cli.has('--flow') ? 'flow' : 'agent'
+    // El tercer destino: se miró y no cambia nada. Sin esto sólo había aplicarla o dejarla esperando,
+    // y lo que se hacía era mergear el PR sin firmar — que deja el documento diciendo «sin aplicar»
+    // para siempre, indistinguible de una que espera trabajo.
+    if (cli.has('--archived')) {
+      const result = L.archive(opsRoot(), agent, cli.value('--period'), kind)
+      const relative = path.relative(opsRoot(), result.file)
+      return console.log(result.already
+        ? `= ${relative} ya estaba archivada`
+        : `✓ ${relative} queda archivada: se miró y no cambia nada`)
+    }
     if (cli.has('--applied')) {
       const result = L.seal(opsRoot(), agent, cli.value('--period'), kind)
       const relative = path.relative(opsRoot(), result.file)
@@ -139,14 +149,28 @@ function learn(agent, cli) {
         ? `= ${relative} ya estaba aplicada`
         : `✓ ${relative} queda aplicada: no se vuelve a aplicar`)
     }
+    // Un recorrido no tiene informe semanal: su propuesta se compone de los veredictos de sus propias
+    // corridas y nunca lee `learning/reports/`. La forma desnuda —la que para un cargo abre el informe
+    // de la semana— no tiene entonces qué abrir acá, y `prepareReport` lo decía resolviendo con el
+    // `kind` por defecto: «no existe agents/<tipo>/<slug>/SKILL.md», que manda a crear un cargo que no
+    // falta. Negarse nombrando el comando que sí corresponde es lo que cierra R13.
+    if (kind === 'flow' && !cli.has('--proposal')) {
+      fail(`${agent} es un recorrido: aprende de sus corridas, no de informes semanales.\n`
+        + `  Abrí la propuesta con "ops learn ${agent} --flow --proposal".`, 2)
+    }
     // `--period` es para consolidar a mano un mes que no es el de hoy. El ciclo automático no lo
     // pasa: la propuesta se llama por el mes en que se abre y arrastra lo que todavía no entró.
     const result = cli.has('--proposal')
       ? L.prepareProposal(opsRoot(), agent, new Date(), cli.value('--period'), kind)
       : L.prepareReport(opsRoot(), agent)
-    // Sin informes pendientes no hay archivo que nombrar, y decirlo es el resultado: el ciclo corrió
-    // y no había nada que consolidar.
-    if (!result.file) return console.log('= sin informes pendientes: no se abre propuesta')
+    // Sin archivo que nombrar hay dos resultados distintos y decir cuál es el punto: no había material,
+    // o lo había y ninguno propuso un cambio. El segundo no es un error ni un mes perdido —el informe
+    // es histórico igual— y confundirlo con el primero manda a buscar por qué no se investigó.
+    if (!result.file) {
+      return console.log(result.quiet
+        ? `= ${result.quiet} informe(s) sin recomendación: no hay qué proponer, quedan para el mes que viene`
+        : '= sin informes pendientes: no se abre propuesta')
+    }
     console.log(`${result.created ? '+' : '='} ${path.relative(opsRoot(), result.file)}`)
     // Un cargo consolida informes de su profesión; un recorrido, las corridas que lo midieron.
     if (typeof result.reports === 'number') {
@@ -170,7 +194,12 @@ function evaluate(agent, caso, cli) {
     }
     // El caso es el posicional que sigue al cargo: `evaluate <cargo> --bench <caso>`. Sin él se arma
     // un banco suelto, para mirarlo a mano; una corrida real pide uno por caso.
-    return console.log(evaluationBench(root, agent, caso, cli.has('--force'), kind))
+    //
+    // Relativa a la raíz, como la de `--record`: esta salida la lee el agente que prepara los bancos,
+    // y de ahí la ruta viaja a los informes y a las propuestas que después lee otro cargo. Absoluta
+    // nombraba el directorio personal de una máquina, y así quedaron mil cuatrocientas ochenta y cinco
+    // citas que dejaron de resolver el día que este repositorio cambió de nombre.
+    return console.log(path.relative(root, evaluationBench(root, agent, caso, cli.has('--force'), kind)))
   }
   try {
     // Los casos, para que un recorrido los ejecute. Sin `--json` no tiene sentido: es entrada de

package/engine/cli/instance.js

@@ -7,7 +7,6 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const { spawnSync } = require('node:child_process')
 const F = require('../core/files')
 const O = require('../core/ownership')
 const CL = require('../core/changelog')
@@ -15,7 +14,6 @@ const M = require('../core/manifest')
 const OB = require('../core/onboarding')
 const P = require('../planning/parser')
 const ST = require('../planning/state')
-const I = require('../integrations/registry')
 const A = require('../automation')
 const { fail } = require('./io')
 

package/engine/cli/ops.js

@@ -4,25 +4,9 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
-const P = require('../planning/parser')
-const B = require('../planning/business-rules')
-const PC = require('../planning/contracts')
-const ST = require('../planning/state')
-const I = require('../integrations/registry')
-const L = require('../agents/learning')
 const A = require('../automation')
-const F = require('../core/files')
-const O = require('../core/ownership')
-const CL = require('../core/changelog')
-const M = require('../core/manifest')
-const SC = require('../core/scan')
-const OB = require('../core/onboarding')
-const C = require('../config/validate')
-const T = require('../flows/registry')
-const AG = require('../agents/catalog')
-const EV = require('../agents/evaluations')
 const { FLAGS, parse } = require('./args')
-const { fail, opsRoot } = require('./io')
+const { fail } = require('./io')
 const IN = require('./instance')
 const PL = require('./planning')
 const CAT = require('./catalog')
@@ -170,7 +154,7 @@ function usage() {
   ops automation doctor <ops-root> claude|codex|gemini|antigravity
   ops automation install <ops-root> claude|codex|gemini|antigravity
   ops automation uninstall <ops-root> claude|codex|gemini|antigravity
-  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied [--period <AAAA-MM>]]
+  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied|--archived [--period <AAAA-MM>]]
   ops evaluate <agent|flow> [--flow] [--cases [--json]] [--bench [caso]] [--record [AAAA-MM-DD]]
   ops agents list [ops-root] [--own|--system] [--json]
   ops agents fork <cargo> [ops-root]