@ingeniomaps/cauce 0.94.0 → 0.96.0

package/engine/cli/args.js

@@ -41,6 +41,12 @@ const FLAGS = {
   flow: ['--json'],
 }
 
+// Qué banderas acepta un comando, y `[]` si el comando no existe. `FLAGS[nombre]` a secas resuelve
+// contra `Object.prototype`, así que `constructor` contestaba una función —que es verdadera, y el CLI
+// daba el comando por bueno— y `toString` contestaba un método sin `.includes`, que reventaba acá
+// mismo. No es un nombre exótico: es lo que sale de pasarle a `ops` una variable que vino vacía.
+const accepted = (command) => (Object.hasOwn(FLAGS, command) ? FLAGS[command] : [])
+
 // La línea de comandos, leída una sola vez. Antes cada función buscaba sus banderas en
 // `process.argv`, veinticinco veces y a cualquier profundidad: `evaluationBench` sacaba `--force` de
 // ahí en vez de recibirlo, así que su firma no decía de qué dependía y probar un comando exigía
@@ -51,6 +57,10 @@ function parse(argv) {
   const positional = []
   for (let index = 0; index < argv.length; index += 1) {
     const value = argv[index]
+    // `-h` es la única bandera corta que el CLI anuncia, y como no empieza con `--` caía de posicional:
+    // `ops check -h` tomaba `-h` por la raíz del planning y contestaba que ahí no había ninguno. Se
+    // normaliza a `--help` para que adentro haya una sola grafía y nadie tenga que preguntar por las dos.
+    if (value === '-h') { flags.add('--help'); continue }
     if (!value.startsWith('--')) { positional.push(value); continue }
     flags.add(value)
     if (VALUED_FLAGS.has(value)) { values[value] = argv[index + 1] || ''; index += 1 }
@@ -60,8 +70,12 @@ function parse(argv) {
     has: (flag) => flags.has(flag),
     value: (flag, fallback = '') => values[flag] || fallback,
     // Lo que el comando no declara en `FLAGS`. Se calcula sobre `flags` y no sobre argv crudo para
-    // que el valor de una bandera con valor no se confunda con una bandera suelta.
-    unknown: (command) => [...flags].filter((flag) => !FLAGS[command].includes(flag)),
+    // que el valor de una bandera con valor no se confunda con una bandera suelta. `--help` la acepta
+    // cualquier comando y por eso no la declara ninguno: sin esta excepción, pedir ayuda sería una
+    // bandera desconocida.
+    unknown: (command) => [...flags]
+      .filter((flag) => flag !== '--help')
+      .filter((flag) => !accepted(command).includes(flag)),
   }
 }
 

package/engine/cli/bench.js

@@ -18,7 +18,7 @@ const CL = require('../planning/claims')
 const P = require('../planning/parser')
 const IN = require('./instance')
 const O = require('../core/ownership')
-const { fail, opsRoot, TODAY } = require('./io')
+const { fail, opsRoot, TODAY, USAGE } = require('./io')
 
 // Qué decir cuando el banco sobrevivió a su propio borrado, que es lo único que va a permitir
 // establecer la causa. Devuelve el mensaje en vez de escribirlo donde ocurre, y eso es lo que lo hace
@@ -73,9 +73,9 @@ function benchSurvived(dir, since) {
 // la rama se ejerce en milisegundos y sobre un temporal que la prueba acaba de crear.
 function clearBench(dir, scratch, remove = fs.rmSync) {
   const target = path.resolve(dir)
-  const banco = path.resolve(scratch)
-  if (!target.startsWith(banco + path.sep)) {
-    return `no se borra ${target}: no cuelga de ${banco}, así que no es un banco de evaluación.`
+  const benchRoot = path.resolve(scratch)
+  if (!target.startsWith(benchRoot + path.sep)) {
+    return `no se borra ${target}: no cuelga de ${benchRoot}, así que no es un banco de evaluación.`
   }
   // El instante de arranque, para poder fechar lo que sobreviva: es lo único que separa un archivo que el
   // borrado no tocó de uno que alguien reescribió mientras borrábamos.
@@ -106,7 +106,7 @@ function makeBench(root, dir, force, name) {
   const dirty = spawnSync('git', ['-C', dir, 'status', '--porcelain'], { encoding: 'utf8' })
   if ((dirty.stdout || '').trim() && !force) {
     fail(`${dir} tiene trabajo sin recoger. Guardá lo que esa corrida dejó antes de rehacerlo, `
-      + 'o usá --force si ya lo tenés.', 2)
+      + 'o usá --force si ya lo tenés.', USAGE)
   }
   // Rodear un borrado a medias deja la corrida siguiendo sobre un banco que no es nuevo, y lo que falla
   // después no dice nada del borrado: el test que lo destapó reportaba `true !== false` sobre un archivo
@@ -116,7 +116,7 @@ function makeBench(root, dir, force, name) {
   // **Y de acá para abajo el directorio no existe.** Eso es lo que sostiene que el andamiaje y el enlace
   // se escriban sin defensas: hasta el 073, los dos llevaban una por si algo sobrevivía al borrado.
   const problema = clearBench(dir, path.join(root, '.cauce-eval'))
-  if (problema) fail(problema, 2)
+  if (problema) fail(problema, USAGE)
   // Sin `force`, y eso es lo que hay que poder decir: sólo servía si algún archivo sobrevivía al borrado,
   // y la comprobación de arriba garantiza que no queda ninguno. Lo llevaba porque el mismo test falló tres
   // veces en un día con «El destino contiene …/AGENTS.md», y eso era el escritor de fondo que apagó el 073.
@@ -183,7 +183,7 @@ function seal(dir, git, mensaje) {
 function evaluationBench(root, agent, caso, force, kind) {
   const safe = (value) => {
     if (!/^[a-z0-9_][a-z0-9._-]*$/i.test(value) || value.includes('..')) {
-      fail(`nombre inválido para el banco: ${value}`, 2)
+      fail(`nombre inválido para el banco: ${value}`, USAGE)
     }
     return value
   }
@@ -273,7 +273,7 @@ function populate(dir, scenario, git) {
 // `clearBench` ya se niega a borrar fuera de ahí— y se distingue por el escenario, que es lo que lo puebla.
 function measurementBench(root, scenario, force) {
   if (!SCENARIOS.includes(scenario)) {
-    fail(`escenario desconocido: ${scenario || '(ninguno)'}. Hay ${SCENARIOS.join(', ')}.`, 2)
+    fail(`escenario desconocido: ${scenario || '(ninguno)'}. Hay ${SCENARIOS.join(', ')}.`, USAGE)
   }
   const dir = path.join(root, '.cauce-eval', '_medicion', scenario)
   const { env, git } = makeBench(root, dir, force, `Banco de medición (${scenario})`)
@@ -293,7 +293,7 @@ function bench(scenario, cli) {
   const root = opsRoot()
   if (O.mode(root) !== 'toolkit') {
     fail('ops bench es del toolkit: arma un banco desechable para medir a Cauce. En una instancia, lo '
-      + 'que se mide es tu propio proyecto — corré el comando que quieras medir sobre tu planning/.', 2)
+      + 'que se mide es tu propio proyecto — corré el comando que quieras medir sobre tu planning/.', USAGE)
   }
   const dir = measurementBench(root, scenario, cli.has('--force'))
   console.log(path.relative(root, dir))

package/engine/cli/catalog.js

@@ -13,14 +13,14 @@ const O = require('../core/ownership')
 // El banco desechable y su borrado comprobado. Se reexportan abajo porque su contrato lo fija la suite
 // del banco, que llega por acá desde antes de que el módulo existiera.
 const B = require('./bench')
-const { fail, opsRoot } = require('./io')
+const { fail, opsRoot, TODAY, USAGE, REFUSED } = require('./io')
 
 function agentsFork(slug, dir) {
   const root = opsRoot(dir)
-  if (!slug) fail('Falta el cargo: ops agents fork <cargo> [ops-root]', 2)
+  if (!slug) fail('Falta el cargo: ops agents fork <cargo> [ops-root]', USAGE)
   let result
-  const date = new Date().toISOString().slice(0, 10)
-  try { result = require('../agents/fork').fork(root, slug, date) } catch (error) { fail(error.message, 2) }
+  const date = TODAY()
+  try { result = require('../agents/fork').fork(root, slug, date) } catch (error) { fail(error.message, USAGE) }
   console.log(`+ ${path.relative(root, result.dir)} (${result.files.length} archivo(s))`)
   if (result.skipped.length) {
     console.log(`  quedan en el catálogo: ${result.skipped.length} artefacto(s) que ganó su versión`)
@@ -31,15 +31,28 @@ function agentsFork(slug, dir) {
 
 // Lista los cargos visibles resolviendo la precedencia; evita que cada consumidor —CI incluido—
 // reimplemente el recorrido del catálogo.
+// Una lista vacía y un paquete que no se resolvió se ven igual, y las acciones son opuestas: en uno no hay
+// nada que hacer, en el otro falta una instalación. Se avisa sólo cuando la lista sale vacía, que es cuando
+// la ambigüedad existe — con resultados a la vista no hay nada que aclarar.
+//
+// Va por `stderr` y no por el código de salida: el `--json` lo consume el cron del ciclo de aprendizaje, y
+// romperle el contrato para arreglar un mensaje sería cambiar lo que no está mal (caso 173).
+function warnUnresolved(root, name, found) {
+  if (found || O.packageDir(root, name)) return
+  console.error(`⚠ ${name}/ no se pudo resolver desde ${root}: el paquete @ingeniomaps/cauce no está ahí `
+    + `ni en la raíz que declara ops.config.json, así que una lista vacía acá no dice que no haya ${name}.`)
+}
+
 function agents(action, dir, extra, cli) {
   if (action === 'fork') return agentsFork(dir, extra)
-  if (action !== 'list') fail(`Acción de agents desconocida: ${action || '(vacía)'}`, 2)
+  if (action !== 'list') fail(`Acción de agents desconocida: ${action || '(vacía)'}`, USAGE)
   const root = opsRoot(dir)
   // Una empresa mantiene sus cargos, no los nuestros: `learn` sobre uno del catálogo se niega, así que
   // recorrer el catálogo entero para encontrar el suyo es ruido. `--own` hace ejecutable ese recorrido.
   const own = cli.has('--own')
   const system = cli.has('--system')
   const roles = AG.list(root).filter((role) => (own ? !role.system : true) && (system ? role.system : true))
+  warnUnresolved(root, 'agents', roles.length)
   if (cli.has('--json')) {
     // `path` viene resuelto: quien consuma esto no debería reconstruir dónde ganó la precedencia.
     return console.log(JSON.stringify(roles.map((role) => ({
@@ -104,7 +117,7 @@ function learn(agent, cli) {
     // 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`
-        + `  Abrí la propuesta con "ops learn ${agent} --flow --proposal".`, 2)
+        + `  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
     // pasa: la propuesta se llama por el mes en que se abre y arrastra lo que todavía no entró.
@@ -133,7 +146,7 @@ function learn(agent, cli) {
     if (LF.blankProposal(result.file)) {
       console.log('  sin cambio decidido: falta correr agent-propose antes de que esto se pueda firmar')
     }
-  } catch (error) { fail(error.message, 2) }
+  } catch (error) { fail(error.message, USAGE) }
 }
 
 function evaluate(agent, caso, cli) {
@@ -149,7 +162,7 @@ function evaluate(agent, caso, cli) {
       // forkeaba, repetía el comando y recibía el mismo mensaje diciéndole que forkeara—.
       fail('--bench es del toolkit. En una instancia, el cargo trabaja sobre tu planning/: corré '
         + `"ops evaluate ${agent}" sin la bandera, que valida sus controles, casos y propuestas `
-        + 'contra este proyecto.', 2)
+        + 'contra este proyecto.', USAGE)
     }
     // El caso es el posicional que sigue al cargo: `evaluate <cargo> --bench <caso>`. Sin él se arma
     // un banco suelto, para mirarlo a mano; una corrida real pide uno por caso.
@@ -179,7 +192,7 @@ function evaluate(agent, caso, cli) {
     // Dónde escribir el registro de esta corrida. Lo pregunta el recorrido en vez de componer el
     // nombre, que es lo que hacía que la segunda corrida de un día borrara a la primera.
     if (cli.has('--record')) {
-      const day = cli.value('--record') || new Date().toISOString().slice(0, 10)
+      const day = cli.value('--record') || TODAY()
       return console.log(path.relative(root,
         path.join(EV.resultsDir(root, agent, kind), EV.nextResult(root, agent, day, kind))))
     }
@@ -190,7 +203,7 @@ function evaluate(agent, caso, cli) {
     const errors = [...result.errors, ...runs.errors]
     for (const warning of [...result.warnings, ...runs.warnings]) console.warn(`⚠ ${warning}`)
     for (const error of errors) console.error(`✗ ${error}`)
-    if (errors.length) fail(`\n${errors.length} error(es)`, 1)
+    if (errors.length) fail(`\n${errors.length} error(es)`, 1, REFUSED)
     // Cuándo se midió es un rango cuando el veredicto vigente lo aportó más de una corrida. Por qué se
     // compone en vez de leerse la última, en `composed`.
     const measuredAt = runs.state && runs.state.oldest !== runs.state.newest
@@ -208,13 +221,19 @@ function evaluate(agent, caso, cli) {
         `${result.pending ? ` (${result.pending} sin aplicar)` : ''}, ` +
         'controles estructurales válidos',
     )
-  } catch (error) { fail(error.message, 2) }
+  } catch (error) { fail(error.message, USAGE) }
 }
 
-function flow(action, slug, cli) {
+// La raíz la toma como posicional, igual que el resto de los comandos que leen una instancia: `list` no
+// lleva recorrido, así que la suya es el primer posicional, y `check`/`show` la llevan después del
+// recorrido —la misma forma que `agents fork <cargo> [ops-root]`—. Antes se descartaba y todo resolvía por
+// `opsRoot()`, así que `ops flow list <raíz>` contestaba sobre el directorio actual y la respuesta se leía
+// igual de bien viniendo de otra instancia (caso 172).
+function flow(action, slug, dir, cli) {
+  const root = opsRoot(action === 'list' ? slug : dir)
   if (action === 'list') {
-    const root = opsRoot()
     const slugs = T.list(root)
+    warnUnresolved(root, 'flows', slugs.length)
     // La misma forma que `agents list --json`, porque la consume el mismo cron. `cadence` es fija:
     // un recorrido no tiene profesión que cambie afuera, así que su calendario no se deriva de
     // fuentes —no tiene—; lo que decide si le toca es `pending`, las corridas que dejó sin consolidar.
@@ -238,11 +257,11 @@ function flow(action, slug, cli) {
     for (const name of slugs) console.log(name)
     return
   }
-  if (!['check', 'show'].includes(action)) fail(`Acción de flow desconocida: ${action || '(vacía)'}`, 2)
+  if (!['check', 'show'].includes(action)) fail(`Acción de flow desconocida: ${action || '(vacía)'}`, USAGE)
   try {
-    const result = T.validate(opsRoot(), slug)
+    const result = T.validate(root, slug)
     for (const error of result.errors) console.error(`✗ ${error}`)
-    if (result.errors.length) fail(`${slug}: ${result.errors.length} error(es)`, 1)
+    if (result.errors.length) fail(`${slug}: ${result.errors.length} error(es)`, 1, REFUSED)
     if (action === 'show') {
       // El manifiesto entero, para que un workflow ejecute las etapas sin que un modelo lo parsee.
       if (cli.has('--json')) return console.log(JSON.stringify(result.manifest))
@@ -254,7 +273,7 @@ function flow(action, slug, cli) {
     } else {
       console.log(`✓ ${slug}: ${result.stages} etapa(s), ${result.agents} agente(s), contrato válido`)
     }
-  } catch (error) { fail(error.message, 2) }
+  } catch (error) { fail(error.message, USAGE) }
 }
 
 module.exports = {

package/engine/cli/claims.js

@@ -9,27 +9,25 @@ 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, USAGE, REFUSED } = require('./io')
 
 function claim(dir, slug, cli) {
   const root = planningRoot(dir)
-  if (!slug) return fail('Falta el slug. `ops claim <planning-dir> <tarea>`', 2)
+  if (!slug) return fail('Falta el slug. `ops claim <planning-dir> <tarea>`', USAGE)
   const state = ST.snapshot(root)
   const task = state.milestones.flatMap((milestone) => milestone.tasks).find((one) => one.slug === slug)
-  if (!task) return fail(`${slug} no está en BACKLOG: sólo se toma trabajo ya promovido.`, 2)
+  if (!task) return fail(`${slug} no está en BACKLOG: sólo se toma trabajo ya promovido.`, USAGE)
 
   // 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.`, REFUSED)
 
   const me = CL.owner(root)
   const from = CL.runner()
   if (!me) {
     return fail('No sé quién sos. Configurá `git config user.email` o exportá CAUCE_OWNER: '
-      + 'un reclamo anónimo no dice a quién preguntarle.', 2)
+      + 'un reclamo anónimo no dice a quién preguntarle.', USAGE)
   }
   // Un runner lleva una tarea a la vez (BR-OPS-001), y exigirlo acá hace ruidosa la única forma en que
   // este contrato falla en silencio: dos agentes de la misma máquina compartiendo id porque nadie puso
@@ -40,12 +38,12 @@ function claim(dir, slug, cli) {
     .find((one) => one.runner === from && one.slug !== slug && !state.done.set.has(one.slug))
   if (ocupado) {
     return fail(`este runner ya tiene ${ocupado.slug}. Cerrala o soltala primero; y si sos otro agente `
-      + 'en la misma máquina, exportá CAUCE_RUNNER con un valor propio.')
+      + 'en la misma máquina, exportá CAUCE_RUNNER con un valor propio.', REFUSED)
   }
 
   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,26 +52,26 @@ 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.`, REFUSED)
+    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.')
+        + 'lista lo que hay abierto.', REFUSED)
     }
-    return fail(`${slug} la tomó ${dueño.owner} el ${dueño.started}. Si se abandonó, borrá `
-      + `${CL.DIR}/${slug}.md a mano: soltar lo de otro es una decisión, no un comando.`)
+    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.`, REFUSED)
   }
   console.log(`✓ ${slug} tomada por ${me}`)
   if (!cli.has('--json')) {
@@ -89,12 +87,12 @@ function claim(dir, slug, cli) {
 
 function release(dir, slug) {
   const root = planningRoot(dir)
-  if (!slug) return fail('Falta el slug. `ops release <planning-dir> <tarea>`', 2)
+  if (!slug) return fail('Falta el slug. `ops release <planning-dir> <tarea>`', USAGE)
   const from = CL.runner()
   const taken = CL.read(root).find((one) => one.slug === slug)
-  if (!taken) return fail(`${slug} no está tomada por nadie.`, 2)
+  if (!taken) return fail(`${slug} no está tomada por nadie.`, USAGE)
   if (taken.runner !== from) {
-    return fail(`${slug} es de ${taken.owner}. Si se abandonó, borrá ${taken.at} a mano.`)
+    return fail(`${slug} es de ${taken.owner}. Si se abandonó, borrá ${taken.at} a mano.`, REFUSED)
   }
   fs.rmSync(CL.file(root, slug))
   console.log(`✓ ${slug} soltada; volvió a la cola`)
@@ -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

@@ -15,7 +15,7 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const P = require('../planning/parser')
-const { fail, opsRoot } = require('./io')
+const { fail, opsRoot, USAGE } = require('./io')
 
 // Los cuatro que componen el contrato, con la ruta relativa a la raíz de la instancia. El orden es el que
 // usa el mensaje de error: se nombra el primero que falte y no los cuatro, porque arreglar uno suele
@@ -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')
@@ -171,14 +188,15 @@ function contract(dir, cli) {
   // se pierde no se ve en la salida, se ve tres fases después en lo que un subagente creyó que podía tocar.
   if (missing) {
     return fail(`${root} no tiene ${missing}, así que no hay contrato que derivar. Es la raíz que escribió `
-      + '`automation install`: comprobá que exista y, si moviste el proyecto de carpeta, reinstalá el adaptador.', 2)
+      + '`automation install`: comprobá que exista y, si moviste el proyecto de carpeta, reinstalá el adaptador.',
+    USAGE)
   }
 
   let config
   try {
     config = JSON.parse(fs.readFileSync(path.join(root, 'ops.config.json'), 'utf8'))
   } catch (error) {
-    return fail(`ops.config.json no se pudo leer como JSON: ${error.message}`, 2)
+    return fail(`ops.config.json no se pudo leer como JSON: ${error.message}`, USAGE)
   }
 
   const sections = {}
@@ -188,7 +206,7 @@ function contract(dir, cli) {
     // que poder abrir el archivo y ver qué encabezado falta, y el arreglo es restaurarlo con `upgrade`.
     if (!found.trim()) {
       return fail(`${file} no tiene la sección ${name}, y de ahí sale el contrato que reciben los agentes. `
-        + 'Ese archivo lo reemplaza `ops upgrade` entero: corrélo para restaurarlo.', 2)
+        + 'Ese archivo lo reemplaza `ops upgrade` entero: corrélo para restaurarlo.', USAGE)
     }
     sections[file] = found
   }

package/engine/cli/dependency.js

@@ -7,7 +7,7 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const F = require('../core/files')
-const { fail } = require('./io')
+const { fail, USAGE } = require('./io')
 
 // Declara el motor como dependencia exacta: el lockfile decide qué versión corre, no una copia.
 // Conserva el manifiesto existente porque el repo anfitrión puede tener el suyo.
@@ -15,7 +15,7 @@ function declareEngine(manifest, version) {
   let pkg = { name: path.basename(path.dirname(manifest)), private: true, version: '0.0.0' }
   if (fs.existsSync(manifest)) {
     try { pkg = JSON.parse(fs.readFileSync(manifest, 'utf8')) } catch (error) {
-      fail(`package.json inválido en ${manifest}: ${error.message}`)
+      fail(`package.json inválido en ${manifest}: ${error.message}`, USAGE)
     }
   }
   pkg.devDependencies = { ...pkg.devDependencies, '@ingeniomaps/cauce': version }