@ingeniomaps/cauce 0.70.0 → 0.72.0

package/agents/roles/system/ux-designer/learning/HISTORY.md

@@ -1,4 +1,6 @@
 # Historial de aprendizaje
 
+Una fila por propuesta cerrada: cuándo, cuál, qué se decidió —aplicarla o archivarla—, quién lo decidió y qué cambió.
+
 | Fecha | Propuesta | Decisión | Aprobó | Cambio aplicado |
 |---|---|---|---|---|

package/agents/roles/system/ux-designer/learning/sources.yaml

@@ -13,7 +13,7 @@ sources:
     tier: standard
     topics: [accessibility, wcag, cognitive-accessibility]
   - name: ISO Human-centred Design
-    url: https://www.iso.org/standard/77520.html
+    url: https://committee.iso.org/standard/77520.html
     tier: standard
     topics: [human-centred-design, lifecycle]
   - name: Nielsen Norman Group

package/agents/roles/system/ux-designer/references/operating-model.md

@@ -79,7 +79,7 @@ Diseñar para que la experiencia sea perceptible, operable, comprensible y robus
 
 Modelo sintetizado con fuentes revisadas en agosto de 2026:
 
-- [ISO 9241-210:2019](https://www.iso.org/standard/77520.html): integrar diseño centrado en las personas durante el ciclo de vida de sistemas interactivos.
+- [ISO 9241-210:2019](https://committee.iso.org/standard/77520.html): integrar diseño centrado en las personas durante el ciclo de vida de sistemas interactivos.
 - [WCAG 2.2](https://www.w3.org/TR/WCAG22/): criterios comprobables para contenido perceptible, operable, comprensible y robusto.
 - [Nielsen Norman Group: heurísticas de usabilidad](https://media.nngroup.com/media/articles/attachments/Heuristic_Summary1_A4_compressed.pdf): principios para inspeccionar feedback, control, consistencia, prevención y recuperación.
 - [GOV.UK Design System Patterns](https://design-system.service.gov.uk/patterns/): patrones documentados para tareas concretas, adaptables al contexto.

package/automatization/workflows/autobuild.js

@@ -9,7 +9,7 @@ export const meta = {
   // la primera fase. Escribirlas también les da un detalle propio, que es lo que se lee al autorizar.
   phases: [
     { title: 'Triage', detail: 'Contrato del proyecto y estado de planning' },
-    { title: 'Pick', detail: 'La próxima tarea, o la épica que falta expandir' },
+    { title: 'Pick', detail: 'La próxima tarea del hito, y la reserva antes de construirla' },
     { title: 'Classify', detail: 'Carril y reparto de la tarea que no los declara' },
     { title: 'Ready', detail: 'Aceptación concreta y sin decisiones pendientes' },
     { title: 'Decompose', detail: 'Partir la tarea que no entra en el tope de horas' },
@@ -40,8 +40,12 @@ const ROADMAP = `${P}/roadmap`
 // Estado de planning tal como lo emite `ops context --json`; ningún modelo parsea BACKLOG ni WIP.
 const CONTEXT = {
   type: 'object', additionalProperties: false,
-  required: ['blocked', 'hasTask', 'wipActive', 'queued', 'cast'],
+  required: ['blocked', 'hasTask', 'wipActive', 'queued', 'cast', 'readOk'],
   properties: {
+    // Si el comando salió con error no hay estado que reportar, y `hasTask: false, queued: 0` es
+    // exactamente lo que un modelo completa cuando no tiene qué poner. Sin este campo esa invención se
+    // lee igual que una cola terminada, y Pick la toma como permiso para promover.
+    readOk: { type: 'boolean' },
     blocked: { type: 'string' }, hasTask: { type: 'boolean' }, wipActive: { type: 'boolean' },
     queued: { type: 'integer' }, slug: { type: 'string' }, hito: { type: 'string' },
     service: { type: 'string' }, acceptance: { type: 'string' }, epic: { type: 'string' },
@@ -73,10 +77,6 @@ const CLAIM = {
   type: 'object', additionalProperties: false, required: ['claimed'],
   properties: { claimed: { type: 'boolean' }, details: { type: 'string' } },
 }
-const EXPANSION = {
-  type: 'object', additionalProperties: false, required: ['expanded'],
-  properties: { expanded: { type: 'boolean' }, hito: { type: 'string' }, reason: { type: 'string' } },
-}
 const READY = {
   type: 'object', additionalProperties: false, required: ['ready', 'needsHuman'],
   properties: {
@@ -229,8 +229,16 @@ const CLASSIFICATION = {
 
 const CONTRACT = {
   type: 'object', additionalProperties: false,
-  required: ['project', 'workspaceRoots', 'maxTaskHours', 'commitPerTask', 'humanCheckpoint', 'contracts'],
+  required: ['project', 'workspaceRoots', 'maxTaskHours', 'commitPerTask', 'humanCheckpoint', 'contracts',
+    'rootOk'],
   properties: {
+    // `ROOT` viaja escrito en el workflow y es relativo al cwd de los agentes: si la sesión abrió en otra
+    // carpeta, todas las rutas resuelven a `<raíz>/<raíz>/…` y ninguna existe. Nada lo comprobaba, y el
+    // recorrido gastaba Triage entero sobre archivos ausentes antes de parar más abajo por otra causa,
+    // nombrando el planning en vez de la raíz de la que ese planning cuelga.
+    //
+    // Se pregunta acá porque acá ya se leen los cuatro archivos: cuesta un campo y ningún agente más.
+    rootOk: { type: 'boolean' },
     project: { type: 'string' }, workspaceRoots: { type: 'array', minItems: 1, items: { type: 'string' } },
     // La puerta que el proyecto declara, si la declara. Viaja con la raíz porque es de la base de código
     // y no del runner: un monorepo tiene una por servicio, y uno solo tiene una sola.
@@ -289,7 +297,9 @@ phase('Triage')
 // subagente como «Límites del proyecto» eran sólo los genéricos del toolkit.
 const contract = await agent(
   `${BASE}\n\nLeé ${ROOT}/AGENTS.md, ${ORG}/workspace.md, ${CONFIG} y ${P}/PROTOCOL.md una sola vez y no ` +
-  `leas nada más. Reportá los ` +
+  `leas nada más. Poné rootOk en true sólo si los cuatro existieron y los pudiste leer; si alguno no ` +
+  `estaba, rootOk en false y el resto en sus valores vacíos, sin deducirlos de otra fuente. ` +
+  `Reportá los ` +
   `valores de configuración textualmente: project, workspaceRoots como entradas "nombre → ruta", ` +
   `runner.maxTaskHours, runner.commitPerTask y runner.humanCheckpointBetweenMilestones como humanCheckpoint. ` +
   `En gates poné una entrada "ruta → comando" por cada workspaceRoot que declare \`verify\`, y ninguna por ` +
@@ -301,6 +311,12 @@ const contract = await agent(
   { schema: CONTRACT, label: 'contract-digest' },
 )
 if (!contract) return stop('contract-unavailable', `no se pudo leer ${CONFIG} ni ${P}/PROTOCOL.md`)
+// Falla acá y nombrando la raíz, que es lo que hace falta para arreglarlo: parar más abajo mandaba a
+// revisar el planning, y el planning está bien — lo que no existe es la carpeta de la que cuelga.
+if (!contract.rootOk) {
+  return stop('root-unreadable', `${ROOT} no se pudo leer entero. Es una ruta relativa a la carpeta `
+    + `donde se abre la herramienta: comprobá desde dónde estás corriendo el recorrido.`)
+}
 
 const bounds = contract.boundaries || []
 const limits = bounds.length ? ` Límites del proyecto: ${bounds.join('; ')}.` : ''
@@ -329,12 +345,17 @@ const readContext = () => read(
   `de task.tier; copiá slug, ` +
   `hito, service, acceptance, ` +
   `epic y cast de task, y epicContext de epic.context —vacío si no hay épica—. El comando es la fuente de ` +
-  `verdad: no abras archivos de planning para completarlo.`,
+  `verdad: no abras archivos de planning para completarlo. Poné readOk en true sólo si el comando salió ` +
+  `con código 0 y devolvió JSON; si falló, readOk en false y el resto en sus valores vacíos, sin ` +
+  `deducir el estado de ninguna otra fuente.`,
   { schema: CONTEXT, label: 'planning-context' },
 )
 
 let planning = await readContext()
 if (!planning) return stop('context-unavailable', `no se pudo leer el estado de ${P}`)
+// Que el agente conteste no significa que haya leído: el schema se completa igual con ceros. Parar acá
+// cuesta una corrida; seguir sobre una lectura fallida escribe en el BACKLOG, y eso no se revierte solo.
+if (!planning.readOk) return stop('context-unavailable', `${P} no se pudo leer; revisá la ruta y el cwd`)
 if (planning.blocked) return stop('awaiting-human-review', `${GATE} tiene un checkpoint humano sin resolver`)
 
 let currentMilestone = planning.wipActive ? planning.hito : ''
@@ -350,18 +371,15 @@ const classified = new Set()
 
 while (rounds++ < MAX_TASKS) {
   phase('Pick')
-  if (!planning.hasTask && !planning.queued) {
-    const expansion = await write(
-      `Leé ${ROADMAP}. Expandí sólo la próxima épica abierta y aprobada en un hito nuevo de ${BACKLOG}, ` +
-      `conservando el slug de cada historia, sus referencias a criterios y su servicio. Nunca promuevas ` +
-      `${P}/INBOX.md. Reportá si escribiste algo.`,
-      { schema: EXPANSION },
-    )
-    if (!expansion) return stop('agent-unavailable', 'Pick no devolvió resultado')
-    if (!expansion.expanded) break
-    planning = await readContext()
-    if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
-  }
+  // Sin tarea y con la cola vacía, la corrida termina. **No expande la próxima épica**, y eso no es una
+  // limitación sino la regla: el roadmap llama `open` a «candidata editable que aún no fue promovida al
+  // backlog», así que pegarla en la cola es promoverla — y BR-OPS-002 deja una propuesta fuera de la cola
+  // hasta que la apruebe una persona. El prompt que hacía esto pedía «la próxima épica abierta y
+  // aprobada», y «aprobada» no correspondía a ningún dato: una épica declara `epic`, `title`, `status` y
+  // `service`, y ninguno registra una aprobación.
+  //
+  // `context` nombra la que sigue, igual que nombra una recurrencia vencida y por el mismo motivo: la
+  // máquina calcula y la persona encola.
   if (!planning.hasTask || (currentMilestone && planning.hito !== currentMilestone)) break
   const task = {
     id: planning.slug, hito: planning.hito, service: planning.service,

package/engine/agents/evaluations.js

@@ -132,10 +132,21 @@ function behaviors(root, agent, kind) {
 // tiene `SKILL.md`— así que se le podía agregar una dimensión al gate y sus veredictos anteriores
 // seguían leyéndose vigentes. Pasó el mismo día que esto se escribió: `change-review` ganó la pregunta
 // por las superficies críticas y sus tres casos aprobados no dijeron una palabra.
+//
+// Y hay un entorno donde git **no puede** contestar: un clon `--depth 1` tiene un solo commit y le
+// atribuye todo el árbol, así que `log -1 -- <archivo>` devuelve la fecha del checkout para cualquier
+// archivo. Comprobado con git 2.43.0 clonando este repositorio a profundidad 1: el `SKILL.md` de
+// `site-reliability-engineer` daba el día del clon contra el 2026-09-02, que es cuando se editó.
+//
+// Ahí la respuesta no es una fecha vieja sino ninguna, y **se dice**: un aviso que anuncia un cambio
+// que no ocurrió se lee igual que uno verdadero, y tres informes de dos cargos gastaron un hallazgo
+// cada uno investigándolo antes de que saliera como el caso 052.
 function contractChangedAt(dir, kind) {
   const file = kind === 'flow' ? 'flow.json' : 'SKILL.md'
+  const shallow = spawnSync('git', ['-C', dir, 'rev-parse', '--is-shallow-repository'], { encoding: 'utf8' })
+  if ((shallow.stdout || '').trim() === 'true') return { date: '', truncated: true }
   const git = spawnSync('git', ['-C', dir, 'log', '-1', '--format=%cs', '--', file], { encoding: 'utf8' })
-  return git.status === 0 ? (git.stdout || '').trim() : ''
+  return { date: git.status === 0 ? (git.stdout || '').trim() : '', truncated: false }
 }
 
 function resultsDir(root, agent, kind) {
@@ -264,10 +275,13 @@ function validate(root, agent, kind) {
   if (state.failed.length) {
     warnings.push(`${state.failed.length} caso(s) no pasan: ${state.failed.join(', ')}`)
   }
-  const changedAt = contractChangedAt(subject(root, agent, kind), kind)
-  if (changedAt && changedAt > state.oldest) {
+  const contract = contractChangedAt(subject(root, agent, kind), kind)
+  if (contract.truncated) {
+    warnings.push('no se puede saber si el contrato cambió después de estos veredictos: el checkout '
+      + 'está truncado y git le atribuye todo a su único commit (se destraba con fetch-depth: 0)')
+  } else if (contract.date && contract.date > state.oldest) {
     const which = state.oldest === state.newest ? 'la última corrida es' : 'el veredicto más viejo es'
-    warnings.push(`el contrato cambió el ${changedAt} y ${which} del ${state.oldest}: `
+    warnings.push(`el contrato cambió el ${contract.date} y ${which} del ${state.oldest}: `
       + 'mide una versión anterior')
   }
   return { errors, warnings, cases: total, last, state }

package/engine/agents/learning-seal.js

@@ -12,6 +12,8 @@ const path = require('node:path')
 const { atomicWrite } = require('../core/files')
 const { isoDate, proposalFiles, proposalState, assertWritable, lastOfPeriod } = require('./learning-files')
 const { section } = require('../planning/parser')
+// La misma identidad con la que se reclama una tarea: quién es la persona, no qué runner corre.
+const { owner } = require('../planning/claims')
 
 // 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.
@@ -102,22 +104,51 @@ function archive(root, agent, period = '', kind = 'agent') {
       + 'Archivar es para lo que se miró y no cambia nada.',
     )
   }
+  // Quién archivó, que es la mitad que faltaba. Sellar saca el responsable del documento —lo escribió la
+  // firma— y archivar no pasa por firma, así que sale de la identidad de quien corre el comando: la misma
+  // que `claim` usa para decir de quién es una tarea. Sin esto la propuesta quedaba en «por definir» y no
+  // había forma de distinguir una decisión de un olvido.
+  const responsible = owner(root) || 'sin identificar'
   atomicWrite(file, text
     .replace(/^status:\s*\S+\s*$/m, 'status: archived')
     .replace(/^-[ \t]*Estado:[ \t]*pendiente[ \t]*$/mi, '- Estado: archivada')
+    .replace(/^-[ \t]*Responsable:[ \t]*por definir[ \t]*$/mi, `- Responsable: ${responsible}`)
     .replace(/^-[ \t]*Fecha:[ \t]*por definir[ \t]*$/mi, `- Fecha: ${isoDate(new Date())}`))
+  // La fila va para los dos tipos, y no sólo para los recorridos como en `seal`: allá los cargos los
+  // registra `agent-promote` al aplicar, y archivar no pasa por ningún workflow que lo haga.
+  // La raíz del cargo, que es `<cargo>/learning/proposals/<archivo>` sin sus tres últimos tramos:
+  // `appendHistory` agrega `learning/` por su cuenta.
+  //
+  // La celda del cambio lleva el criterio y no queda vacía. Es el único que este comando admite —archivar
+  // *es* decidir que no cambia nada— así que decirlo evita que la fila se lea como un registro a medias.
+  // Archivar por otra razón, como posponer, necesitaría un campo que hoy no existe.
+  appendHistory(path.dirname(path.dirname(path.dirname(file))), file, responsible,
+    'Se miró y no cambia nada.', 'archivada')
   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) {
+// Una fila por propuesta cerrada, cualquiera sea el destino. El cambio va en una línea: el documento
+// entero está a un enlace, y una tabla que lo repite entero deja de leerse.
+//
+// La decisión es un parámetro y no la constante `aplicada` porque la columna de la tabla se llama
+// «Decisión» y hay dos: aplicar y archivar. Archivar no dejaba fila, así que una propuesta mirada y
+// descartada era indistinguible de una que nadie miró — y eso lo pagaban los informes siguientes, que
+// gastaban su recomendación explicando el estado en vez de su profesión.
+const HISTORY_HEADER = '| Fecha | Propuesta | Decisión | Aprobó | Cambio aplicado |\n|---|---|---|---|---|\n'
+
+function appendHistory(target, file, responsible, change, decision = 'aplicada') {
   const history = path.join(target, 'learning', 'HISTORY.md')
   if (!fs.existsSync(history)) return
+  const previous = fs.readFileSync(history, 'utf8')
   const line = change.split('\n').map((one) => one.trim()).filter(Boolean)[0] || ''
-  const row = `| ${isoDate(new Date())} | \`${path.basename(file)}\` | aplicada | ${responsible} `
+  const row = `| ${isoDate(new Date())} | \`${path.basename(file)}\` | ${decision} | ${responsible} `
     + `| ${line.slice(0, 160)} |\n`
-  fs.appendFileSync(history, `${fs.readFileSync(history, 'utf8').endsWith('\n') ? '' : '\n'}${row}`)
+  // Dieciséis de los cincuenta y tres cargos tienen el archivo sin la tabla, sólo con su párrafo de
+  // encabezado, y la fila quedaba pegada ahí: en markdown eso no es una tabla sino texto con barras, y
+  // nadie lo veía porque el archivo se lee dos veces al año. Se agrega la cabecera antes de la primera
+  // fila en vez de exigir que ya esté, que es pedirle a cada cargo que se acuerde.
+  const cabecera = /^\|\s*Fecha\s*\|/m.test(previous) ? '' : `\n${HISTORY_HEADER}`
+  fs.appendFileSync(history, `${previous.endsWith('\n') ? '' : '\n'}${cabecera}${row}`)
 }
 
 module.exports = { seal, archive }

package/engine/agents/learning-sources.js

@@ -86,27 +86,119 @@ function cadence(root, agent) {
 // Basta con las líneas `tier:`: el archivo es del catálogo, no de un tercero, y agregar un parser de
 // YAML por un campo rompería la regla de cero dependencias.
 function sourceTiers(text) {
-  const body = text.includes('sources:') ? text.slice(text.indexOf('sources:')) : ''
-  return [...body.matchAll(/tier:\s*([A-Za-z-]+)/g)].map((hit) => hit[1])
+  return [...sourcesBody(text).matchAll(/tier:\s*([A-Za-z-]+)/g)].map((hit) => hit[1])
 }
 
+// El cuerpo de `sources:` termina donde empieza `pending:`. Sin este corte, una pendiente entraba como
+// fuente declarada y el chequeo semanal la reportaba rota todas las semanas — que es exactamente el
+// aviso permanente que la lista existe para no producir.
+function sourcesBody(text) {
+  if (!text.includes('sources:')) return ''
+  const body = text.slice(text.indexOf('sources:'))
+  const corte = body.search(/^pending:/m)
+  return corte === -1 ? body : body.slice(0, corte)
+}
+
+// Una entrada escrita en una sola línea: seis cargos del catálogo la escriben así y cuarenta y siete la
+// reparten en varias. Leyendo sólo la segunda forma, esos seis no tenían el chequeo de URL duplicada que
+// hay más abajo, y nada lo decía porque no encontrar duplicados y no mirar se ven igual.
+const FLOW_ENTRY = /^\s*-\s*\{[^}]*\bname:\s*([^,}]+?)\s*,[^}]*\burl:\s*"?([^",}\s]+)/
+const quitar = (value) => value.replace(/^['"]|['"]$/g, '')
+
 // Las fuentes de un cargo, por su URL. La misma URL con dos nombres es una sola fuente contada dos
 // veces: el catálogo llegó a tener la especificación OpenAPI bajo tres —`OpenAPI Specification`,
 // `...latest published` y `...3.2.0`— así que arreglarle el `tier` a un cargo no se lo arreglaba a los
 // otros, y quien leyera el informe vería la misma página citada como si fueran tres.
 function sourceUrls(text) {
-  const body = text.includes('sources:') ? text.slice(text.indexOf('sources:')) : ''
+  const body = sourcesBody(text)
   const out = []
   let name = ''
   for (const line of body.split('\n')) {
+    const flow = line.match(FLOW_ENTRY)
+    if (flow) { out.push({ name: quitar(flow[1]), url: flow[2].replace(/\/+$/, '') }); continue }
     const declared = line.match(/^\s*-\s*name:\s*(.+?)\s*$/)
-    if (declared) { name = declared[1].replace(/^['"]|['"]$/g, ''); continue }
+    if (declared) { name = quitar(declared[1]); continue }
     const url = line.match(/^\s*url:\s*(\S+)/)
     if (url && name) out.push({ name, url: url[1].replace(/\/+$/, '') })
   }
   return out
 }
 
+// Todo lo que un cargo cita y alguien va a abrir. `sources.yaml` es lo que investiga; `references/` y
+// `SKILL.md` son el método que sigue, y hasta 0.71.0 nadie las miraba: 29 de las 207 URLs de esos
+// documentos no servían, entre ellas dos 404 de páginas que se habían movido.
+//
+// `evaluations/` queda afuera y no por costo: los casos adversariales **inventan** dominios a propósito
+// —veintiuna URLs bajo `.example` y marcas que no existen— y comprobarlas reportaría rotas las que están
+// bien escritas. `learning/reports` y `learning/proposals` también, por lo contrario: son evidencia
+// fechada de que algo dio 403 el día que se consultó, y eso no se arregla.
+const DOC_URL = /https?:\/\/[^\s)>"`\]]+/g
+function documentUrls(dir) {
+  const out = []
+  const seen = new Set()
+  const add = (raw, origin) => {
+    const url = raw.replace(/[.,;:]+$/, '')
+    if (seen.has(url)) return
+    seen.add(url)
+    out.push({ url, origin })
+  }
+  const below = (base, relative) => {
+    let entries = []
+    try { entries = fs.readdirSync(path.join(base, relative), { withFileTypes: true }) } catch { return }
+    for (const entry of entries) {
+      const next = `${relative}/${entry.name}`
+      if (entry.isDirectory()) { below(base, next); continue }
+      if (!entry.name.endsWith('.md')) continue
+      for (const hit of fs.readFileSync(path.join(base, next), 'utf8').match(DOC_URL) || []) add(hit, next)
+    }
+  }
+  below(dir, 'references')
+  const skill = path.join(dir, 'SKILL.md')
+  if (fs.existsSync(skill)) {
+    for (const hit of fs.readFileSync(skill, 'utf8').match(DOC_URL) || []) add(hit, 'SKILL.md')
+  }
+  return out
+}
+
+// Lo que el cargo probó, no pudo abrir y va a volver a necesitar. Cinco cargos lo escribían ya como
+// comentario en su propio archivo —el steward hasta puso «Registrar cuando exista una ficha legible»,
+// que es un recordatorio que nadie iba a revisar—, así que la forma existía y lo que faltaba era que
+// alguien la mirara.
+//
+// `url` es opcional a propósito: la mitad de esas entradas están pendientes **porque no hay ninguna URL
+// que responda** —ISO/IEC/IEEE 24765, la ley federal mexicana—, y exigirla habría dejado fuera
+// justamente las que más cuesta resolver. Lo que no es opcional es `why`: sin la razón, la lista es un
+// cementerio de enlaces que nadie sabe por qué están.
+//
+// La continuación de línea se une en vez de prohibirse: `why` es una frase y una frase se envuelve. La
+// primera versión la cortaba en el primer salto y **no avisaba** —cuatro razones quedaron a media
+// oración sin que nada fallara—, y prohibir la forma no evita que la próxima persona la escriba.
+const PENDING_FIELD = /^\s{4}(name|url|why|since):\s*(.+?)\s*$/
+function pendingSources(text) {
+  const corte = text.search(/^pending:/m)
+  if (corte === -1) return []
+  const out = []
+  let one = null
+  let last = ''
+  for (const line of text.slice(corte).split('\n').slice(1)) {
+    if (/^\S/.test(line)) break
+    if (/^\s{2}-\s/.test(line)) {
+      if (one) out.push(one)
+      one = {}
+      last = ''
+      const primero = line.match(/^\s{2}-\s*(name|url|why|since):\s*(.+?)\s*$/)
+      if (primero) { one[primero[1]] = quitar(primero[2]); last = primero[1] }
+      continue
+    }
+    const campo = line.match(PENDING_FIELD)
+    if (campo && one) { one[campo[1]] = quitar(campo[2]); last = campo[1]; continue }
+    const sigue = line.match(/^\s{6,}(\S.*?)\s*$/)
+    if (sigue && one && last) one[last] += ` ${sigue[1]}`
+  }
+  if (one) out.push(one)
+  return out
+}
+
 function evaluate(root, agent) {
   const target = catalog.resolve(root, agent)
   const errors = []
@@ -145,6 +237,20 @@ function evaluate(root, agent) {
       }
       byUrl.set(one.url, one.name)
     }
+    // Una pendiente sin razón es un enlace muerto con fecha, y sin fecha no se puede ver que lleva
+    // meses ahí. Los dos campos son la mitad del valor de la lista: lo que la vuelve revisable.
+    for (const one of pendingSources(fs.readFileSync(sourcesFile, 'utf8'))) {
+      const falta = ['name', 'why', 'since'].filter((campo) => !one[campo])
+      if (falta.length) {
+        errors.push(`sources.yaml: una pendiente no declara ${falta.join(' ni ')}`
+          + `${one.name ? ` (${one.name})` : ''}`)
+      }
+      // Declarada y pendiente a la vez es una contradicción que el chequeo semanal no puede resolver:
+      // la reportaría rota como fuente y recuperada como pendiente en la misma corrida.
+      if (one.url && byUrl.has(one.url)) {
+        errors.push(`sources.yaml: ${one.url} está declarada como fuente y también como pendiente`)
+      }
+    }
   }
   const skill = fs.readFileSync(path.join(target, 'SKILL.md'), 'utf8').toLowerCase()
   for (const phrase of ['no inventar', 'autorización', 'evidencia observable']) {
@@ -193,4 +299,6 @@ function evaluate(root, agent) {
   return { errors, warnings, proposals: proposals.length, pending, cases }
 }
 
-module.exports = { SOURCE_TIERS, cadence, evaluate, evaluateTeam }
+module.exports = {
+  SOURCE_TIERS, cadence, documentUrls, evaluate, evaluateTeam, pendingSources, sourceUrls,
+}

package/engine/agents/learning.js

@@ -40,15 +40,21 @@ function prepareReport(root, agent, now = new Date()) {
   // Los sellos de estado de este módulo escriben atómico y esto no, y la diferencia es qué se pierde
   // si la escritura se corta: allá el archivo ya existía y quedaría truncado, acá no había nada. Un
   // documento nuevo a medio escribir se ve; uno viejo a medio pisar se lee como si estuviera entero.
+  // `propone` nace sin contestar y lo completa quien escribe el informe. No se deduce del texto de
+  // «Recomendación»: los veinte informes del 2026-09-07 tenían texto ahí y once no proponían ningún
+  // cambio —explicaban por qué, que es lo correcto—, así que «sección vacía» no distingue nada. Con
+  // el campo, un informe que no cambia ningún contrato se mergea solo en vez de gastar una revisión
+  // humana que no puede decidir nada.
   fs.writeFileSync(file, `---
 agent: ${agent}
 date: ${isoDate(now)}
 status: draft
+propone: por-completar
 ---
 
 # Investigación semanal — ${isoDate(now)}
 
-<!-- Dos convenciones que el ciclo necesita y que nada más sostiene:
+<!-- Tres convenciones que el ciclo necesita y que nada más sostiene:
 
   · Etiquetá cada hallazgo H1, H2, … en el orden en que aparecen. «Evidencia» y «Recomendación» se
     refieren a ellos por esa clave, y la propuesta mensual la cita para decir de qué hallazgo sale
@@ -57,6 +63,12 @@ status: draft
   · No renombres los títulos. «## Recomendación» se lee con un patrón exacto y es lo único que la
     propuesta consolida de cada informe: renombrarlo no da error, deja la propuesta vacía.
 
+  · Contestá «propone» en el frontmatter, con «si» o con «no». Es «si» cuando el informe pide tocar
+    algún archivo del cargo —SKILL.md, sources.yaml, references/, un caso— y «no» cuando lo hallado
+    no cambia ningún contrato, aunque «Recomendación» explique largamente por qué. Un «no» se
+    mergea sin revisión humana: no hay nada que decidir. Ante la duda va «si», que sólo cuesta una
+    mirada.
+
 Este comentario vive fuera de toda sección a propósito — dentro de «Recomendación» viajaría a cada
 propuesta consolidada. -->
 

package/engine/cli/planning.js

@@ -266,6 +266,9 @@ function treeJson({ epics, milestones, done, wips, inbox, queued, claims }) {
 
 function tree(dir, cli) {
   const root = path.resolve(dir || '.')
+  // Mismo motivo que en `context`, y por eso comparten la comprobación: sin ella un planning ausente
+  // dibujaba un árbol vacío, que se lee como un roadmap sin épicas en vez de como una ruta equivocada.
+  assertPlanning(root)
   const state = ST.snapshot(root)
   if (cli.has('--json')) return treeJson(state)
   const { epics, milestones, done, wips, inbox, queued, claims } = state
@@ -304,9 +307,29 @@ function tree(dir, cli) {
   console.log(`${paint('1', 'DONE')}   ${done.entries.length} tareas\n`)
 }
 
+// Lo que no se pudo leer no contesta como si se hubiera leído: la misma regla que `stagedFiles` aplica
+// sobre el índice de git, y que esta familia ya aplicaba al `--hito` inexistente. Faltaba la raíz, y ahí
+// pesa más, porque el consumidor no siempre es una persona: `autobuild` toma la cola vacía como permiso
+// para expandir una épica, así que un error de ruta promovía trabajo en vez de fallar.
+//
+// La ruta va **resuelta** y no como se escribió, porque el error que ataca es de resolución: en sidecar
+// `<empresa>-ops/planning` desde adentro de la raíz apunta a `<empresa>-ops/<empresa>-ops/planning`.
+function assertPlanning(root) {
+  if (!fs.existsSync(root)) {
+    return fail(`no existe el planning en ${root} (ruta resuelta). Comprobá desde dónde estás invocando.`, 2)
+  }
+  // Existir no alcanza: un directorio cualquiera contestaría cola vacía igual. `BACKLOG.md` es el archivo
+  // del que sale la cola, así que sin él la respuesta no significa nada.
+  if (!fs.existsSync(path.join(root, 'BACKLOG.md'))) {
+    return fail(`${root} (ruta resuelta) no es un planning: falta BACKLOG.md.`, 2)
+  }
+  return null
+}
+
 // Contexto mínimo suficiente para ejecutar una tarea, en lugar de releer roadmap, BACKLOG y WIP enteros.
 function context(dir, cli) {
   const root = path.resolve(dir || '.')
+  assertPlanning(root)
   const state = ST.snapshot(root)
   // Acotar la cola a un hito es como un equipo se reparte trabajo sin coordinarse: dos personas en hitos
   // distintos casi nunca dependen entre sí ni tocan los mismos archivos. Lo que se acota es qué se
@@ -372,6 +395,10 @@ function context(dir, cli) {
     // vuelta. Que aparezca es la señal.
     recurring: RC.status({ ...RC.read(root), done: state.done, today: TODAY() })
       .filter((one) => one.overdue),
+    // La próxima sin promover: se nombra, no se encola, igual que la recurrencia de arriba y por su
+    // mismo criterio. Por qué no la encola una máquina está en la fase Pick de `autobuild`.
+    nextEpic: (!task && [...state.epics].filter((one) => one.status === 'open')
+      .sort((a, b) => String(a.num).localeCompare(String(b.num)))[0]) || null,
   }
   if (cli.has('--json')) return console.log(JSON.stringify(report))
 
@@ -403,6 +430,8 @@ function context(dir, cli) {
   }
   if (!report.task) {
     console.log('TASK   (sin tarea disponible)')
+    const { nextEpic: next } = report
+    if (next) console.log(`EPIC   ${next.num}: ${next.title} — sin promover`)
     // Mismo motivo que `blocked` arriba, con otra causa: acá la cola no la traba una persona, la tiene
     // el equipo, y lo que corresponde es hablar con quien la tiene.
     for (const one of report.taken) console.log(`TAKEN  ${one.slug} (${dueño(one)})`)

package/package.json

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

package/template/planning/PROTOCOL.md

@@ -81,6 +81,20 @@ El lane reduce ceremonia, nunca seguridad, aceptación ni evidencia: Verify y el
 cuatro. Lo que decide el carril es la superficie del cambio y no su tamaño en líneas — un `if` en el
 chequeo de permisos es `full`, y un componente entero de presentación puede ser `directo`.
 
+Escribir la línea es también contrastarla. Declara cuatro cosas —qué hace, en qué carril, quién entrega y
+revisa, con qué se comprueba— y las cuatro salen de la misma mano en el mismo acto, así que nada las cruza
+después. Releerlas no encuentra el hueco: una aceptación incompleta se lee perfecta, porque todo lo que
+dice es cierto.
+
+Antes de dar la tarea por escrita se recorre su descripción frase por frase y se contesta, por cada cosa
+que promete, cuál condición de aceptación la comprueba; se lee el carril contra la superficie que toca y
+no contra su tamaño; y se comprueba que el cast entregue a quien construye. Lo que quede sin condición se
+agrega o se declara fuera de alcance en la línea.
+
+Es el único momento en que las cuatro se pueden mirar juntas, y por eso la pasada vive acá y no en una
+fase: después el carril ya decide cuáles corren, y la que revisaría es una de las que ese carril puede
+saltar. Una tarea mal marcada `express` es justamente la que se salta la fase donde alguien lo notaría.
+
 ## Invariantes
 
 1. Una tarea tiene un dueño de estado: roadmap → BACKLOG → overlay WIP → DONE.