@ingeniomaps/cauce 0.25.0 → 0.26.0

package/engine/agents/learning.js

@@ -33,14 +33,30 @@ function assertWritable(root, agent) {
 function isoDate(now = new Date()) { return now.toISOString().slice(0, 10) }
 function month(now = new Date()) { return now.toISOString().slice(0, 7) }
 
-const PROPOSAL_NAME = /^\d{4}-\d{2}\.md$/
+// Una propuesta por período, y sus revisiones. La revisión existe porque aplicar no es el final del
+// ciclo: la evaluación posterior es la que dice si el cambio sirvió, y cuando dice que no, el sello
+// —que está para que nadie reaplique lo mismo y duplique cada viñeta— dejaba al cargo con un contrato
+// que se sabe mal calibrado y sin camino para corregirlo hasta el mes siguiente. La corrección es un
+// cambio distinto: documento propio, firma propia, y la aplicada queda sellada donde está.
+const PROPOSAL_NAME = /^(\d{4}-\d{2})(?:-r(\d+))?\.md$/
+
+// Mismo cuidado que con los registros de evaluación: `-` va antes que `.` en ASCII, así que ordenar
+// nombres pondría `2026-08-r2.md` delante de `2026-08.md` y la revisión se leería como la más vieja.
+function proposalOrder(name) {
+  const [, period, revision] = name.match(PROPOSAL_NAME)
+  return `${period}-${String(Number(revision || 1)).padStart(4, '0')}`
+}
 
 // El tope de la línea de índice. No es estético: son 47 líneas que se leen de un vistazo, y una que
 // se envuelve rompe la columna que hace posible el vistazo.
 const SUMMARY_MAX = 120
 
 function proposalFiles(dir) {
-  try { return fs.readdirSync(dir).filter((name) => PROPOSAL_NAME.test(name)).sort() } catch { return [] }
+  try {
+    return fs.readdirSync(dir)
+      .filter((name) => PROPOSAL_NAME.test(name))
+      .sort((one, other) => proposalOrder(one).localeCompare(proposalOrder(other)))
+  } catch { return [] }
 }
 
 function proposalState(text) {
@@ -58,8 +74,14 @@ function seal(root, agent, period = '') {
   const dir = path.join(assertWritable(root, agent), 'learning', 'proposals')
   const names = proposalFiles(dir)
   if (!names.length) throw new Error(`${agent} no tiene propuestas en learning/proposals/.`)
-  const name = period ? `${period}.md` : names[names.length - 1]
-  if (!names.includes(name)) throw new Error(`${agent} no tiene la propuesta ${name}.`)
+  // `--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)
@@ -109,12 +131,88 @@ propuesta consolidada. -->
   return { file, created: true }
 }
 
+// Abre la revisión siguiente. No vuelve a consolidar los informes semanales: ya se consolidaron en la
+// propuesta que ésta corrige, y repetirlos haría que el mismo hallazgo entre dos veces al contrato. El
+// insumo de una revisión es otro —qué mostró la evaluación posterior a aplicar—, y por eso el molde
+// pregunta eso y no otra cosa.
+function reviseProposal(root, agent, dir, previo, now) {
+  const period = month(now)
+  const anterior = previo.match(PROPOSAL_NAME)
+  const revision = Number(anterior[2] || 1) + 1
+  const file = path.join(dir, `${period}-r${revision}.md`)
+  fs.writeFileSync(file, `---
+agent: ${agent}
+period: ${period}
+revision: ${revision}
+corrects: ${previo}
+status: proposed
+automatic_apply: false
+---
+
+# Propuesta mensual — ${period}, revisión ${revision}
+
+Corrige \`${previo}\`, que ya está aplicada y queda sellada donde está. Esta revisión no la reemplaza ni
+la reabre: es un cambio distinto, con su propia firma.
+
+## Hallazgos
+
+Qué mostró la evaluación posterior a aplicar \`${previo}\`. No repitas acá los hallazgos de esa propuesta
+—ya entraron al contrato—: lo que va es lo que se supo después, con el registro de evaluación que lo
+sostiene.
+
+## Evidencia
+
+El registro de la corrida que lo destapó, y la cita del veredicto. Si el cambio anterior falló por estar
+mal calibrado, va también la línea del contrato que quedó floja y la del caso que la contradice.
+
+## Cambio propuesto
+
+Una revisión suele **no** ser aditiva: reemplaza texto que la propuesta anterior agregó. Decilo
+explícitamente y decí por qué la aditividad no aplica acá — vale para lo que ya rindió sus casos, no para
+un texto que acaba de fallar su primera medición.
+
+## Riesgos y regresiones
+
+Qué casos pasaban con el texto anterior y podrían dejar de pasar con éste. Nombralos por su id: son los
+que hay que volver a correr.
+
+## Evaluación
+
+Cómo se comprueba que esta vez sí. Nombrá el caso que tiene que cambiar de veredicto y por qué razón, no
+sólo que pase.
+
+## Aprobación humana
+
+- Estado: pendiente
+- Responsable: por definir
+- Fecha: por definir
+`)
+  return { file, created: true, reports: 0, corrects: previo }
+}
+
+// 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] : ''
+}
+
 function prepareProposal(root, agent, now = new Date()) {
   const target = assertWritable(root, agent)
   const proposalDir = path.join(target, 'learning', 'proposals')
-  const file = path.join(proposalDir, `${month(now)}.md`)
   fs.mkdirSync(proposalDir, { recursive: true })
-  if (fs.existsSync(file)) return { file, created: false, reports: 0 }
+
+  // Una sola propuesta pendiente por período. Si la última todavía no se aplicó, abrir otra partiría
+  // la firma en dos documentos que dicen cosas distintas sobre el mismo contrato.
+  const previo = lastOfPeriod(proposalDir, month(now))
+  if (previo) {
+    const anterior = path.join(proposalDir, previo)
+    if (proposalState(fs.readFileSync(anterior, 'utf8')) !== 'applied') {
+      return { file: anterior, created: false, reports: 0 }
+    }
+    return reviseProposal(root, agent, proposalDir, previo, now)
+  }
+
+  const file = path.join(proposalDir, `${month(now)}.md`)
   let names = []
   try { names = fs.readdirSync(path.join(target, 'learning', 'reports')) } catch { /* vacío */ }
   const reports = names.filter((name) => name.startsWith(month(now)) && /^\d{4}-\d{2}-\d{2}\.md$/.test(name)).sort()

package/engine/cli/args.js

@@ -5,7 +5,7 @@
 // requerido y no puede exportar nada sin dispararse.
 
 // Banderas que consumen el argumento siguiente: su valor no es un posicional.
-const VALUED_FLAGS = new Set(['--name', '--mode', '--fixture', '--period'])
+const VALUED_FLAGS = new Set(['--name', '--mode', '--fixture', '--period', '--record'])
 
 // Qué acepta cada comando, y a la vez qué comandos existen. Una bandera desconocida se rechaza en vez
 // de ignorarse: `check --jsonn` imprimía la salida humana con código 0, así que quien esperaba JSON
@@ -21,7 +21,7 @@ const FLAGS = {
   integration: ['--fixture'],
   automation: ['--force'],
   learn: ['--proposal', '--applied', '--period'],
-  evaluate: ['--cases', '--json', '--bench', '--force'],
+  evaluate: ['--cases', '--json', '--bench', '--force', '--record'],
   team: ['--json'],
 }
 

package/engine/cli/ops.js

@@ -51,7 +51,7 @@ function usage() {
   ops automation doctor <ops-root> claude|codex|gemini|antigravity
   ops automation install <ops-root> claude|codex|gemini|antigravity
   ops learn <agent> [--proposal] [--applied [--period <AAAA-MM>]]
-  ops evaluate <agent> [--cases [--json]] [--bench [caso]]
+  ops evaluate <agent> [--cases [--json]] [--bench [caso]] [--record [AAAA-MM-DD]]
   ops agents list [ops-root] [--own|--system] [--json]
   ops agents fork <cargo> [ops-root]
   ops team list
@@ -989,6 +989,12 @@ function evaluate(agent, caso, cli) {
       // repetirla por caso invitaría a que alguien la editara en uno solo.
       return console.log(JSON.stringify({ cases, forbidden: prohibido }))
     }
+    // Dónde escribir el registro de esta corrida. Lo pregunta el recorrido en vez de componer el
+    // nombre, que es lo que hacía que la segunda corrida de un día borrara a la primera.
+    if (cli.has('--record')) {
+      const dia = cli.value('--record') || new Date().toISOString().slice(0, 10)
+      return console.log(path.relative(root, path.join(EV.resultsDir(root, agent), EV.nextResult(root, agent, dia))))
+    }
     const result = L.evaluate(root, agent)
     const runs = EV.validate(root, agent)
     const errors = [...result.errors, ...runs.errors]

package/engine/hooks/run.js

@@ -185,9 +185,14 @@ function workspaceBoundary(input) {
 
 function migrations(input) {
   if (process.env.OPS_MIGRATIONS_OVERRIDE === '1') return
+  // Cada rama cierra su propio límite. Cuando el `\b` estaba al final del grupo se aplicaba a las tres, y
+  // la de `delete` termina a propósito en `;`: después de un punto y coma no hay límite de palabra, así que
+  // `DELETE FROM pedidos;` —la forma que tiene en cualquier migración— pasaba y sólo frenaba la variante sin
+  // punto y coma. `drop column` y `drop constraint` faltaban: pierden datos y garantías igual que `drop table`.
   const destructiveSql = new RegExp(
-    String.raw`\b(?:drop\s+(?:table|database|schema)|truncate\s+(?:table\s+)?` +
-      String.raw`|delete\s+from\s+\S+\s*(?:;|$))\b`,
+    String.raw`\bdrop\s+(?:table|database|schema|column|constraint)\b` +
+      String.raw`|\btruncate\b` +
+      String.raw`|\bdelete\s+from\s+\S+\s*(?:;|$)`,
     'i',
   )
   if (destructiveSql.test(contentOf(input))) {

package/package.json

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

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

@@ -13,7 +13,19 @@ No reformatear, renombrar ni reparar elementos ajenos a la tarea.
 Extraer responsabilidades cuando una unidad deja de poder entenderse y probarse aisladamente; no usar
 límites numéricos como sustituto del juicio.
 
-## R11 — Comentarios que explican el porqué
+## R11 — Comentarios con destinatario
 
-Un comentario dice por qué el código es así, no qué hace: si el código ya lo dice, sobra. Cada razón
-vive en un solo lugar, y un bloque de más de tres líneas tiene que justificar su largo.
+Un comentario existe para lo que no se ve leyendo el código, y se escribe para alguien que lo va a
+preguntar o a deshacer sin saberlo. Si nadie lo preguntaría, sobra: tener un porqué no alcanza, porque
+una convención también lo tiene.
+
+Cada razón vive en un solo lugar, el que la vio nacer; repetida en otro archivo, una copia se pudre y
+nada falla.
+
+- **Dentro de una unidad**: el porqué. La restricción, el caso que la forzó, lo que se probó antes.
+- **Encabezando una unidad**: qué garantiza, un nivel por encima del código, para poder usarla sin
+  leerla entera. Su largo lo fija ese contrato.
+- **Donde ningún nombre alcanza**: la fuente de un algoritmo o una norma, qué es un valor opaco, por
+  qué algo se aparta del idioma habitual, y qué quedó a medias.
+
+Un comentario que cuesta escribir suele estar señalando el código, no la falta de palabras.

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

@@ -51,6 +51,16 @@ Son dos ejes distintos y el registro va en los dos: marcar como supuesto un núm
 mecanismo del que ese número se deriva. Un parámetro declarado supuesto sigue prometiendo el efecto que se le
 atribuye, y esa atribución es la que lleva registro.
 
+El registro viaja con la afirmación, no con el documento que la explica. Una lección, una regla propuesta, una
+fila de acciones humanas o un paso de runbook existen para leerse solos, así que una afirmación de mecanismo que
+sale del informe hacia uno de ellos lleva su registro o no sale. Ahí es donde más se pierde: el informe clasifica
+con cuidado y el artefacto derivado repite la afirmación en plano, ya sin nada que la acote, y es el que alguien
+va a leer dentro de un mes.
+
+Y el disparador es a dónde va la afirmación, no cuán discutible parece. Quien elige qué clasificar clasifica lo
+que espera que le discutan, y deja plano lo que sostiene su propio procedimiento — que es justamente lo que nadie
+va a revisar.
+
 La verificación llega hasta donde R12 permite: fuente pública, `--help`, `--version`, una invocación inocua.
 Nunca conectarse a un sistema real ni ejecutar la operación cuyo efecto se describe. Si el mecanismo sólo se
 establece ejecutando lo destructivo, queda en hipótesis; acá la abstención vale más que el dato.