@ingeniomaps/cauce 0.70.0 → 0.71.0

package/engine/agents/learning-sources.js

@@ -90,6 +90,12 @@ function sourceTiers(text) {
   return [...body.matchAll(/tier:\s*([A-Za-z-]+)/g)].map((hit) => hit[1])
 }
 
+// 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
@@ -99,14 +105,52 @@ function sourceUrls(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
+}
+
 function evaluate(root, agent) {
   const target = catalog.resolve(root, agent)
   const errors = []
@@ -193,4 +237,4 @@ 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, 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.71.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.