@ingeniomaps/cauce 0.97.0 → 0.99.0

package/automatization/workflows/autobuild.js

@@ -28,6 +28,7 @@ export const meta = {
 
 {{INCLUDE:shared/workflow-root.js}}
 {{INCLUDE:shared/inbox.js}}
+{{INCLUDE:shared/acceptance.js}}
 const CONFIG = `${ROOT}/ops.config.json`
 const P = `${ROOT}/planning`
 const ORG = `${ROOT}/organization`
@@ -43,6 +44,13 @@ const GATE = `${P}/AWAITING_REVIEW.md`
 // suelta no es un envoltorio. Por eso también la escapada en vez de alternar el estilo de comillas.
 const QUOTES = ['\'', '"']
 
+// Si la fila que registró una parada quedó pendiente. `context` sólo lista las pendientes, así que
+// preguntar por la presencia de la tarea alcanza, y no hace falta que un modelo lea el estado.
+const HUMAN_ROW = {
+  type: 'object', additionalProperties: false, required: ['readOk', 'pending'],
+  properties: { readOk: { type: 'boolean' }, pending: { type: 'boolean' } },
+}
+
 const CONTEXT = {
   type: 'object', additionalProperties: false,
   required: ['blocked', 'hasTask', 'wipActive', 'queued', 'cast', 'readOk'],
@@ -183,19 +191,28 @@ const REVIEWED = { ...DECISION, required: [...DECISION.required, 'rules'],
 // menos —o que ni existe— sale verde igual, y el guard de verify tampoco lo ve porque también mira exit
 // codes. Por eso `uncovered` se contrasta contra la aceptación leyendo el fuente, no la salida (R9).
 const VERIFY = {
-  type: 'object', additionalProperties: false, required: ['passed', 'commands', 'details', 'uncovered'],
+  type: 'object', additionalProperties: false, required: ['passed', 'commands', 'details', 'uncovered', 'covered'],
   properties: {
     passed: { type: 'boolean' }, details: { type: 'string' },
-    // Dos causas que se leen igual en el resultado y piden cosas opuestas: a una le falta trabajo que
-    // el propio recorrido puede hacer, a la otra le falta una decisión que no es suya. Sin separarlas,
-    // la corrida frena por las dos y una persona termina resolviendo lo que se resolvía solo.
+    // Tres causas que se leen igual en el resultado y piden cosas distintas: a una le falta trabajo que
+    // el propio recorrido puede hacer, a otra le falta una decisión que no es suya, y la tercera no tiene
+    // prueba posible porque su entregable no se ejecuta —un ADR, una política—. Sin separarlas, la corrida
+    // frena por las tres, una persona resuelve lo que se resolvía solo y la tarea de decisión no cierra
+    // nunca (caso 189). `reason` es lo que Done escribe en `tests: n/a — <razón>`.
     uncovered: { type: 'array', items: { type: 'object', additionalProperties: false,
       required: ['criterion', 'cause'],
       properties: {
         criterion: { type: 'string' },
-        cause: { type: 'string', enum: ['missing-test', 'ambiguous'] },
+        cause: { type: 'string', enum: ['missing-test', 'ambiguous', 'no-surface'] },
+        reason: { type: 'string' },
       },
     } },
+    // El mapeo que Verify arma al contrastar y del que sale `tests: CN → prueba`. Sin viajar, Done lo
+    // componía de memoria (hallazgo del 189).
+    covered: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['criterion', 'test'],
+      properties: { criterion: { type: 'string' }, test: { type: 'string' } },
+    } },
     commands: { type: 'array', items: { type: 'object', required: ['cmd', 'exitCode'], properties: {
       cmd: { type: 'string' }, exitCode: { type: 'integer' }, note: { type: 'string' },
       ranTests: { type: 'boolean' },
@@ -440,13 +457,32 @@ const read = (prompt, options = {}) => agent(`${BASE}\n\n${prompt}`, options)
 const run = (prompt, options = {}) => agent(`${SCOPE()}\n\n${prompt}`, options)
 const write = (prompt, options = {}) => agent(`${LEDGER()}\n\n${prompt}`, options)
 
-// Las tres paradas que dejan una fila en HUMAN_ACTIONS delegan esa escritura a un agente, y esa fila es
-// el único rastro de la parada: sin ella el recorrido informa un estado que el disco no tiene. Por eso
-// se espera —lanzarla y volver en la línea siguiente la abandona— y por eso se mira si contestó.
-// Devuelve lo que hay que agregarle al detalle, vacío cuando la fila quedó pedida. Caso 087.
-const registerHuman = async (prompt, label) => (await write(prompt, { label })
-  ? ''
-  : ` — la fila en ${HUMAN} no se pudo registrar: escribila a mano`)
+// Las paradas que dejan una fila en HUMAN_ACTIONS delegan esa escritura a un agente, y esa fila es el
+// único rastro de la parada: sin ella el recorrido informa un estado que el disco no tiene. Por eso se
+// espera —lanzarla y volver en la línea siguiente la abandona— y por eso se mira si contestó (caso 087).
+// Devuelve lo que hay que agregarle al detalle, vacío cuando la fila quedó como tiene que quedar.
+//
+// Contestar no alcanza: el agente que acaba de escribir el diagnóstico entero lo lee como ya resuelto, y
+// en una corrida real escribió la fila `resuelta` y la firmó como «decidido por el dueño», desbloqueando
+// la tarea sin que nadie decidiera nada (caso 180). Por eso cada pedido arranca diciendo que la fila nace
+// pendiente, y cuando la fila es de la propia tarea se relee en `context`, que sólo lista las pendientes.
+const HUMAN_ROW_STATE = 'La fila nace con estado `pendiente`, sin excepción: registrás el bloqueo, no lo '
+  + 'resolvés —lo resuelve una persona—. No escribas una decisión ni se la atribuyas a nadie.'
+const registerHuman = async (prompt, label, slug = '') => {
+  if (!(await write(`${HUMAN_ROW_STATE}\n\n${prompt}`, { label }))) {
+    return ` — la fila en ${HUMAN} no se pudo registrar: escribila a mano`
+  }
+  if (!slug) return ''
+  const row = await read(
+    `Corré "node tools/ops.js context ${P} --json" desde ${ROOT}. Poné pending en true sólo si humanActions `
+    + `trae una fila cuya task sea ${slug}, y readOk en true sólo si el comando salió con código 0 y devolvió `
+    + 'JSON. El comando es la fuente de verdad: no abras archivos de planning.',
+    { schema: HUMAN_ROW, label: 'human-row' },
+  )
+  if (!row || !row.readOk) return ` — no se pudo comprobar la fila de ${slug} en ${HUMAN}: revisala a mano`
+  return row.pending ? ''
+    : ` — la fila de ${slug} en ${HUMAN} no quedó pendiente: la resuelve una persona, revisala a mano`
+}
 
 // Gate, mutex de WIP y selección de tarea salen de un comando determinista: AWAITING_REVIEW, BACKLOG,
 // WIP y HUMAN_ACTIONS nunca entran al contexto de un modelo, y su tamaño deja de costar tokens.
@@ -541,6 +577,10 @@ while (rounds++ < MAX_TASKS) {
   const DECIDED = () => (task.description
     ? ` Lo que la línea de la tarea ya decidió, y no se re-decide acá: ${task.description}`
     : '')
+  // Sobrevive al bloque del plan porque Build vive afuera —y porque una corrida que reanuda desde un WIP
+  // no tiene plan en memoria—. Sin esto la estrategia no era que se descartara: es que no estaba en
+  // alcance, que es la forma que ninguna prueba de la fase ve.
+  let testStrategy = ''
   const task = {
     id: planning.slug, hito: planning.hito, service: planning.service,
     acceptance: planning.acceptance, epic: planning.epic, epicContext: planning.epicContext || '',
@@ -552,13 +592,13 @@ while (rounds++ < MAX_TASKS) {
   // por eso perder la carrera no es un error: se relee y se sigue con la que quedó libre.
   if (!planning.claimed && !planning.wipActive) {
     phase('Claim')
-    const reserva = await write(
+    const claim = await write(
       `Corré "node tools/ops.js claim ${P} ${task.id}" desde ${ROOT}. No escribas ningún archivo vos: lo ` +
       `escribe el comando. claimed=true sólo con exit 0; si falla porque la tomó otro, claimed=false y ` +
       `copiá el mensaje en details.`,
       { schema: CLAIM, label: `claim:${task.id}` },
     )
-    if (!reserva || !reserva.claimed) {
+    if (!claim || !claim.claimed) {
       planning = await readContext()
       if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
       // Perder la carrera es legítimo y se ve en que la cola pasa a ofrecer **otra** tarea: quien la
@@ -577,7 +617,7 @@ while (rounds++ < MAX_TASKS) {
       if (planning.hasTask && planning.slug === task.id && !planning.claimed) {
         return stop('claim-stuck', `${task.id} sigue siendo la próxima tarea y no se pudo reclamar. `
           + `context la ofrece y claim la rechaza, así que repetir no cambia nada. `
-          + `El reclamo contestó: ${(reserva && reserva.details) || '(sin detalle)'}`)
+          + `El reclamo contestó: ${(claim && claim.details) || '(sin detalle)'}`)
       }
       // Con qué sigue, que es lo que cambia respecto de lo que esperaba quien autorizó la corrida: se
       // pidió un hito y se va a construir otra tarea de ese hito. Sin decirlo, el cambio sólo aparece al
@@ -691,12 +731,12 @@ while (rounds++ < MAX_TASKS) {
 
   const planRejected = async (reason, unit, found) => {
     const detail = found.join('; ') || 'sin condiciones nombradas'
-    const nota = await registerHuman(
+    const note = await registerHuman(
       `Registrá ${unit.id} en ${HUMAN}: nadie pudo escribir un plan que sobreviva a la crítica. `
       + `Motivo: ${detail}. La acción humana es revisar si la unidad son dos resultados con vidas `
-      + `distintas y partirla, o dejarla entera con la razón escrita.`, 'plan-human')
+      + `distintas y partirla, o dejarla entera con la razón escrita.`, 'plan-human', unit.id)
     await releaseBlocked()
-    return stop(reason, `${detail}${nota}`)
+    return stop(reason, `${detail}${note}`)
   }
 
   if (!planning.wipActive) {
@@ -711,11 +751,11 @@ while (rounds++ < MAX_TASKS) {
       )
       if (!ready) return stop('agent-unavailable', 'Ready no devolvió resultado')
       if (!ready.ready) {
-        const nota = await registerHuman(
+        const note = await registerHuman(
           `Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`,
-          'ready-human')
+          'ready-human', task.id)
         await releaseBlocked()
-        return stop('not-ready', `${ready.reason}${nota}`)
+        return stop('not-ready', `${ready.reason}${note}`)
       }
       if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
     }
@@ -821,6 +861,7 @@ while (rounds++ < MAX_TASKS) {
       if (!critique.consulted.length) return stop('critique-unbacked', 'aprobó el plan sin declarar qué inspeccionó')
     }
     }
+    testStrategy = plan.testStrategy || ''
     phase('WIP')
     // Esta llamada escribe un archivo y nada más, y hay que decirlo con todas las letras. En una corrida
     // real hizo el trabajo entero: leyó los pasos del plan como una orden, implementó, corrió RED/GREEN,
@@ -833,7 +874,15 @@ while (rounds++ < MAX_TASKS) {
       `en DONE. Los pasos van sin tildar porque todavía no ocurrieron. task=${task.id}, ` +
       `hito=${JSON.stringify(task.hito)}, phase=Build, service=${task.service}, ` +
       `acceptance=${JSON.stringify(task.acceptance)}, lane=${planning.lane || 'sin clasificar'}, ` +
-      `pasos sin tildar=${JSON.stringify(plan.steps)}. ` +
+      `pasos sin tildar=${JSON.stringify(plan.steps)}, ` +
+      // La estrategia de prueba es `required` en el plan y hasta acá se descartaba, así que un paso que
+      // decía «correr la mutación declarada en testStrategy» apuntaba a un lugar que no existía: quien
+      // revisa no podía distinguir la mutación corrida de la pensada, y la única salida que le quedaba
+      // era rehacer la revisión. R9 pide la mutación **declarada**, y el WIP es donde queda escrita.
+      //
+      // Es la tercera vez que algo decidido no llega a quien decide después: el contexto de la épica
+      // (027), la descripción de la tarea (177) y esto. Las tres se arreglan igual — que viaje.
+      `testStrategy=${JSON.stringify(testStrategy)}. ` +
       `Registrá el reparto de cargos ${JSON.stringify(cast)} en las decisiones del WIP, para que después se ` +
       `pueda auditar quién revisó qué. Seguí el contrato de WIP exactamente y reportá con qué status quedó.`,
       { label: 'wip', schema: {
@@ -877,7 +926,8 @@ while (rounds++ < MAX_TASKS) {
     `nombrás en test y anotás en redFirst—, kind=open si lo notaste y no impide entregar la aceptación: se ` +
     `registra para que lo decida quien corresponde y el recorrido sigue. Si de verdad no podés entregar sin ` +
     `esa decisión, eso no va en discovered: es completed=false con su blocker. ` +
-    `Aceptación: ${task.acceptance}.${DECIDED()}`,
+    `Aceptación: ${task.acceptance}.${DECIDED()}`
+    + (testStrategy ? ` Estrategia de prueba que el plan fijó: ${testStrategy}` : ''),
     { schema: BUILD, label: 'build' },
   )
   if (!build) return stop('agent-unavailable', 'Build no devolvió resultado')
@@ -1005,11 +1055,11 @@ while (rounds++ < MAX_TASKS) {
     if (filed.length) {
       // La nota que devuelve viaja al hecho: sin ella la entrega afirma una fila que el disco no tiene,
       // que es el caso 087 entrando por otra puerta.
-      const nota = await registerHuman(`Registrá en ${HUMAN} una fila por cada decisión que la revisión de `
+      const note = await registerHuman(`Registrá en ${HUMAN} una fila por cada decisión que la revisión de `
         + `${task.id} dejó abierta, con qué la cierra y quién puede tomarla. La primera columna nunca es `
         + `${task.id} —el porqué es el mismo que en Build—: va la épica, el hito o el recorrido al que `
         + `alcanza. No inventes responsables ni fechas: ${JSON.stringify(filed)}`, 'review-human')
-      decidedNote = `${nota}`
+      decidedNote = `${note}`
     }
     reviewFact = `${review.verdict} por ${cast.review}, sobre ${review.consulted.join(', ')}`
       + (filed.length ? ` · ${filed.length} decisión(es) registrada(s)${decidedNote}` : '')
@@ -1043,11 +1093,25 @@ while (rounds++ < MAX_TASKS) {
   }
 
   phase('Verify')
+  // Lo declarado `(fuera de verify: …)` se separa acá y no se le explica a Verify: la aceptación es texto
+  // conocido antes de preguntar, y dejar que el modelo reconozca la marca en la respuesta es apostar a que
+  // enumere los criterios con el mismo corte. `check` ofrecía la marca y el recorrido la mandaba igual,
+  // así que la condición terminaba en `uncovered` y la corrida en `verify-hollow` (caso 195).
+  const conditions = acceptanceConditions(task.acceptance)
+  const outOfVerify = conditions.filter((one) => OUT_OF_VERIFY.test(one))
+  const checkable = outOfVerify.length
+    ? conditions.filter((one) => !OUT_OF_VERIFY.test(one)).join('; ')
+      || 'ninguna: todas se declararon fuera de verify'
+    : task.acceptance
   const VERIFY_ASK = `${asRole(cast.verify)}Abrí el fuente de los tests que la tarea agregó o cambió y ` +
     `contrastá cada criterio ` +
     `de aceptación contra sus aserciones: en uncovered va el criterio que ningún test codifica, con su causa ` +
     `—missing-test si el test falta o no asercia la propiedad, ambiguous si el criterio no dice qué habría ` +
-    `que aserciar—. Un test que pasa sin aserciarla no la cubre. Después corré los gates reales de ${task.service}. ` +
+    `que aserciar, no-surface si se cumple en un artefacto que no se ejecuta, como un documento o una ` +
+    `decisión escrita, y con reason diciendo cuál—. no-surface vale sólo si la tarea no tocó ningún archivo ` +
+    `que no termine en ${NON_EXECUTABLE.join(', ')}; con cualquier otro en el diff es missing-test. En ` +
+    `covered va cada criterio que un test sí codifica, con el nombre de ese test. ` +
+    `Un test que pasa sin aserciarla no la cubre. Después corré los gates reales de ${task.service}. ` +
     // Descubrir la puerta es trabajo de modelo repetido en cada tarea sobre una respuesta que no cambia,
     // y encima adivinable: el proyecto la declara en `verify` y ahí deja de adivinarse. Cuando no la
     // declara se vuelve a descubrir, que es lo que pasaba siempre.
@@ -1060,7 +1124,7 @@ while (rounds++ < MAX_TASKS) {
     `Leé los exit codes de verdad. ` +
     `passed=true exige comandos corridos y ninguna regresión causada por la tarea. Marcá ranTests en el ` +
     `comando que haya corrido las pruebas, sea cual sea su nombre. ` +
-    `Aceptación: ${task.acceptance}.`
+    `Aceptación: ${checkable}.`
   let verified = await run(VERIFY_ASK, { schema: VERIFY, label: 'verify' })
   if (!verified) return stop('agent-unavailable', 'Verify no devolvió resultado')
   // Un criterio que nadie sabe cómo aserciar no es trabajo que falta sino una definición que falta, y
@@ -1068,14 +1132,18 @@ while (rounds++ < MAX_TASKS) {
   // hacer parar a una persona por eso le cobra una interrupción por algo que se resolvía solo.
   const ambiguous = verified.uncovered.find((entry) => entry.cause === 'ambiguous')
   if (ambiguous) {
-    const nota = await registerHuman(
+    const note = await registerHuman(
       `Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
-      `que aserciar, y hace falta la decisión que lo fija.`, 'verify-human')
-    return stop('acceptance-ambiguous', `${ambiguous.criterion}${nota}`)
+      `que aserciar, y hace falta la decisión que lo fija.`, 'verify-human', task.id)
+    return stop('acceptance-ambiguous', `${ambiguous.criterion}${note}`)
   }
-  if (verified.uncovered.length) {
+  // Lo que no tiene superficie no frena ni rebota: viaja a Done, que lo escribe como `tests: n/a`. Se filtra
+  // por exclusión y no por `missing-test` para que una causa que no se conozca siga frenando (R27). Que
+  // el modelo no lo use para cerrar sin pruebas lo sostiene `check`, que mira qué tocó el commit.
+  const lacking = () => verified.uncovered.filter((entry) => entry.cause !== 'no-surface')
+  if (lacking().length) {
     await run(`${asRole(cast.build)}Escribí sólo las pruebas que faltan en ${task.id}, con el mismo rojo ` +
-      `previo, y no toques el código de producción: ${verified.uncovered.map((e) => e.criterion).join('; ')}`,
+      `previo, y no toques el código de producción: ${lacking().map((e) => e.criterion).join('; ')}`,
       { label: 'missing-tests' })
     verified = await run(VERIFY_ASK, { schema: VERIFY, label: 'verify' })
     if (!verified) return stop('agent-unavailable', 'la segunda pasada de Verify no devolvió resultado')
@@ -1087,21 +1155,29 @@ while (rounds++ < MAX_TASKS) {
   if (build.redFirst.length && !ranTests) {
     return stop('verify-untested', `${task.id} escribió pruebas y ningún gate corrió una`)
   }
-  if (verified.uncovered.length) {
-    return stop('verify-hollow', `sin test que lo codifique: ${verified.uncovered.map((e) => e.criterion).join('; ')}`)
+  if (lacking().length) {
+    return stop('verify-hollow', `sin test que lo codifique: ${lacking().map((e) => e.criterion).join('; ')}`)
   }
+  const noSurface = verified.uncovered.filter((entry) => entry.cause === 'no-surface')
+  const covered = verified.covered || []
+  // Toda la tarea sin superficie: no hay comportamiento que ejercitar, y saltear QA en silencio dejaría sin
+  // mirar lo único que se puede mirar, que el documento esté y diga lo que la aceptación enumera.
+  const onlyDocument = noSurface.length > 0 && !covered.length
 
   // QA ejercita comportamiento, y lo mecánico no lo cambia: el valor literal que la aceptación nombra
   // ya lo comprobó Verify contra el test, y en `directo` además lo mira el revisor que nombra el cast.
   let qa = { passed: true, evidence: 'carril mecánico: la aceptación queda comprobada en Verify' }
   if (!mechanical) {
     phase('QA')
-    qa = await run(
-      `${asRole(cast.qa)}${lite
+    qa = await run(onlyDocument
+      ? `${asRole(cast.qa)}${task.id} no tiene superficie ejecutable: comprobá que el documento existe y cubre ` +
+        `cada elemento que la aceptación enumera, y en evidence decí cuáles encontraste y dónde. ` +
+        `Aceptación: ${checkable}.`
+      : `${asRole(cast.qa)}${lite
         ? 'Hacé la comprobación de aceptación real más barata'
         : 'Ejercitá el comportamiento real que ve quien lo usa'} para ` +
       `${task.id}. Las pruebas unitarias solas no son QA. Levantá el mínimo runtime necesario y bajalo ` +
-      `después. Aceptación: ${task.acceptance}.`,
+      `después. Aceptación: ${checkable}.`,
       { schema: QA, label: 'qa' },
     )
     if (!qa) return stop('agent-unavailable', 'QA no devolvió resultado')
@@ -1129,7 +1205,14 @@ while (rounds++ < MAX_TASKS) {
     `"node tools/ops.js release ${P} ${task.id}". En decisions no nombres una fase ni un cargo ` +
     `que no figure en estos hechos. Hechos: lane=${planning.lane || 'sin clasificar'}; ` +
     `review=${reviewFact}; fases=${ran.join(' → ')}; build=${build.summary}; ` +
-    `verify=${JSON.stringify(verified.commands)}; qa=${qa.evidence}; commit=${commit.hash || commit.reason}.`,
+    `verify=${JSON.stringify(verified.commands)}; cubiertos=${JSON.stringify(covered)}; ` +
+    (noSurface.length ? `sin-superficie=${JSON.stringify(noSurface.map(({ criterion, reason }) => ({
+      criterion, reason: reason || 'no se ejecuta' })))}; ` : '') +
+    (outOfVerify.length ? `fuera-de-verify=${JSON.stringify(outOfVerify)}; ` : '') +
+    `qa=${qa.evidence}; commit=${commit.hash || commit.reason}. En tests rastreá cada criterio con la ` +
+    `prueba que cubiertos le asigna` +
+    (noSurface.length ? ', y los de sin-superficie con tests: n/a — <razón>' : '') +
+    (outOfVerify.length ? '; cada condición de fuera-de-verify queda cumplida en tests, qa o commit' : '') + '.',
     { label: 'done' },
   )
   completed.push(task.id)

package/engine/agents/learning-files.js

@@ -138,6 +138,23 @@ function proposalState(text) {
   return frontmatterState(text, 'proposed')
 }
 
+// Las propuestas que alguien descartó diciendo por qué. Es lo que el informe siguiente necesita para no
+// volver a recomendar lo mismo: sin el motivo escrito, una archivada no se distingue de un olvido, y el
+// hallazgo vuelve cada semana con el mismo texto — pasó con cuatro cargos en septiembre de 2026.
+//
+// Lee el documento y no el historial: la fila de `HISTORY.md` recorta la celda a 160 caracteres, y un
+// motivo cortado a la mitad es justo el que se malinterpreta.
+const REASON_LINE = /^-[ \t]*Motivo:[ \t]*(.+)$/m
+
+function discardedProposals(dir) {
+  return proposalFiles(dir).map((name) => {
+    const text = fs.readFileSync(path.join(dir, name), 'utf8')
+    const reason = (text.match(REASON_LINE) || [])[1]
+    if (proposalState(text) !== 'archived' || !reason) return null
+    return { name, reason: reason.trim() }
+  }).filter(Boolean)
+}
+
 // El sufijo `-N` es la segunda corrida del mismo día, y es la que trae el veredicto más nuevo. Sin él
 // en el patrón, más de una cuarta parte de los registros que existían —de cargos y de recorridos—
 // quedaban fuera del ciclo: no entraban a ninguna propuesta y nada lo delataba, que es el modo de fallo
@@ -159,4 +176,5 @@ module.exports = {
   REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME, undecided, blankProposal, SIGNED, CLOSED,
   assertWritableTeam, assertWritable, isoDate, month,
   proposalOrder, proposalFiles, frontmatterState, proposalState, reportFiles, lastOfPeriod,
+  discardedProposals,
 }

package/engine/agents/learning-seal.js

@@ -93,7 +93,7 @@ function proposalFile(root, agent, period = '', kind = 'agent') {
   return path.join(dir, name)
 }
 
-function archive(root, agent, period = '', kind = 'agent') {
+function archive(root, agent, period = '', kind = 'agent', reason = '') {
   const file = proposalFile(root, agent, period, kind)
   const text = fs.readFileSync(file, 'utf8')
   const state = proposalState(text)
@@ -116,31 +116,43 @@ function archive(root, agent, period = '', kind = 'agent') {
   // 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
+  // Descartar lo que alguien decidió exige decir por qué, y el motivo va al documento porque es lo que lee
+  // el informe siguiente (`discardedProposals`). Sin él el hallazgo volvía cada semana: nada distinguía
+  // «se miró y no va» de «nadie lo miró», y el cargo no tenía cómo saber que ya estaba contestado. Una
+  // propuesta con el molde intacto no lo exige: ahí no hubo decisión que explicar, y lo que traía sigue
+  // vivo para la próxima — a menos que quien archiva sí haya mirado los hallazgos y lo diga.
+  const why = reason.replace(/\s+/g, ' ').trim()
+  const blank = undecided(change)
+  if (!blank && !why) {
+    throw new Error(
+      `${path.basename(file)} decide un cambio: descartarlo pide --reason "<por qué no va>". `
+      + 'El motivo es lo que evita que el próximo informe lo vuelva a recomendar.',
+    )
+  }
+  const stamped = text
     .replace(/^status:\s*\S+\s*$/m, 'status: archived')
     // `UNSEALED` y no sólo «pendiente»: desde que se puede archivar una firmada sin decidir, el cuerpo
     // llega diciendo «aprobada» y se quedaba así con el frontmatter en `archived`. Es la contradicción
     // que el comentario de `seal` nombra, por el otro destino.
     .replace(UNSEALED, '- Estado: archivada')
     .replace(/^-[ \t]*Responsable:[ \t]*por definir[ \t]*$/mi, `- Responsable: ${responsible}`)
-    .replace(/^-[ \t]*Fecha:[ \t]*por definir[ \t]*$/mi, `- Fecha: ${isoDate(new Date())}`))
+    .replace(/^-[ \t]*Fecha:[ \t]*por definir[ \t]*$/mi, `- Fecha: ${isoDate(new Date())}`)
+  atomicWrite(file, why ? stamped.replace(/^(-[ \t]*Estado:[ \t]*archivada[ \t]*)$/m, `$1\n- Motivo: ${why}`) : stamped)
   // 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, para que la fila no se lea como un registro a
-  // medias. Son dos y dicen cosas distintas: archivar lo que alguien miró **es** decidir que no cambia
-  // nada, y archivar un documento que nadie decidió es tirar el andamio — la firma se gastó sobre el molde
-  // intacto y no hubo nada que aprobar. Escribir el primero sobre el segundo pondría en el historial que se
-  // miró algo que nadie miró, y ese archivo es lo que alguien lee dentro de seis meses.
-  const blank = undecided(change)
-  appendHistory(path.dirname(path.dirname(path.dirname(file))), file, responsible,
-    blank ? 'Se archivó sin decidir: el documento quedó con el molde.' : 'Se miró y no cambia nada.',
-    'archivada')
+  // medias. Son dos y dicen cosas distintas: descartar con motivo **es** decidir, y archivar un documento
+  // que nadie decidió es tirar el andamio — la firma se gastó sobre el molde intacto y no hubo nada que
+  // aprobar. Escribir el primero sobre el segundo pondría en el historial que se miró algo que nadie
+  // miró, y ese archivo es lo que alguien lee dentro de seis meses.
+  const verdict = why ? `Descartada: ${why}` : 'Se archivó sin decidir: el documento quedó con el molde.'
+  appendHistory(path.dirname(path.dirname(path.dirname(file))), file, responsible, verdict, 'archivada')
   // `blank` sale acá y no lo recalcula quien imprime: son la misma pregunta, y dos lecturas de la misma
   // sección se separan sin que nada falle.
-  return { file, already: false, blank }
+  return { file, already: false, blank, reason: why }
 }
 
 // Una fila por propuesta cerrada, cualquiera sea el destino. El cambio va en una línea: el documento

package/engine/agents/learning-sources.js

@@ -52,15 +52,17 @@ function evaluateTeam(root, slug) {
 // un nombre compuesto. Cuando eran uno solo el catálogo llegó a 51 etiquetas para estas seis.
 const SOURCE_TIERS = ['advisory', 'platform', 'project', 'regulation', 'standard', 'profession']
 
-// Cada cuánto vale la pena volver a mirar cada tipo. Un aviso publica todos los días y llegar un mes
-// tarde es llegar tarde; una norma se revisa por edición y mirarla cada lunes devuelve el mismo texto.
-// La cadencia de un cargo la fija su fuente más rápida: basta una que corra para que la semana traiga
-// algo, y ninguna otra pierde nada por mirarse antes.
+// Cada cuánto vale la pena volver a mirar cada tipo. La cadencia de un cargo la fija su fuente más
+// rápida, y la más rápida es mensual aunque un aviso publique todos los días: lo que el ciclo produce es
+// un cambio de contrato, que se firma una vez al mes y llega a cada empresa con `upgrade`, así que
+// enterarse el día 7 en vez del 24 no adelanta nada. Hubo una cadencia semanal y se midió (caso 182):
+// en tres semanas, ~353 hallazgos, ninguno urgente, ninguno aplicado y la mitad repetidos.
+// Una norma, en cambio, se revisa por edición, y la profesión cambia más despacio que las dos.
 const TIER_CADENCE = {
-  advisory: 'semanal', platform: 'semanal', project: 'semanal',
+  advisory: 'mensual', platform: 'mensual', project: 'mensual',
   regulation: 'mensual', standard: 'mensual', profession: 'trimestral',
 }
-const CADENCES = ['semanal', 'mensual', 'trimestral']
+const CADENCES = ['mensual', 'trimestral']
 
 // Sale del árbol y no de una lista escrita a mano, por la misma razón que la matriz del cron sale del
 // árbol: una lista paralela se pudre el día que un cargo cambia sus fuentes y nadie la toca.
@@ -79,7 +81,7 @@ function sourceTiers(text) {
 }
 
 // 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
+// fuente declarada y cada corrida la reportaba rota, una vez tras otra — que es exactamente el
 // aviso permanente que la lista existe para no producir.
 function sourcesBody(text) {
   if (!text.includes('sources:')) return ''
@@ -207,8 +209,8 @@ function evaluate(root, agent) {
   const sourcesFile = path.join(target, 'learning', 'sources.yaml')
   if (fs.existsSync(sourcesFile)) {
     const tiers = sourceTiers(fs.readFileSync(sourcesFile, 'utf8'))
-    // Sin fuentes el ciclo semanal no tiene literatura que leer y devuelve un informe vacío cada
-    // semana. Avisa y no bloquea: un cargo que se está escribiendo todavía no las tiene.
+    // Sin fuentes el ciclo no tiene literatura que leer y devuelve un informe vacío en cada
+    // corrida. Avisa y no bloquea: un cargo que se está escribiendo todavía no las tiene.
     if (!tiers.length) warnings.push('sources.yaml sin fuentes: la investigación no tiene qué leer')
     for (const tier of tiers) {
       if (!SOURCE_TIERS.includes(tier)) {
@@ -234,7 +236,7 @@ function evaluate(root, agent) {
         errors.push(`sources.yaml: una pendiente no declara ${missing.join(' ni ')}`
           + `${one.name ? ` (${one.name})` : ''}`)
       }
-      // Declarada y pendiente a la vez es una contradicción que el chequeo semanal no puede resolver:
+      // Declarada y pendiente a la vez es una contradicción que el chequeo de cada corrida 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`)

package/engine/agents/learning.js

@@ -9,6 +9,7 @@ const { atomicWrite } = require('../core/files')
 const {
   REQUIRED_SECTIONS, SUMMARY_MAX, PROPOSAL_NAME, REPORT_NAME, assertWritableTeam, assertWritable, lastOfPeriod,
   isoDate, month, proposalOrder, proposalFiles, frontmatterState, proposalState, reportFiles, CLOSED,
+  discardedProposals,
 } = require('./learning-files')
 // Cerrar una propuesta vive en su propio módulo; se reexporta para no mover a cada llamador.
 const { seal, archive } = require('./learning-seal')
@@ -42,7 +43,8 @@ function markConsolidated(file) {
 }
 
 function prepareReport(root, agent, now = new Date()) {
-  const reports = path.join(assertWritable(root, agent), 'learning', 'reports')
+  const learning = path.join(assertWritable(root, agent), 'learning')
+  const reports = path.join(learning, 'reports')
   const file = path.join(reports, `${isoDate(now)}.md`)
   fs.mkdirSync(reports, { recursive: true })
   if (fs.existsSync(file)) return { file, created: false }
@@ -61,8 +63,8 @@ status: draft
 propone: por-completar
 ---
 
-# Investigación semanal — ${isoDate(now)}
-
+# Investigación — ${isoDate(now)}
+${decided(discardedProposals(path.join(learning, 'proposals')))}
 <!-- 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
@@ -96,8 +98,28 @@ 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
+// Lo que ya se descartó, dicho donde el cargo lo va a leer: en el informe que está por completar, y no
+// en su prompt ni en el `AUTOMATION.md` de cada cargo. Un prompt lo repetiría en cincuenta archivos, y
+// basta uno que no lo copie para que ese cargo vuelva a proponer lo descartado en cada corrida.
+//
+// Va en un comentario, fuera de toda sección, por lo mismo que las convenciones de abajo: dentro de
+// «Recomendación» viajaría a la propuesta mensual.
+function decided(discarded) {
+  if (!discarded.length) return ''
+  const lines = discarded.map(({ name, reason }) => `  · learning/proposals/${name}: ${reason}`)
+  return `
+<!-- Ya se decidió no aplicar estas propuestas. Lo que proponían está en cada archivo, en «Cambio
+propuesto» y «Hallazgos»; el motivo, acá:
+
+${lines.join('\n')}
+
+No vuelvas a recomendar lo descartado. Si encontrás un hecho que el motivo no contemplaba —una versión,
+una fecha, una norma nueva—, recomendalo nombrando la propuesta y qué cambió desde entonces. -->
+`
+}
+
+// Abre la revisión siguiente. No vuelve a consolidar los informes de investigación: 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.
 //
@@ -394,11 +416,11 @@ automatic_apply: false
 
 ## Hallazgos
 
-${summaries.join('\n\n') || 'No hay informes semanales para este período.'}
+${summaries.join('\n\n') || 'No hay informes de investigación para este período.'}
 
 ## Evidencia
 
-Revisar las fuentes primarias enlazadas desde cada informe semanal.
+Revisar las fuentes primarias enlazadas desde cada informe de investigación.
 
 ## Cambio propuesto
 

package/engine/automation/index.js

@@ -25,6 +25,7 @@ const {
 // Qué le falta a la superficie de automatización, que no comparte ayudantes con los tres verbos que
 // escriben. Se reexporta para que sus consumidores sigan pidiéndoselo a este módulo.
 const { check } = require('./check')
+const { registrationProblems } = require('./registration')
 
 // Ejecuta el puente del runner tal como él lo invoca, y desde otra carpeta. Instalado no es lo mismo que
 // operativo: un bridge que el runner no puede lanzar —porque su ruta es relativa y el cwd es otro, o
@@ -48,7 +49,12 @@ function probeBridge(paths, runner) {
   const launchDirs = [paths.install, path.dirname(script)]
   for (const event of hookEvents) {
     for (const cwd of launchDirs) {
-      const payload = JSON.stringify({ toolCall: { args: { CommandLine: 'ls', Cwd: paths.install } } })
+      // Una llamada inocua para el evento que la juzga, y ninguna para los demás: un `pre-files` con un
+      // comando no describe ningún archivo, y el puente niega lo que no sabe describir (caso 200). La
+      // entrada vacía es la forma legítima de no describir nada, y ejercita igual el arranque y la raíz.
+      const payload = JSON.stringify(event === 'pre-shell'
+        ? { toolCall: { args: { CommandLine: 'ls', Cwd: paths.install } } }
+        : {})
       const result = spawnSync(process.execPath, [script, event], { cwd, input: payload, encoding: 'utf8' })
       let response = {}
       try { response = JSON.parse((result.stdout || '').trim()) } catch { response = {} }
@@ -68,7 +74,9 @@ function probeBridge(paths, runner) {
   return problems
 }
 
-function doctor(root, name, output = console) {
+// `afterInstall` es la llamada con la que cierra `install`: ahí una copia registrada vieja es el paso que sigue
+// —registrar lo que se acaba de instalar—, no una instalación rota, así que se avisa en vez de fallar.
+function doctor(root, name, output = console, { afterInstall = false } = {}) {
   const runner = runnerManifest(root, name)
   const paths = runnerPaths(root, name, runner)
   const errors = []
@@ -151,6 +159,7 @@ function doctor(root, name, output = console) {
   }
   // Un puente que no responde niega cada llamada del runner: es error, no advertencia.
   for (const problem of probeBridge(paths, runner)) errors.push(problem)
+  for (const problem of registrationProblems(paths, runner)) (afterInstall ? warnings : errors).push(problem)
 
   const executable = spawnSync(
     'sh',