@ingeniomaps/cauce 0.94.0 → 0.95.0

package/engine/cli/claims.js

@@ -9,9 +9,7 @@ const path = require('node:path')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const ST = require('../planning/state')
-const { fail, planningRoot } = require('./io')
-
-const TODAY = () => new Date().toISOString().slice(0, 10)
+const { fail, planningRoot, TODAY } = require('./io')
 
 function claim(dir, slug, cli) {
   const root = planningRoot(dir)
@@ -22,8 +20,8 @@ function claim(dir, slug, cli) {
 
   // No se reserva lo que todavía no se puede empezar: una tarea tomada con su dependencia en vuelo
   // bloquea la cola sin que nadie pueda avanzarla, y el runner que la tomó se queda sin poder tomar otra.
-  const falta = task.depends.find((dep) => !state.done.set.has(dep))
-  if (falta) return fail(`${slug} depende de ${falta}, que todavía no está en DONE.`)
+  const blocker = task.depends.find((dep) => !state.done.set.has(dep))
+  if (blocker) return fail(`${slug} depende de ${blocker}, que todavía no está en DONE.`)
 
   const me = CL.owner(root)
   const from = CL.runner()
@@ -45,7 +43,7 @@ function claim(dir, slug, cli) {
 
   const target = CL.file(root, slug)
   fs.mkdirSync(path.dirname(target), { recursive: true })
-  const cuerpo = CL.content({ task: slug, owner: me, runner: from, started: TODAY(), service: task.service })
+  const body = CL.content({ task: slug, owner: me, runner: from, started: TODAY(), service: task.service })
   try {
     // Reservar **es** crear el archivo, así que el único juez de quién la tiene es el archivo. `wx` falla
     // si ya está, y de ahí sale la respuesta entera: propia, ajena o perdida en la carrera.
@@ -54,25 +52,25 @@ function claim(dir, slug, cli) {
     // de diferencia ganarían los dos sin que ninguno se entere. Y una comprobación previa tampoco
     // alcanzaría —entre mirar y escribir queda la misma ventana—, así que sería un segundo juez que
     // adelanta un veredicto que este bloque tiene que volver a dar igual.
-    fs.writeFileSync(target, cuerpo, { flag: 'wx' })
+    fs.writeFileSync(target, body, { flag: 'wx' })
   } catch (error) {
     if (error.code !== 'EEXIST') throw error
-    const dueño = CL.read(root).find((one) => one.slug === slug)
+    const holder = CL.read(root).find((one) => one.slug === slug)
     // Existía al crear y ya no está: alguien la soltó entre las dos operaciones. Es una ventana de
     // microsegundos y aun así tiene respuesta, porque la alternativa es reventar con un TypeError.
-    if (!dueño) return fail(`${slug} cambió de manos mientras la pedías; volvé a intentarlo.`)
-    if (dueño.runner === from) return console.log(`= ${slug} ya era tuya desde ${dueño.started}`)
+    if (!holder) return fail(`${slug} cambió de manos mientras la pedías; volvé a intentarlo.`)
+    if (holder.runner === from) return console.log(`= ${slug} ya era tuya desde ${holder.started}`)
     // Mismo dueño y otro runner son dos situaciones que se ven idénticas desde acá —vos retomando la
     // sesión de ayer, o un segundo agente tuyo— y ninguna se puede distinguir mirando el archivo.
     // Retomarla sola le sacaría la tarea al otro agente; crear un runner nuevo dejaría dos trabajando lo
     // mismo. Las dos rompen trabajo, así que decide una persona y acá sólo se dice cuál es cuál.
-    if (dueño.owner === me) {
-      return fail(`${slug} la tenés vos, tomada el ${dueño.started} desde el runner ${dueño.runner}. `
+    if (holder.owner === me) {
+      return fail(`${slug} la tenés vos, tomada el ${holder.started} desde el runner ${holder.runner}. `
         + 'Preguntá si se retoma esa sesión —y entonces corré con ese id— o si es otro agente en '
         + `paralelo, que toma otra tarea. \`ops runners ${path.relative(process.cwd(), root) || '.'}\` `
         + 'lista lo que hay abierto.')
     }
-    return fail(`${slug} la tomó ${dueño.owner} el ${dueño.started}. Si se abandonó, borrá `
+    return fail(`${slug} la tomó ${holder.owner} el ${holder.started}. Si se abandonó, borrá `
       + `${CL.DIR}/${slug}.md a mano: soltar lo de otro es una decisión, no un comando.`)
   }
   console.log(`✓ ${slug} tomada por ${me}`)
@@ -111,20 +109,20 @@ function release(dir, slug) {
 function runners(dir, cli) {
   const root = planningRoot(dir)
   const done = ST.snapshot(root).done
-  const abiertos = CL.read(root).filter((one) => !done.set.has(one.slug))
-  const hoy = TODAY()
-  const filas = abiertos.map((one) => {
+  const open = CL.read(root).filter((one) => !done.set.has(one.slug))
+  const today = TODAY()
+  const rows = open.map((one) => {
     const commit = R.lastCommit(R.repoOf(path.join(root, '..'), one.service), CL.branchOf(one.slug))
     return { runner: one.runner, task: one.slug, owner: one.owner, started: one.started, lastCommit: commit }
   })
-  if (cli.has('--json')) return console.log(JSON.stringify(filas))
-  if (!filas.length) return console.log('= ningún runner tiene trabajo abierto: arrancá con un id propio')
-  const ancho = Math.max(...filas.map((one) => one.runner.length))
-  for (const una of filas) {
-    const avance = una.lastCommit ? `último commit ${una.lastCommit}` : 'sin commits en su rama'
-    console.log(`${una.runner.padEnd(ancho)}  ${una.task}  (${una.owner}, desde ${una.started}; ${avance})`)
+  if (cli.has('--json')) return console.log(JSON.stringify(rows))
+  if (!rows.length) return console.log('= ningún runner tiene trabajo abierto: arrancá con un id propio')
+  const width = Math.max(...rows.map((one) => one.runner.length))
+  for (const row of rows) {
+    const progress = row.lastCommit ? `último commit ${row.lastCommit}` : 'sin commits en su rama'
+    console.log(`${row.runner.padEnd(width)}  ${row.task}  (${row.owner}, desde ${row.started}; ${progress})`)
   }
-  console.log(`\n${filas.length} runner(s) con trabajo abierto al ${hoy}. `
+  console.log(`\n${rows.length} runner(s) con trabajo abierto al ${today}. `
     + 'Retomá uno usando su id, o arrancá con uno propio.')
 }
 

package/engine/cli/contract.js

@@ -83,9 +83,18 @@ const MARKED = /^###\s+Límites\s*$/m
 // llevaba adentro los cuatro párrafos que la persona había agregado al final de la sección. Descontar el
 // bloque entero —que es lo que parecía el arreglo— apagaba justo lo que el aviso existe para encontrar.
 const BULLET = /^\s*[-*]\s+/
+// Una viñeta es la viñeta entera, no su primera línea. Un límite de verdad no entra en el ancho del
+// archivo, así que se escribe en dos, y recorriendo línea por línea lo que viajaba al preámbulo de cada
+// subagente era la mitad — cortada justo donde suele estar lo que el límite decide (caso 168).
+//
+// `own` son las líneas **sin plegar**, y existe para `warnings`: descuenta por línea contra lo que el
+// archivo tiene escrito (caso 159), y una viñeta ya plegada no coincide con ninguna de esas líneas, así
+// que su continuación volvía a contarse como un párrafo perdido. Son dos preguntas distintas sobre el
+// mismo bloque: qué dice cada límite, y qué líneas ya están cubiertas.
 function marked(raw) {
   const bullets = []
   const intros = []
+  const own = []
   let rest = raw
   for (let start = rest.search(MARKED); start >= 0; start = rest.search(MARKED)) {
     const after = rest.slice(start).split('\n').slice(1)
@@ -93,13 +102,21 @@ function marked(raw) {
     const block = end < 0 ? after : after.slice(0, end)
     const first = block.findIndex((line) => BULLET.test(line))
     if (first > 0) intros.push(...block.slice(0, first).map((line) => line.trim()).filter(Boolean))
-    bullets.push(...block
-      .filter((line) => BULLET.test(line))
-      .map((line) => line.replace(BULLET, '').trim())
-      .filter(Boolean))
+    // Una línea en blanco cierra la viñeta abierta: lo que venga después es otra cosa y pegarlo ahí
+    // uniría dos límites en uno.
+    let open = -1
+    for (const line of first < 0 ? [] : block.slice(first)) {
+      const text = line.replace(BULLET, '').trim()
+      if (!text) { open = -1; continue }
+      // A `own` va lo que pertenece a una viñeta y nada más. Empujar toda línea no vacía haría que la
+      // prosa suelta que quedó bajo el encabezado contara como declarada y `warnings` dejara de nombrarla:
+      // el plegado apagaría el aviso en vez de arreglar el límite.
+      if (BULLET.test(line)) { bullets.push(text); open = bullets.length - 1; own.push(text) }
+      else if (open >= 0) { bullets[open] += ` ${text}`; own.push(text) }
+    }
     rest = (end < 0 ? '' : after.slice(end).join('\n'))
   }
-  return { bullets, intros }
+  return { bullets, intros, own }
 }
 
 const declared = (raw) => marked(raw).bullets
@@ -147,8 +164,8 @@ function warnings(root) {
   // Se descuenta por línea y no por párrafo, que es donde estaba el defecto: `paragraphs` saca el `- ` y
   // une las viñetas seguidas en un párrafo solo, así que una lista declarada no era igual a ninguna
   // entrada de `declared()` y se contaba entera como un límite perdido (caso 159).
-  const { bullets, intros } = marked(mine)
-  const suyo = new Set([...bullets, ...intros])
+  const { own, intros } = marked(mine)
+  const suyo = new Set([...own, ...intros])
   const outside = P.withoutComments(mine).split('\n')
     .filter((line) => !suyo.has(line.replace(BULLET, '').trim()))
     .join('\n')

package/engine/cli/instance.js

@@ -15,7 +15,7 @@ const P = require('../planning/parser')
 const ST = require('../planning/state')
 const RC = require('../planning/recurring')
 const A = require('../automation')
-const { fail } = require('./io')
+const { fail, TODAY } = require('./io')
 const { declareEngine, pinEngine, undeclareEngine } = require('./dependency')
 const { adviceFor, previewUpgrade, reportUpgrade } = require('./upgrade-report')
 
@@ -98,7 +98,7 @@ function scaffold(root, { name, mode, force = false, quiet = false }) {
     '{{PROJECT_NAME}}': name,
     '{{MODE}}': mode,
     '{{WORKSPACE_PATH}}': mode === 'embedded' ? '.' : '..',
-    ...RC.sinceValues(new Date().toISOString().slice(0, 10)),
+    ...RC.sinceValues(TODAY()),
   }, force, providerNames(), quiet)
   // No se copia `.github/`: `ci.yml` valida el toolkit con `npm run ci` —que una instancia no tiene— y
   // el ciclo de aprendizaje dejó de distribuirse en 0.4.0. Copiar salteando lo que no aplica dejaba
@@ -309,17 +309,17 @@ function upgrade(dir, cli) {
   //
   // El aviso sale en **cada** corrida y no sólo la primera: una instancia con medio molde congelado y
   // sin enterarse es el otro modo de fallo, y es silencioso.
-  const conservados = force ? new Set() : new Set(changed)
-  if (conservados.size) {
-    for (const file of conservados) console.log(`= conservado ${file} (editado localmente)`)
-    console.log(`\n${conservados.size} archivo(s) del molde quedan congelados por tu edición.`)
-    console.log(`${adviceFor([...conservados])}\n`)
+  const keptFiles = force ? new Set() : new Set(changed)
+  if (keptFiles.size) {
+    for (const file of keptFiles) console.log(`= conservado ${file} (editado localmente)`)
+    console.log(`\n${keptFiles.size} archivo(s) del molde quedan congelados por tu edición.`)
+    console.log(`${adviceFor([...keptFiles])}\n`)
     console.log('Para tomar la versión nueva y descartar la tuya, repetí con --force.\n')
   }
   // Un archivo propio que se llama como uno que el paquete empieza a traer (caso 110): se conserva y se
   // dice, igual que una edición local, y `--force` lo reemplaza diciéndolo.
-  const choques = new Set(force ? [] : colliding)
-  for (const file of choques) {
+  const collisions = new Set(force ? [] : colliding)
+  for (const file of collisions) {
     console.log(`= conservado ${file}: ya existía y Cauce no lo entregó, así que el del paquete no se `
       + 'instaló. Renombrá el tuyo y repetí, o repetí con --force para reemplazarlo.')
   }
@@ -345,7 +345,7 @@ function upgrade(dir, cli) {
       '{{PROJECT_NAME}}': config.project || path.basename(root),
       '{{MODE}}': O.mode(root),
       '{{WORKSPACE_PATH}}': O.mode(root) === 'embedded' ? '.' : '..',
-      ...RC.sinceValues(new Date().toISOString().slice(0, 10)),
+      ...RC.sinceValues(TODAY()),
     })) content = content.replaceAll(key, value)
     F.atomicWrite(target, content)
     added.push(relative)
@@ -368,13 +368,13 @@ function upgrade(dir, cli) {
 
   const conservar = (file) => {
     const relative = path.relative(root, file).replace(/\\/g, '/')
-    return conservados.has(relative) || choques.has(relative)
+    return keptFiles.has(relative) || collisions.has(relative)
   }
   for (const relative of [...system, ...O.RUNTIME_PATHS]) {
     const origin = path.join(PROJECT_ROOT, O.sourceOf(relative))
     if (!fs.existsSync(origin)) continue
     const target = path.join(root, relative)
-    if (conservados.has(relative)) continue
+    if (keptFiles.has(relative)) continue
     // Sobrescribe lo que trae el paquete y deja intacto lo demás: un guard propio de la empresa,
     // o un adaptador de runner que el toolkit no conoce, sobreviven a la actualización.
     if (fs.statSync(origin).isDirectory()) copyRuntime(origin, target, false, root, [], conservar)
@@ -389,7 +389,7 @@ function upgrade(dir, cli) {
 
   // Retirar lo que el toolkit ya no distribuye, después de haber actualizado lo que sí.
   const retired = []
-  const pendientes = []
+  const pending = []
   for (const relative of O.RETIRED) {
     const target = path.join(root, relative)
     if (!fs.existsSync(target)) continue
@@ -398,10 +398,10 @@ function upgrade(dir, cli) {
     // también usa para lo suyo, borrar el directorio entero se llevaba puesto contenido que nadie
     // había entregado —un `autobuild.js` propio, los workflows de una empresa— sin confirmación y sin
     // vuelta atrás. Se conserva y se nombra; `--force` es la salida, igual que para una edición local.
-    const contenido = O.RETIRED_COMPARTIDO.includes(relative) && fs.statSync(target).isDirectory()
+    const leftover = O.RETIRED_SHARED.includes(relative) && fs.statSync(target).isDirectory()
       ? O.treeFiles(target)
       : []
-    if (contenido.length && !force) { pendientes.push({ relative, files: contenido }); continue }
+    if (leftover.length && !force) { pending.push({ relative, files: leftover }); continue }
     fs.rmSync(target, { recursive: true, force: true })
     retired.push(relative)
   }
@@ -413,7 +413,7 @@ function upgrade(dir, cli) {
   // conservar **ese** digest: registrar el de disco lo volvería idéntico a lo entregado, dejaría de
   // detectarse como editado y la corrida siguiente lo pisaría sin decir nada. Es el 001 de vuelta por
   // la puerta de atrás, y no se ve mirando el archivo — se ve dos upgrades después.
-  const entregado = { ...record }
+  const delivered = { ...record }
   for (const relative of O.trackedPaths()) {
     if (fs.existsSync(path.join(root, relative))) {
       record = M.record(root, relative, O.deliveredFiles(root, relative), record)
@@ -428,8 +428,8 @@ function upgrade(dir, cli) {
     }
   }
   record = M.recordPaths(root, O.SYSTEM_FILES, record)
-  for (const file of conservados) if (entregado[file]) record[file] = entregado[file]
-  for (const file of choques) delete record[file]
+  for (const file of keptFiles) if (delivered[file]) record[file] = delivered[file]
+  for (const file of collisions) delete record[file]
   // El registro de forks se poda igual que el de archivos: un cargo devuelto al catálogo deja su
   // entrada, y una entrada sin copia sólo puede producir avisos sobre algo que no está.
   const kept = Object.fromEntries(Object.entries(M.readForks(root)).filter(
@@ -447,7 +447,7 @@ function upgrade(dir, cli) {
   // que no ocurrieron (caso 048).
   reportUpgrade({
     root, from, to, system, retired, added, overrides, pinned, droppedBlocks,
-    descartados: force ? changed : [], conservados: [...conservados], pendientes,
+    discarded: force ? changed : [], keptFiles: [...keptFiles], pending,
   })
 }
 

package/engine/cli/ops.js

@@ -195,11 +195,15 @@ const NO_FLAGS = { has: () => false, value: (_flag, fallback = '') => fallback }
 
 async function run(cli) {
   const [command] = cli.positional
-  if (!command || ['help', '--help', '-h'].includes(command)) return usage()
-  if (!FLAGS[command]) { usage(); fail(`Comando desconocido: ${command}`, 2) }
+  // `--help` y `-h` nunca llegan acá: `parse` los reconoce como banderas, así que el posicional queda
+  // vacío y lo atiende el `!command` de al lado. Lo que sí es un posicional es `help` a secas.
+  if (!command || command === 'help') return usage()
+  // `Object.hasOwn` y no `FLAGS[command]`: `constructor` heredado de `Object.prototype` pasaba por
+  // comando válido y el CLI salía con 0 sin hacer nada.
+  if (!Object.hasOwn(FLAGS, command)) { usage(); fail(`Comando desconocido: ${command}`, 2) }
   // `--help` valía sólo como primer argumento: `check --help` corría `check` contra el directorio
   // actual en vez de explicarse.
-  if (cli.has('--help') || cli.has('-h')) return usage()
+  if (cli.has('--help')) return usage()
   const unknown = cli.unknown(command)
   if (unknown.length) {
     const accepts = FLAGS[command].length ? `Acepta: ${FLAGS[command].join(', ')}.` : 'No acepta banderas.'

package/engine/cli/planning.js

@@ -141,7 +141,7 @@ function context(dir, cli) {
   // Un filtro elige dónde buscar trabajo **nuevo**; no puede esconder el que ya tenés. Sin esto, pedir
   // otro hito mientras sostenías una tarea ofrecía una segunda que `claim` después se niega a dar: el
   // comando que dice qué hacer y el que lo autoriza contestaban distinto, y sólo se veía al reclamar.
-  const propio = state.claims.find((one) => one.runner === from && !state.done.set.has(one.slug))
+  const own = state.claims.find((one) => one.runner === from && !state.done.set.has(one.slug))
   let hitoOmitido = ''
   if (hito) {
     const existe = state.milestones.some((one) => one.slug === hito)
@@ -150,7 +150,7 @@ function context(dir, cli) {
       const hay = state.milestones.map((one) => one.slug).join(', ') || '(ninguno)'
       return fail(`el hito ${hito} no existe. Hay: ${hay}`, 2)
     }
-    if (propio) hitoOmitido = `${hito} no se aplica: ya tenés ${propio.slug} tomada`
+    if (own) hitoOmitido = `${hito} no se aplica: ya tenés ${own.slug} tomada`
     else state.milestones = state.milestones.filter((one) => one.slug === hito)
   }
   const gate = path.join(root, 'AWAITING_REVIEW.md')
@@ -222,13 +222,13 @@ function context(dir, cli) {
   // Es el comando que existe para decir qué toca ahora, contestando «nada» cuando lo que toca es eso.
   // Tu propio nombre en una tarea «ajena» es la señal de que sos vos desde otro runner, y sin decirlo se
   // lee como que alguien te ganó la tarea.
-  const dueño = (one) => (one.owner === report.owner ? `${one.owner} — vos, desde otro runner` : one.owner)
+  const ownerLabel = (one) => (one.owner === report.owner ? `${one.owner} — vos, desde otro runner` : one.owner)
   // Que el reclamo sea tuyo desde otro id ya se decía; que además haya un **plan escrito** bajo ese id, no.
   // Esa es la mitad que cuesta la sesión: los pasos ya hechos están en un archivo que nadie nombra, y el id
   // que lo recupera es justo el que esta sesión no supo deducir. Los dos datos están en el reclamo.
   const tomadas = () => {
     for (const one of report.taken) {
-      console.log(`TAKEN  ${one.slug} (${dueño(one)})`)
+      console.log(`TAKEN  ${one.slug} (${ownerLabel(one)})`)
       if (one.owner === report.owner && one.wip) {
         console.log(`PLAN   ${one.slug}: su plan está en wip/${one.wip} — retomalo con `
           + `\`export CAUCE_RUNNER=${one.runner}\``)

package/engine/cli/upgrade-report.js

@@ -26,7 +26,7 @@ function adviceFor(changed) {
   const advice = []
   if (ruleFiles.length) {
     advice.push(
-      'Las ruleFiles y decisiones bajo system/ son del toolkit. Para cambiar una, escribí la tuya al\n'
+      'Las reglas y decisiones bajo system/ son del toolkit. Para cambiar una, escribí la tuya al\n'
       + 'lado con el mismo ID: el proyecto manda y `check` lo reporta como override explícito.',
     )
   }
@@ -47,11 +47,11 @@ function adviceFor(changed) {
   // El consejo de arriba manda mudar lo propio a donde sí es del proyecto, y para estos cuatro no hay
   // adónde: no existe un PROTOCOL de la empresa que le gane al del toolkit como sí lo hay en `rules/`.
   // Sin decirlo, quien adoptó Cauce sobre su propio proceso lee un consejo que no puede seguir.
-  const SIN_CONTRAPARTE = ['planning/PROTOCOL.md', 'planning/METHODOLOGY.md', 'planning/FLOW.md', 'Makefile']
-  const propios = docs.filter((file) => SIN_CONTRAPARTE.includes(file))
-  if (propios.length) {
+  const NO_COUNTERPART = ['planning/PROTOCOL.md', 'planning/METHODOLOGY.md', 'planning/FLOW.md', 'Makefile']
+  const ownDocs = docs.filter((file) => NO_COUNTERPART.includes(file))
+  if (ownDocs.length) {
     advice.push(
-      `${propios.join(', ')} no tienen contraparte propia adónde mudarse: son del toolkit y no hay\n`
+      `${ownDocs.join(', ')} no tienen contraparte propia adónde mudarse: son del toolkit y no hay\n`
       + 'una versión del proyecto que le gane. Quedan congelados con tu versión y el resto se actualiza\n'
       + 'igual. Adoptar el del toolkit es trabajo propio —comparar los dos procesos y decidir—, no un flag.',
     )
@@ -74,18 +74,18 @@ function adviceFor(changed) {
 // entero en vez de recalcular nada: lo que se informa es exactamente lo que ocurrió.
 function reportUpgrade({
   root, from, to, system, retired, added, overrides, pinned, droppedBlocks,
-  descartados, conservados, pendientes,
+  discarded, keptFiles, pending,
 }) {
   console.log(`✓ Cauce ${from || '(previa)'} → ${to}`)
   // Descartar con --force es legítimo; hacerlo sin dejar rastro no. Queda en la salida del comando,
   // que es la evidencia que el protocolo pide para cualquier cambio. Y lo que se conservó no se vuelve
   // a enumerar acá: ya salió con su consejo antes de escribir nada, y repetirlo con el glifo del
   // descarte es lo que volvía ilegible el bloque.
-  for (const file of descartados) console.log(`− descartado tu cambio en ${file}`)
-  if (conservados.length) console.log(`= ${conservados.length} archivo(s) conservados por tu edición`)
+  for (const file of discarded) console.log(`− descartado tu cambio en ${file}`)
+  if (keptFiles.length) console.log(`= ${keptFiles.length} archivo(s) conservados por tu edición`)
   for (const relative of retired) console.log(`− retirado ${relative}: Cauce ya no lo distribuye`)
   // Sin glifo de acción porque no hubo ninguna: la ruta sigue ahí y el contenido también.
-  for (const { relative, files } of pendientes) {
+  for (const { relative, files } of pending) {
     console.log(`  ${relative}: ${files.length} archivo(s) que Cauce no entregó; la ruta se retiró y `
       + 'el contenido queda. Movelo adonde lo quieras y borrala, o repetí con --force.')
   }
@@ -103,7 +103,7 @@ function reportUpgrade({
   }
   // Sólo cuando es cierto, y ahora lo decide lo que pasó y no una condición: se dice justo cuando no
   // se descartó nada, que incluye la corrida que conservó veinte archivos.
-  if (!descartados.length) console.log('  planning, organization y todo lo propio quedaron intactos')
+  if (!discarded.length) console.log('  planning, organization y todo lo propio quedaron intactos')
   // No se borra: sin la dependencia declarada, quitarle `.ops/` la dejaría sin motor. Se avisa y
   // decide una persona.
   if (fs.existsSync(path.join(root, '.ops', 'engine'))) {

package/engine/cli/validate.js

@@ -137,19 +137,19 @@ function check(dir, cli) {
   // Lo que `upgrade` conserva por estar editado deja de recibir mejoras, y eso es una deuda que no
   // avisa sola: la instancia queda con medio molde viejo y todo se ve normal. Sale acá para que se vea
   // en cada corrida y no sólo el día que alguien actualiza.
-  const congelados = O.localChanges(path.resolve(root, '..'))
-  if (congelados.length) {
-    warnings.push(`${congelados.length} archivo(s) del molde congelados por edición local; `
+  const frozen = O.localChanges(path.resolve(root, '..'))
+  if (frozen.length) {
+    warnings.push(`${frozen.length} archivo(s) del molde congelados por edición local; `
       + '`upgrade` los conserva y no les trae mejoras')
   }
 
   // Y lo que `upgrade` no retiró porque no pudo demostrar que fuera suyo: queda ahí, sin colgar de
   // ningún mecanismo, hasta que alguien lo mueva o lo borre. Se cuenta por lo mismo que los congelados
   // — un resto que no se ve se vuelve permanente.
-  const restos = O.RETIRED_COMPARTIDO.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
-  if (restos.length) {
-    warnings.push(`${restos.length} ruta(s) retiradas siguen en disco con contenido tuyo `
-      + `(${restos.join(', ')}); Cauce ya no las distribuye ni las toca`)
+  const leftovers = O.RETIRED_SHARED.filter((relative) => fs.existsSync(path.join(root, '..', relative)))
+  if (leftovers.length) {
+    warnings.push(`${leftovers.length} ruta(s) retiradas siguen en disco con contenido tuyo `
+      + `(${leftovers.join(', ')}); Cauce ya no las distribuye ni las toca`)
   }
 
   const integration = I.validate(path.resolve(root, '..'))

package/engine/core/onboarding.js

@@ -119,7 +119,10 @@ function orphanCredentials(root) {
     path.join('planning', 'HUMAN_ACTIONS.md')]
     .map((file) => { try { return fs.readFileSync(path.join(root, file), 'utf8') } catch { return '' } })
     .join('\n')
-  if (!contracts) return []
+  // Acá había una salida temprana por `contracts` vacío que no corría nunca —pegar tres cadenas con
+  // `\n` deja `"\n\n"` aunque las tres fallen—, y no se la repone: una credencial que ningún documento
+  // nombra está huérfana igual, y apagar el aviso porque el documento que debía nombrarla está vacío lo
+  // calla justo en la instancia que más lo necesita.
   const orphans = []
   const cut = []
   for (const service of inventory(root)) {

package/engine/core/ownership.js

@@ -299,7 +299,7 @@ const RETIRED = [
 //
 // El manifiesto no las puede desempatar: `trackedPaths()` nunca las registró, así que para el toolkit
 // todo su contenido es igual de ajeno. Sin poder demostrar que lo entregó, no lo borra.
-const RETIRED_COMPARTIDO = ['automatization/runners', 'automatization/workflows']
+const RETIRED_SHARED = ['automatization/runners', 'automatization/workflows']
 
 function retiredWithLearning(root) {
   const found = []
@@ -407,7 +407,7 @@ module.exports = {
   deliveredFiles,
   effectiveRules,
   shippedFiles,
-  RETIRED_COMPARTIDO,
+  RETIRED_SHARED,
   TEMPLATE_OWN,
   TEMPLATE_PREFIXES,
   addedPaths,

package/engine/core/repos.js

@@ -55,10 +55,10 @@ function repoOf(opsRoot, service) {
 // el árbol principal: los worktrees se crean desde ahí y ahí se queda.
 function lastCommit(repo, branch) {
   if (!repo) return ''
-  const actual = git(repo, 'rev-parse', '--abbrev-ref', 'HEAD')
-  const tronco = actual.status === 0 ? actual.stdout.trim() : ''
-  const args = tronco && tronco !== branch
-    ? ['log', '-1', '--format=%cs', branch, '--not', tronco, '--']
+  const head = git(repo, 'rev-parse', '--abbrev-ref', 'HEAD')
+  const trunk = head.status === 0 ? head.stdout.trim() : ''
+  const args = trunk && trunk !== branch
+    ? ['log', '-1', '--format=%cs', branch, '--not', trunk, '--']
     : ['log', '-1', '--format=%cs', branch, '--']
   const shown = git(repo, ...args)
   return shown.status === 0 ? shown.stdout.trim() : ''
@@ -85,9 +85,15 @@ function unrecordedCommits(repo, since, recorded) {
   const log = git(repo, 'log', '--no-merges', '--date=short', '--format=%h %ad %s')
   if (log.status !== 0) return []
   const conocidos = new Set([...recorded].map((sha) => String(sha).slice(0, 7)))
+  // El hash y la fecha se leen partiendo por espacios y no por columna: `%h` mide 7 por default y git lo
+  // sube solo cuando el repositorio crece —en éste mide 8—, así que una posición fija leía un espacio en
+  // vez de la fecha y ningún commit pasaba el filtro. El aviso quedaba mudo sin decirlo, que es la peor
+  // forma de que una puerta falle (caso 169).
   return log.stdout.split('\n').map((line) => line.trim()).filter(Boolean)
-    .filter((line) => line.slice(8, 18) >= since)
-    .filter((line) => !conocidos.has(line.slice(0, 7)))
+    .map((line) => ({ line, sha: line.split(/\s+/)[0], date: line.split(/\s+/)[1] }))
+    .filter((one) => one.date >= since)
+    .filter((one) => !conocidos.has(one.sha.slice(0, 7)))
+    .map((one) => one.line)
 }
 
 // Cuánto del trabajo que entró a los repositorios quedó registrado, desde la última tarea cerrada. Avisa
@@ -102,18 +108,18 @@ function unrecordedCommits(repo, since, recorded) {
 // Y no dice cuántos *deberían* tener entrada, porque eso no se sabe desde acá: lo dice el desglose, y en
 // la instancia medida 120 de 173 eran `feat` o `fix` (caso 082).
 function coverageWarnings(opsRoot, done) {
-  const fechas = done.entries.map((entry) => entry.fecha).filter(Boolean).sort()
-  const desde = fechas[fechas.length - 1]
-  if (!desde) return []
+  const dates = done.entries.map((entry) => entry.fecha).filter(Boolean).sort()
+  const since = dates[dates.length - 1]
+  if (!since) return []
   const recorded = new Set()
   for (const entry of done.entries) {
     for (const sha of String(entry.commit || '').matchAll(/\b[0-9a-f]{7,40}\b/g)) recorded.add(sha[0])
   }
   const warnings = []
   for (const repo of reposFor(opsRoot, '.')) {
-    const sueltos = unrecordedCommits(repo, desde, recorded)
-    if (!sueltos.length) continue
-    warnings.push(`${path.basename(repo)}: ${sueltos.length} commit(s) desde ${desde} que ninguna `
+    const unrecorded = unrecordedCommits(repo, since, recorded)
+    if (!unrecorded.length) continue
+    warnings.push(`${path.basename(repo)}: ${unrecorded.length} commit(s) desde ${since} que ninguna `
       + 'entrada de DONE nombra, así que ese trabajo no está en planning/ (OPS-001)')
   }
   return warnings

package/engine/hooks/approval.js

@@ -96,9 +96,17 @@ function where(input) {
 function HOW(variable, lines, input, pasteable = lines) {
   const chat = CHAT.hold(input, lines)
   const stuck = lines.filter((one) => !pasteable.includes(one))
+  // El alcance del «dale» va con la oferta y no después. La rama del pegado ya decía el suyo —«valen para
+  // ese conjunto»— y la del chat no decía ninguno, siendo la que se ofrece primero. Las dos mitades que
+  // faltaban no son la misma: que **cubre lo frenado y nada más** explica por qué un archivo nuevo vuelve a
+  // frenar, que desde afuera se lee como que el guard se olvidó; y que **sigue valiendo en los mensajes
+  // siguientes** es la dirección permisiva, la que nadie nota porque lo que no ocurre es un bloqueo.
+  // `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. '
+      + '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. '
     : ''
   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

@@ -116,13 +116,13 @@ function mentions(text, item) {
       if (before && !/[\s'"`(/]/.test(before)) continue
       if (rest && !/^(?:[\s'"`),;:!?]|\.(?:\s|$)|$)/.test(rest)) continue
       const clause = lower.slice(0, at).split(CLAUSE).pop()
-      const frase = `${clause} ${rest.split(CLAUSE)[0]}`
+      const phrase = `${clause} ${rest.split(CLAUSE)[0]}`
       found.push({
         denied: NEGATION.test(clause),
-        asked: asks(frase),
+        asked: asks(phrase),
         // El alcance se lee de la misma frase que decide si la ruta fue pedida, y no del mensaje entero:
         // un «mientras dure la tarea t-014» que hable de otra cosa, en otra oración, no acota a ésta.
-        scope: (frase.match(SCOPE) || [])[1] || '',
+        scope: (phrase.match(SCOPE) || [])[1] || '',
       })
     }
   }
@@ -183,11 +183,19 @@ function record(input) {
     // alcance que ya no acota a nadie.
     const scopes = {}
     for (const one of granted) if (previous.scopes && previous.scopes[one]) scopes[one] = previous.scopes[one]
+    // Que haya alguien a quien preguntarle es de la sesión y no de este mensaje. Una notificación de una
+    // tarea de fondo entra por este mismo hook —es un `UserPromptSubmit` con el texto
+    // `<task-notification>…`, medido sobre los registros reales— así que se anota con `human: false`, y
+    // sin esto borraba del registro a la persona que está mirando el bloqueo en ese instante. Se arrastra
+    // igual que `granted` y por la misma razón: un aviso del runner en el medio no se lleva puesto lo que
+    // ya era cierto. Lo vuelve a decidir el mensaje humano siguiente (caso 166).
+    const flow = flowCommand(text)
+    const askable = human ? !flow : Boolean(previous && previous.askable)
     fs.mkdirSync(DIR, { recursive: true })
     // Sobre qué instancia se está hablando, que es lo que después deja filtrar lo concedido: por qué hace
     // falta, en `grantedIn`.
     fs.writeFileSync(recordPath(input.session_id), JSON.stringify(
-      { id: idOf(input), text, human, flow: flowCommand(text), root: opsRoot(input), approved, granted,
+      { id: idOf(input), text, human, askable, flow, root: opsRoot(input), approved, granted,
         scopes, pending: [] }))
   } catch { /* registrar es un extra: si falla, los guards siguen frenando lo que frenaban */ }
 }
@@ -203,6 +211,20 @@ function said(input) {
   return current && saved.id && current !== saved.id ? null : saved
 }
 
+// Hay una persona en esta sesión a quien preguntarle, que no es lo mismo que «este mensaje lo escribió
+// ella». `said` contesta la segunda porque de ella depende **conceder**; ésta contesta la primera, que es
+// todo lo que hace falta para decidir si el bloqueo ofrece contestar «dale» o manda a pegar líneas en un
+// archivo. Preguntar no es conceder, y fundir las dos preguntas le cobraba un copiar y pegar a la persona
+// justo cuando estaba mirando (caso 166).
+//
+// Un registro escrito antes de que `askable` existiera no lo trae y queda afuera: la sesión pierde la
+// salida por chat hasta el mensaje siguiente, que la vuelve a escribir. Es la dirección barata del error.
+function present(input) {
+  if (process.env.CI || input.agent_id || !input.session_id) return null
+  const saved = load(input.session_id)
+  return saved && saved.askable ? saved : null
+}
+
 // Con qué autorización pasa un ítem, o vacío si no pasa: lo pidió este mensaje, un «dale» aprobó lo que
 // había quedado frenado, o se lo concedieron antes en esta sesión. Qué cuenta como pedirlo depende de qué
 // se frena: un archivo se nombra, un push se ordena con su remoto y su rama.
@@ -303,7 +325,7 @@ function unauthorizedNow(input, items) {
 // Lo que quedó frenado, para que un «dale» en el mensaje siguiente apruebe exactamente eso y nada más.
 // Devuelve si hay una persona a quien preguntarle.
 function hold(input, items) {
-  const saved = said(input)
+  const saved = present(input)
   if (!saved) return false
   try {
     saved.pending = [...new Set([...saved.pending, ...items])]

package/engine/hooks/files.js

@@ -8,7 +8,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const { spawnSync } = require('node:child_process')
 const {
-  patchOf, filesOf, contentOf, cwdOf, block, configOf, findOpsRoot, opsRoot,
+  patchOf, filesOf, contentOf, cwdOf, block, configOf, opsRoot,
   writableRoots, outsideRoots, DECLARE_IT,
 } = require('./input')
 const AP = require('./approval')
@@ -242,10 +242,10 @@ function planFirst(input) {
   //
   // Se lista recién acá, después de las dos salidas de arriba: quien tiene su plan sale por la primera y
   // no paga esta lectura, que es la misma razón por la que `hasTasks` se pregunta donde se pregunta.
-  const ajenos = readWips(planning).filter((one) => one.complete + one.pending > 0)
+  const foreign = readWips(planning).filter((one) => one.complete + one.pending > 0)
   const estado = wip ? `WIP tiene la tarea ${wip.task} y ningún paso` : 'WIP está en IDLE'
-  const why = ajenos.length
-    ? `hay plan escrito, pero bajo otro id: ${ajenos.map((one) => `${one.runner} (${one.task})`).join(', ')}.\n`
+  const why = foreign.length
+    ? `hay plan escrito, pero bajo otro id: ${foreign.map((one) => `${one.runner} (${one.task})`).join(', ')}.\n`
       + 'Si ese plan es tuyo, volvé a su id con `export CAUCE_RUNNER=<id>` —`ops runners <planning>` los lista '
       + 'con su tarea y su avance— y repetí el cambio. Si vas a trabajar en paralelo, montá tu propio árbol '
       + 'con `ops worktree <planning> <tarea>`, que te devuelve el id hecho.\n'
@@ -258,7 +258,7 @@ function planFirst(input) {
     // Con un plan a la vista no se ofrece ninguna de las dos salidas: aprobar la ruta escribe «esto no es
     // trabajo de una tarea», que ahí es falso, y anunciar la variable ofrece el permiso más ancho cuando
     // la acción correcta es angosta y concreta —el mismo criterio con que `HOW` decide no nombrarla—.
-    const how = ajenos.length
+    const how = foreign.length
       ? AP.HOW(null, [], input, [])
       : AP.HOW('OPS_PLAN_FIRST_OVERRIDE', [raw], input)
     block(`${raw} cambia el producto sin plan. ${why}${how}`)
@@ -359,7 +359,7 @@ function migrations(input) {
 // empresa corre un motor que no coincide con la versión que declara —la clase de diferencia que
 // aparece como un bug irreproducible—. En modo `toolkit` no aplica: ahí el motor es el producto.
 function engineWrites(input) {
-  const root = findOpsRoot(process.env.OPS_ROOT || process.env.CLAUDE_PROJECT_DIR || cwdOf(input))
+  const root = opsRoot(input)
   if (!root) return
   const config = configOf(root)
   if (config.mode === 'toolkit') return