@ingeniomaps/cauce 0.96.0 → 0.98.0

package/automatization/workflows/flow.js

@@ -111,16 +111,30 @@ const STAGE = {
   properties: {
     gate: { type: 'string', enum: ['cumplido', 'con-condiciones', 'no-cumplido'] },
     // La ruta del análisis, no el análisis. Ver el comentario de arriba: mientras el campo pudo
-    // contener el texto entero, lo contuvo, y la respuesta no llegaba.
-    analysis: { type: 'string' }, summary: { type: 'string' },
-    evidence: { type: 'array', items: { type: 'string' } },
-    assumptions: { type: 'array', items: { type: 'string' } },
-    openQuestions: { type: 'array', items: { type: 'object', additionalProperties: false,
+    // contener el texto entero, lo contuvo, y la respuesta no llegaba. Es la única excepción al techo:
+    // una ruta se acota sola.
+    analysis: { type: 'string' },
+    // Y el resto lleva su techo por la misma razón, que el arreglo de `analysis` no alcanzó a cubrir: la
+    // etapa que **frena** escribe largo en `missing` y `humanAction` —lo dice el párrafo de arriba y lo
+    // volvió a mostrar una corrida sobre un banco, con los cinco reintentos envueltos—. Sin tope, cada
+    // campo nuevo nace sin él y lo que revienta es la etapa que menos se ejercita.
+    //
+    // Los números salen de lo que el prompt ya pedía —`summary` en 150 palabras o menos, que es del orden
+    // de mil caracteres— y de R16: entre etapas viaja lo que la siguiente necesita para decidir, no todo
+    // lo que la anterior produjo. Lo que no entra no se pierde: vive en el archivo de análisis.
+    //
+    // Un techo por debajo de lo que el prompt pide no acota: contradice. Medido en una corrida real con
+    // `summary` en 400, el agente achicó en cada reintento —2766, 2078, 2064, 1934, 1854— y murió
+    // convergiendo hacia un número siete veces menor que el que la misma instrucción le pedía escribir.
+    summary: { type: 'string', maxLength: 1000 },
+    evidence: { type: 'array', maxItems: 5, items: { type: 'string', maxLength: 200 } },
+    assumptions: { type: 'array', maxItems: 4, items: { type: 'string', maxLength: 160 } },
+    openQuestions: { type: 'array', maxItems: 4, items: { type: 'object', additionalProperties: false,
       required: ['detail', 'blocking'],
-      properties: { detail: { type: 'string' }, blocking: { type: 'boolean' } },
+      properties: { detail: { type: 'string', maxLength: 200 }, blocking: { type: 'boolean' } },
     } },
-    missing: { type: 'string' },
-    humanAction: { type: 'string' },
+    missing: { type: 'string', maxLength: 500 },
+    humanAction: { type: 'string', maxLength: 500 },
   },
 }
 // Tres salidas porque el contrato del equipo enumera tres —«hacer, no hacer o investigar»— y con un
@@ -281,14 +295,16 @@ const runStage = (stage, index) => {
     `condiciona la decisión siguiente. ` +
     `Escribí primero tu análisis completo en ${REPORTS} como ${stage.id}-analisis.md —ahí no hay ` +
     `límite de extensión y es lo que lee quien sintetiza al final— y devolvé esa ruta en analysis.\n` +
-    `Lo que devolvés en el esquema es corto, todo junto por debajo de 2000 caracteres: si algo no ` +
-    `entra, va al archivo y en el campo queda lo esencial. Vale también para missing y humanAction ` +
-    `cuando el gate no se cumple, que es cuando más se escribe. ` +
+    `Lo que devolvés en el esquema es corto y cada campo tiene su tope, que el esquema rechaza si lo `
+    + `pasás: summary 1000 caracteres, missing y humanAction 500, cada evidencia 200. Si algo no entra, `
+    + `va al archivo y en el campo queda lo esencial. El tope rige sobre todo cuando el gate no se `
+    + `cumple, que es cuando más se escribe. ` +
     `Devolvé los campos directamente: nunca envuelvas la respuesta en {"raw": ..., "len": ...} ni ` +
     `mandes el JSON como string adentro de un campo, porque eso no valida. ` +
-    `En summary va, en 150 ` +
-    `palabras o menos, lo que la etapa siguiente necesita para decidir —no un resumen de tu análisis, ` +
-    `sino lo que le cambia el trabajo—, porque eso se le reenvía a cada etapa posterior.`,
+    `En summary va, en los 1000 caracteres que el esquema admite, lo que la etapa siguiente necesita ` +
+    `para decidir —no un resumen de tu análisis, sino lo que le cambia el trabajo—, porque eso se le ` +
+    `reenvía a cada etapa posterior. El límite va en caracteres y no en palabras porque es lo que el ` +
+    `esquema mide.`,
     { schema: STAGE, label: `stage:${stage.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/cli/args.js

@@ -7,7 +7,7 @@
 // Banderas que consumen el argumento siguiente: su valor no es un posicional.
 const VALUED_FLAGS = new Set([
   '--name', '--mode', '--fixture', '--period', '--record', '--runner', '--integration',
-  '--task', '--promote', '--hito',
+  '--task', '--promote', '--hito', '--reason',
 ])
 
 // Qué acepta cada comando, y a la vez qué comandos existen. Una bandera desconocida se rechaza en vez
@@ -36,7 +36,7 @@ const FLAGS = {
   integration: ['--fixture'],
   secrets: [],
   automation: ['--force'],
-  learn: ['--flow', '--proposal', '--applied', '--archived', '--period'],
+  learn: ['--flow', '--proposal', '--applied', '--archived', '--period', '--reason'],
   evaluate: ['--cases', '--json', '--bench', '--force', '--record', '--flow'],
   flow: ['--json'],
 }

package/engine/cli/catalog.js

@@ -91,14 +91,14 @@ function learn(agent, cli) {
     // y lo que se hacía era mergear el PR sin firmar — que deja el documento diciendo «sin aplicar»
     // para siempre, indistinguible de una que espera trabajo.
     if (cli.has('--archived')) {
-      const result = L.archive(opsRoot(), agent, cli.value('--period'), kind)
+      const result = L.archive(opsRoot(), agent, cli.value('--period'), kind, cli.value('--reason') || '')
       const relative = path.relative(opsRoot(), result.file)
-      // Los dos archivados no son lo mismo y el mensaje lo dice: uno es una decisión —se miró y no
-      // cambia nada— y el otro es tirar un andamio que nadie llegó a llenar. Afirmar el primero sobre
-      // el segundo le cuenta a quien archiva que hubo una revisión que no hubo.
-      const porque = result.blank
-        ? 'nadie decidió el cambio y el documento quedó con el molde'
-        : 'se miró y no cambia nada'
+      // Los dos archivados no son lo mismo y el mensaje lo dice: uno es una decisión, con su motivo, y
+      // el otro es tirar un andamio que nadie llegó a llenar. Afirmar el primero sobre el segundo le
+      // cuenta a quien archiva que hubo una revisión que no hubo.
+      const porque = result.reason
+        ? `descartada — ${result.reason}`
+        : 'nadie decidió el cambio y el documento quedó con el molde'
       return console.log(result.already
         ? `= ${relative} ya estaba archivada`
         : `✓ ${relative} queda archivada: ${porque}`)
@@ -110,13 +110,13 @@ function learn(agent, cli) {
         ? `= ${relative} ya estaba aplicada`
         : `✓ ${relative} queda aplicada: no se vuelve a aplicar`)
     }
-    // Un recorrido no tiene informe semanal: su propuesta se compone de los veredictos de sus propias
-    // corridas y nunca lee `learning/reports/`. La forma desnuda —la que para un cargo abre el informe
-    // de la semana— no tiene entonces qué abrir acá, y `prepareReport` lo decía resolviendo con el
+    // Un recorrido no tiene informe de investigación: su propuesta se compone de los veredictos de sus
+    // propias corridas y nunca lee `learning/reports/`. La forma desnuda —la que para un cargo abre su
+    // informe— no tiene entonces qué abrir acá, y `prepareReport` lo decía resolviendo con el
     // `kind` por defecto: «no existe agents/<tipo>/<slug>/SKILL.md», que manda a crear un cargo que no
     // falta. Negarse nombrando el comando que sí corresponde es lo que cierra R13.
     if (kind === 'flow' && !cli.has('--proposal')) {
-      fail(`${agent} es un recorrido: aprende de sus corridas, no de informes semanales.\n`
+      fail(`${agent} es un recorrido: aprende de sus corridas, no de informes de investigación.\n`
         + `  Abrí la propuesta con "ops learn ${agent} --flow --proposal".`, USAGE)
     }
     // `--period` es para consolidar a mano un mes que no es el de hoy. El ciclo automático no lo
@@ -137,7 +137,7 @@ function learn(agent, cli) {
     if (typeof result.reports === 'number') {
       console.log(kind === 'flow'
         ? `  ${result.reports} corrida(s) consolidada(s), ${result.findings} hallazgo(s)`
-        : `  ${result.reports} informe(s) semanal(es) incluidos`)
+        : `  ${result.reports} informe(s) de investigación incluidos`)
     }
     // Lo lee quien automatiza el ciclo para no pedir una firma por un documento que no decide nada, y
     // también quien lo corre a mano: sin esta línea el archivo se ve terminado y no lo está. Se pregunta

package/engine/cli/ops.js

@@ -180,7 +180,8 @@ function usage() {
   ops automation doctor <ops-root> claude|codex|gemini|antigravity
   ops automation install <ops-root> claude|codex|gemini|antigravity
   ops automation uninstall <ops-root> claude|codex|gemini|antigravity
-  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied|--archived [--period <AAAA-MM>]]
+  ops learn <agent|flow> [--flow] [--proposal [--period <AAAA-MM>]] [--applied [--period <AAAA-MM>]]
+  ops learn <agent|flow> [--flow] --archived [--period <AAAA-MM>] [--reason <motivo>]
   ops evaluate <agent|flow> [--flow] [--cases [--json]] [--bench [caso]] [--record [AAAA-MM-DD]]
   ops agents list [ops-root] [--own|--system] [--json]
   ops agents fork <cargo> [ops-root]

package/engine/cli/planning.js

@@ -162,11 +162,14 @@ function context(dir, cli) {
   const report = {
     // Toda la cola trabada por una persona no es lo mismo que no tener cola, y decir lo segundo manda a
     // buscar trabajo que no existe en vez de a resolver la fila que lo destraba.
-    blocked: fs.existsSync(gate) ? 'awaiting-review' : (!task && skipped.length ? 'blocked-on-human' : ''),
+    blocked: P.checkpointHolds(root) ? 'awaiting-review' : (!task && skipped.length ? 'blocked-on-human' : ''),
     task: task && {
       slug: task.slug, hito: task.hito, tier: task.tier, cast: task.cast, service: task.service,
       // Una tarea puede heredar su aceptación del criterio citado; el runner necesita el texto, no la cita.
       acceptance: task.acceptance || criteria.map((criterion) => criterion.text).join(' '),
+      // Las decisiones que la línea ya tomó. Viaja con la tarea y no aparte porque es de ella: quien la
+      // reciba tiene que poder leerla al lado de su aceptación, que es contra lo que se contrasta.
+      description: task.description || '',
       epic: task.epic,
     },
     criteria,

package/engine/hooks/approval.js

@@ -104,9 +104,11 @@ function HOW(variable, lines, input, pasteable = lines) {
   // `check` la muestra al final de la corrida —es lo que trajo el 117—, y al concederla no la decía nadie
   // (caso 170).
   const ask = chat
-    ? 'Decile a la persona qué se frenó y por qué, y esperá: si contesta «dale», reintentá el mismo cambio y '
-      + 'pasa. Ese «dale» cubre lo que se frenó y nada más —algo nuevo vuelve a frenar— y sigue valiendo en '
-      + 'los mensajes siguientes hasta que ella lo niegue. '
+    ? 'Decile a la persona qué se frenó y por qué, y pedile que lo confirme con sus palabras: un «dale» '
+      + 'alcanza, pero no hace falta esa palabra. Si lo que contesta es un sí, reintentá el mismo cambio y '
+      + 'pasa; si duda, pregunta o dice que no, no reintentes. Juzgarlo te toca a vos: el guard sólo frena la '
+      + 'respuesta que niega, frena o pregunta. Esa confirmación cubre lo que se frenó y nada más —algo nuevo '
+      + 'vuelve a frenar— y sigue valiendo en los mensajes siguientes hasta que ella lo niegue. '
     : ''
   const paste = pasteable.length
     ? (chat ? 'Si prefiere aprobarlo a mano, que pegue ella tal cual en' : 'Aprobalo pegando tal cual en')

package/engine/hooks/chat.js

@@ -157,10 +157,15 @@ function ordersPush(text, item) {
   })
 }
 
-// Quien contesta a un bloqueo que quedó pendiente. Sólo el principio del mensaje: «dale» es la respuesta
-// entera o su primera palabra, no algo que aparece en medio de otra frase.
-const YES = new RegExp(String.raw`^\s*(?:s[ií]|dale|ok(?:ay)?|hac[eé]lo|hazlo|adelante|aprobado|apruebo`
-  + String.raw`|aprob[aá]lo|de acuerdo|yes)(?![\p{L}])`, 'iu')
+// Quien contesta a un bloqueo que quedó pendiente lo confirma con sus palabras, y juzgar si lo que dijo
+// es un sí le toca al agente que lo lee. Antes el guard exigía que el mensaje **empezara** con una de once
+// formas —«dale», «sí», «ok»…—, así que «listo», «claro», «confirmo» o «bueno dale» volvían a frenar lo
+// que la persona acababa de aprobar (caso 184). Lo único que el guard sigue decidiendo es la dirección
+// segura: un mensaje que niega, que arranca frenando o que pregunta no aprueba nada. Si eso se equivoca,
+// el costo es volver a preguntar; si se equivocara al revés, un «no» o un «¿para qué sirve?» ejecutaría lo
+// que la persona no aprobó.
+const HALT = /^\s*(?:par[aá]|deten\p{L}*|esper[aá]|cancel\p{L}*|stop|wait|hold on)(?![\p{L}])/iu
+const refuses = (text) => NEGATION.test(text) || HALT.test(text) || /[?¿]/.test(text)
 
 // El hook de mensaje. Nunca frena: un mensaje de la persona no se bloquea, y sin registro los guards
 // deciden como antes. Un texto que empieza con una etiqueta no lo escribió una persona —Claude avisa así
@@ -175,7 +180,7 @@ function record(input) {
     const text = String(input.prompt || '')
     const human = !process.env.CI && !/^\s*</.test(text)
     const previous = load(input.session_id)
-    const approved = human && previous && YES.test(text)
+    const approved = human && previous && !refuses(text)
       ? previous.pending.filter((item) => !mentions(text, item).denied)
       : []
     const granted = previous ? (previous.granted || []).filter((one) => !mentions(text, one).denied) : []
@@ -322,13 +327,20 @@ function unauthorizedNow(input, items) {
   return items.filter((item) => !cleared.has(item))
 }
 
-// Lo que quedó frenado, para que un «dale» en el mensaje siguiente apruebe exactamente eso y nada más.
+// Lo que quedó frenado, para que la confirmación del mensaje siguiente apruebe exactamente eso y nada más.
 // Devuelve si hay una persona a quien preguntarle.
+//
+// Si el mensaje en curso niega o frena, lo que se ataje en su turno no queda esperando: la persona ya
+// contestó que no antes de que el agente lo intentara. Desde que confirmar no exige una palabra (caso 184),
+// dejarlo pendiente hacía que un «seguí con lo tuyo» aprobara el `.env` o el push que ella acababa de
+// prohibir. Se mira el mensaje y no el ítem porque un push no se nombra como un archivo.
 function hold(input, items) {
   const saved = present(input)
   if (!saved) return false
   try {
-    saved.pending = [...new Set([...saved.pending, ...items])]
+    const text = saved.text || ''
+    const open = NEGATION.test(text) || HALT.test(text) ? [] : items
+    saved.pending = [...new Set([...saved.pending, ...open])]
     fs.writeFileSync(recordPath(input.session_id), JSON.stringify(saved))
     return true
   } catch { return false }

package/engine/hooks/push.js

@@ -105,7 +105,7 @@ function liveMessage(live, input) {
   // una sesión real, con «pegando tal cual» a secas el agente se ofreció a escribirse la aprobación.
   return `'git push' publica cambios en ${names}, la rama viva, y requiere una acción humana: ni `
     + 'runner.allowPush ni una orden en el chat llegan ahí sin un permiso por rama. Decile a la persona qué '
-    + 'se frenó y esperá: un «dale» no lo destraba. Lo da ella, nombrando la rama en '
+    + 'se frenó y esperá: confirmarlo en el chat no lo destraba. Lo da ella, nombrando la rama en '
     + 'runner.pushToLiveBranches de ops.config.json, que la deja como una rama de trabajo'
     + (lines.length ? `, o pegando ella tal cual en ${AP.where(input)} estas líneas:\n`
       + lines.map((line) => `  ${line}\n`).join('') : '.')
@@ -115,7 +115,8 @@ function workMessage(items, input) {
   const lines = items.filter((item) => item.startsWith('push '))
   const chat = CHAT.hold(input, items)
   const how = chat
-    ? 'Decile a la persona qué se frenó y esperá: si contesta «dale», reintentá el mismo push y pasa. '
+    ? 'Decile a la persona qué se frenó y pedile que lo confirme con sus palabras: si lo que contesta es un '
+      + 'sí, reintentá el mismo push y pasa; si duda, pregunta o dice que no, no reintentes. '
       + 'También pasa si lo pide nombrando el remoto y la rama, como «subí feat/x a origin».'
     : 'Lo destraba una persona pidiéndolo en el chat con el remoto y la rama.'
   const paste = lines.length

package/engine/hooks/self-approval.js

@@ -24,7 +24,7 @@ const CHAT_RECORD = (file) => `${file} es el registro de lo que la persona dijo
   + 'runner, nunca una herramienta.'
 
 const SELF = (file) => `${file} es la aprobación de una persona, y escribírsela es aprobarse solo. Si la `
-  + 'persona quiere autorizar algo, que lo diga en el chat —nombrándolo, o contestando «dale» al bloqueo— o '
+  + 'persona quiere autorizar algo, que lo diga en el chat —nombrándolo, o confirmando el bloqueo— o '
   + 'que edite el archivo ella.'
 
 // Las líneas van en el mensaje porque son lo que el «dale» va a aprobar: una confirmación que no muestra
@@ -32,7 +32,7 @@ const SELF = (file) => `${file} es la aprobación de una persona, y escribírsel
 const UNASKED = (file, missing) => `${file} es la aprobación de una persona y estas líneas no las pidió:\n`
   + missing.map((line) => `  ${line}\n`).join('')
   + 'Escribí sólo lo que ella nombró en su mensaje. Si hacen falta las otras, decile cuáles y por qué, y '
-  + 'esperá: si contesta «dale», reintentá la misma escritura y pasa.'
+  + 'pedile que lo confirme con sus palabras: si lo que contesta es un sí, reintentá la misma escritura y pasa.'
 
 // **Por shell se frena toda escritura.** Es la misma decisión que toma `ops-config`, y por qué un comando
 // no se puede comparar está escrito allá. Lo que la trae hasta acá es que el contenido es lo único que

package/engine/hooks/shell.js

@@ -45,6 +45,20 @@ const COMANDO = String.raw`$|[;&|)'"\`]`
 // de frenar trabajo legítimo nombraba una violación que no estaba.
 const MISMO = String.raw`[^;&|\n]`
 
+// Si algún remoto alcanza al commit que está en HEAD. Lectura local e inocua: `branch -r` mira lo que ya
+// está en `refs/remotes/`, no habla con ningún servidor. Un `fetch` que nadie corrió deja la respuesta
+// desactualizada hacia el lado seguro — cree que no está publicado algo que sí lo está—, y por eso esto
+// acota un bloqueo y no autoriza nada: lo que decide publicar sigue siendo `push`, que mira otra cosa.
+//
+// Sin git, sin repositorio o con el comando fallando, la respuesta es **sí**: cerrado por defecto (R27).
+// No saber si algo se publicó no es lo mismo que saber que no.
+function publishedHead(input) {
+  const cwd = (input && input.cwd) || process.cwd()
+  const result = spawnSync('git', ['branch', '-r', '--contains', 'HEAD'], { cwd, encoding: 'utf8' })
+  if (result.status !== 0) return true
+  return Boolean(result.stdout.trim())
+}
+
 // Un mensaje de commit es dato, no código. `git commit -m "fix: bloquear git push --force"` disparaba
 // el guard de publicación, y lo mismo `rm -rf /` nombrado en una explicación; con el heredoc que se usa
 // para un mensaje largo, el cuerpo entero entra en el comando, así que la línea que arregla esto no se
@@ -80,13 +94,22 @@ function destructive(input) {
   publish(input, command)
   const rules = [
     [/\bgit\s+reset\s+--hard\b/, "'git reset --hard' destruye cambios locales.", true],
-    // R8 lo prohíbe sin excepción configurable y ningún guard lo miraba: `grep -rn amend engine/hooks/`
-    // no devolvía una línea. Se bloquea por política y no por daño —un `--amend` sobre algo que nadie vio
-    // no rompe nada—, así que el mensaje manda a lo que sí corresponde: otro commit.
-    [
+    // Lo que R8 protege es la historia que **otro ya leyó**, y el motor ya hace esa distinción para el
+    // push: publicar se autoriza, reescribir lo publicado no. Acá se hace la misma, mirando si algún
+    // remoto alcanza a HEAD.
+    //
+    // Antes se bloqueaba siempre, «por política y no por daño», y eso no impedía el resultado sino el
+    // comando que lo nombra: `git reset --soft HEAD~1` y volver a commitear produce exactamente lo mismo,
+    // no lo frena ningún guard y no deja constancia de nada. Una regla que se cumple mejor esquivándola se
+    // termina esquivando siempre (caso 178).
+    //
+    // Y no lleva salida por chat ni publicado ni sin publicar: sin publicar no la necesita, y publicado es
+    // la misma reescritura que el force-push, que tampoco la tiene.
+    ...(publishedHead(input) ? [[
       new RegExp(String.raw`\bgit\s+commit\b${MISMO}*\s--amend\b`),
-      "'git commit --amend' reescribe un commit ya creado. R8 pide uno nuevo en su lugar.",
-    ],
+      "'git commit --amend' sobre un commit ya publicado reescribe historia que otro leyó. R8 lo "
+        + 'prohíbe: hacé otro commit encima.',
+    ]] : []),
     [/\bgit\s+clean\s+-[^\s]*f/, "'git clean -f' borra archivos sin seguimiento.", true],
     // `git checkout -- .` destruye lo mismo que `reset --hard` y sin recuperación, pero se escribe como
     // una limpieza. Se bloquea sólo la forma ancha —`.`, `*`, `:/`, o sin ruta—: revertir un archivo
@@ -170,6 +193,39 @@ function gitAdd(input) {
   }
 }
 
+// Un `package.json` cambia sin tocar nada de lo que su lockfile registra: un script, una descripción, la
+// configuración de una herramienta. Frenar eso por la sola presencia del archivo en el índice obligaba a
+// pedir permiso por un cambio sin riesgo (caso 181). Se deja pasar sólo lo medido, y lo demás frena como
+// antes, incluido lo que no se puede comparar.
+//
+// La lista salió de correr `npm install --package-lock-only` con npm 11.16.0 cambiando una clave por vez:
+// las claves name, version, license, engines, bin, funding, workspaces, os y cpu, y los scripts preinstall,
+// install y postinstall, sí mueven el lock. Sólo se midió el lock de npm, así que con otro gestor no se
+// afloja nada.
+const INERT_KEYS = new Set([
+  'scripts', 'description', 'keywords', 'author', 'repository', 'homepage', 'bugs', 'private', 'type',
+  'main', 'files', 'exports', 'config', 'jest', 'eslintConfig', 'prettier',
+])
+const INSTALL_SCRIPTS = ['preinstall', 'install', 'postinstall']
+
+function lockUnaffected(dir, file, lockfiles) {
+  if (path.basename(file) !== 'package.json' || lockfiles.join() !== 'package-lock.json') return false
+  const read = (ref) => {
+    const shown = run('git', ['-C', dir, 'show', `${ref}:${file}`], dir)
+    if (!shown.ok) return null
+    try { return JSON.parse(shown.output) } catch { return null }
+  }
+  const before = read('HEAD')
+  const after = read('')
+  if (!before || !after || typeof before !== 'object' || typeof after !== 'object') return false
+  const same = (one, other) => JSON.stringify(one) === JSON.stringify(other)
+  const changed = [...new Set([...Object.keys(before), ...Object.keys(after)])]
+    .filter((key) => !same(before[key], after[key]))
+  if (changed.some((key) => !INERT_KEYS.has(key))) return false
+  const scripts = (one) => (one && typeof one.scripts === 'object' ? one.scripts : {}) || {}
+  return INSTALL_SCRIPTS.every((name) => same(scripts(before)[name], scripts(after)[name]))
+}
+
 function dependencies(input) {
   if (process.env.OPS_DEPENDENCIES_OVERRIDE === '1') return
   const command = commandOf(input)
@@ -227,6 +283,7 @@ function dependencies(input) {
       block(`${parent}: hay varios lockfiles (${onDisk.join(', ')}). Conserva uno solo.`)
     }
     const manifests = sinAprobar(parent, state.manifests)
+      .filter((name) => !lockUnaffected(dir, name, existingLocks))
     if (state.manifests.length && existingLocks.length && !state.locks.length && manifests.length) {
       block(`${parent}: cambió ${state.manifests.join(', ')} sin actualizar su lockfile.\n`
         + AP.HOW('OPS_DEPENDENCIES_OVERRIDE', manifests, input))