@ingeniomaps/cauce 0.43.0 → 0.46.0

package/automatization/workflows/autobuild.js

@@ -2,18 +2,31 @@
 // Descubre proyecto, servicios y límites desde ops.config.json; no codifica rutas ni proveedores.
 export const meta = {
   name: 'autobuild',
-  description: 'Triage → Pick → Cast → Ready → Plan → Build → Review → Verify → QA → Commit → Done',
+  description: 'Triage → Pick → Classify → Plan → WIP → Build → Review → Verify → QA → Commit → Done',
   whenToUse: 'Ejecutar un hito aprobado con recuperación por WIP y checkpoint humano entre hitos.',
+  // Escritas una por una y no derivadas de una lista: el runtime exige que `meta` sea un literal puro
+  // —sin llamadas, variables ni interpolación— y con un `.map` acá rechazaba el archivo entero antes de
+  // la primera fase. Escribirlas también les da un detalle propio, que es lo que se lee al autorizar.
   phases: [
-    'Triage', 'Pick', 'Cast', 'Ready', 'Decompose', 'Plan', 'Critique', 'Build', 'Review',
-    'Verify', 'QA', 'Commit', 'Done', 'Closing',
-  ].map((title) => ({ title, detail: `Fase ${title} del protocolo agnóstico` })),
+    { title: 'Triage', detail: 'Contrato del proyecto y estado de planning' },
+    { title: 'Pick', detail: 'La próxima tarea, o la épica que falta expandir' },
+    { title: 'Classify', detail: 'Carril y reparto de la tarea que no los declara' },
+    { title: 'Ready', detail: 'Aceptación concreta y sin decisiones pendientes' },
+    { title: 'Decompose', detail: 'Partir la tarea que no entra en el tope de horas' },
+    { title: 'Plan', detail: 'El cambio más chico que satisface la aceptación' },
+    { title: 'Critique', detail: 'El plan atacado antes de escribir código' },
+    { title: 'WIP', detail: 'El plan aprobado persistido antes del primer cambio' },
+    { title: 'Build', detail: 'Implementación con la prueba en rojo primero' },
+    { title: 'Review', detail: 'El diff real revisado por el dueño de cada dominio' },
+    { title: 'Verify', detail: 'Los gates del servicio y la aceptación que ninguna prueba codifica' },
+    { title: 'QA', detail: 'El comportamiento ejercitado como lo ve quien lo usa' },
+    { title: 'Commit', detail: 'Conventional Commits, uno por naturaleza del diff, sin push' },
+    { title: 'Done', detail: 'Cierre atómico en DONE con el WIP en IDLE' },
+    { title: 'Closing', detail: 'Check de planning y checkpoint humano del hito' },
+  ],
 }
 
-// El prefijo lo completa `automation install`. No puede venir del entorno: el runtime de workflows no
-// expone `process`, así que leerlo de ahí reventaba el archivo entero en su primera línea. Viaja
-// escrito, relativo a la carpeta donde se abre la herramienta, que es el cwd de los agentes.
-const ROOT = '{{OPS_DIR}}'.replace(/\/+$/, '') || '.'
+{{INCLUDE:shared/workflow-root.js}}
 const CONFIG = `${ROOT}/ops.config.json`
 const P = `${ROOT}/planning`
 const BACKLOG = `${P}/BACKLOG.md`
@@ -25,12 +38,20 @@ const ROADMAP = `${P}/roadmap`
 
 // Estado de planning tal como lo emite `ops context --json`; ningún modelo parsea BACKLOG ni WIP.
 const CONTEXT = {
-  type: 'object', additionalProperties: false, required: ['blocked', 'hasTask', 'wipActive', 'queued'],
+  type: 'object', additionalProperties: false,
+  required: ['blocked', 'hasTask', 'wipActive', 'queued', 'cast'],
   properties: {
     blocked: { type: 'string' }, hasTask: { type: 'boolean' }, wipActive: { type: 'boolean' },
     queued: { type: 'integer' }, slug: { type: 'string' }, hito: { type: 'string' },
     service: { type: 'string' }, acceptance: { type: 'string' }, epic: { type: 'string' },
-    lane: { type: 'string', enum: ['', 'directo', 'lite', 'full'] },
+    lane: { type: 'string', enum: ['', 'express', 'directo', 'lite', 'full'] },
+    // Quién entrega y quiénes miran, decidido al clasificar la tarea y escrito en su línea. Viene
+    // siempre, aunque venga vacío: preguntar si el campo existe antes de leerlo es la clase de borde
+    // que se olvida en una rama y revienta en la otra.
+    cast: {
+      type: 'object', additionalProperties: false, required: ['build', 'review'],
+      properties: { build: { type: 'string' }, review: { type: 'array', items: { type: 'string' } } },
+    },
     blockedTasks: { type: 'array', items: { type: 'string' } },
   },
 }
@@ -62,16 +83,45 @@ const PLAN = {
     testStrategy: { type: 'string' },
   },
 }
+// Un veredicto sin manifiesto no se puede contrastar: `consulted` enumera lo que quien revisó abrió de
+// verdad, y es lo único que separa al que miró del que aprobó de memoria. No prueba que lo haya leído bien
+// —para eso habría que releerlo—, y esa asimetría es la que lo deja barato (R14).
+// Tres estados porque hay tres cosas distintas que decir, y con un booleano dos se pisan: «no puedo
+// aprobar esto» y «apruebo con algo que hay que corregir antes de entregar» caían las dos en el mismo
+// `false`, así que la primera gastaba igual una vuelta de corrección sobre algo que la corrección no
+// arregla. Y `blocking` separa lo que impide entregar de la mejora opinable, que hasta ahora mandaba a
+// tocar código con la misma fuerza que un defecto.
 const DECISION = {
-  type: 'object', additionalProperties: false, required: ['approved', 'concerns'],
-  properties: { approved: { type: 'boolean' }, concerns: { type: 'array', items: { type: 'string' } } },
+  type: 'object', additionalProperties: false, required: ['verdict', 'concerns', 'consulted'],
+  properties: {
+    verdict: { type: 'string', enum: ['aprobado', 'con-condiciones', 'bloqueado'] },
+    concerns: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['detail', 'blocking'],
+      properties: { detail: { type: 'string' }, blocking: { type: 'boolean' } },
+    } },
+    consulted: { type: 'array', items: { type: 'string' } },
+  },
 }
+// Un exit code dice que el test corrió, no que pruebe lo que la tarea prometió: un test que asercia de
+// menos —o que ni existe— sale verde igual, y el guard de verify tampoco lo ve porque también mira exit
+// codes. Por eso `uncovered` se contrasta contra la aceptación leyendo el fuente, no la salida (R9).
 const VERIFY = {
-  type: 'object', additionalProperties: false, required: ['passed', 'commands', 'details'],
+  type: 'object', additionalProperties: false, required: ['passed', 'commands', 'details', 'uncovered'],
   properties: {
     passed: { type: 'boolean' }, details: { type: 'string' },
+    // Dos causas que se leen igual en el resultado y piden cosas opuestas: a una le falta trabajo que
+    // el propio recorrido puede hacer, a la otra le falta una decisión que no es suya. Sin separarlas,
+    // la corrida frena por las dos y una persona termina resolviendo lo que se resolvía solo.
+    uncovered: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['criterion', 'cause'],
+      properties: {
+        criterion: { type: 'string' },
+        cause: { type: 'string', enum: ['missing-test', 'ambiguous'] },
+      },
+    } },
     commands: { type: 'array', items: { type: 'object', required: ['cmd', 'exitCode'], properties: {
       cmd: { type: 'string' }, exitCode: { type: 'integer' }, note: { type: 'string' },
+      ranTests: { type: 'boolean' },
     } } },
     regressions: { type: 'array', items: { type: 'string' } },
     preExisting: { type: 'array', items: { type: 'string' } },
@@ -84,6 +134,33 @@ const QA = {
     bugs: { type: 'array', items: { type: 'string' } },
   },
 }
+// RED/GREEN sin registro es una intención: después nadie distingue el test que se vio fallar del que se
+// escribió cuando el código ya andaba, y ese segundo no prueba su aserción, sólo que corre. Por eso
+// `redFirst` trae el fallo literal de la corrida roja y no la afirmación de que la hubo (R14).
+const BUILD = {
+  type: 'object', additionalProperties: false,
+  required: ['completed', 'summary', 'redFirst', 'discovered', 'closedTask'],
+  properties: {
+    completed: { type: 'boolean' }, summary: { type: 'string' }, closedTask: { type: 'boolean' },
+    redFirst: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['test', 'failure'],
+      properties: { test: { type: 'string' }, failure: { type: 'string' } },
+    } },
+    blockers: { type: 'array', items: { type: 'string' } },
+    // Estricto en el cómo, flexible en el qué: lo que aparece y el plan no previó tiene dos destinos y
+    // ninguno es el silencio. Un caso que esta tarea puede fijar entra con la prueba que lo fija —por eso
+    // su `test` tiene que estar en `redFirst`—; una decisión que no le toca queda registrada con quién
+    // puede tomarla. Implementarlo sin prueba lo vuelve invisible y descartarlo lo pierde: en los dos
+    // casos el próximo que lo encuentre empieza de cero.
+    discovered: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['kind', 'detail'],
+      properties: {
+        kind: { type: 'string', enum: ['edge', 'open'] },
+        detail: { type: 'string' }, test: { type: 'string' },
+      },
+    } },
+  },
+}
 const COMMIT = {
   type: 'object', additionalProperties: false, required: ['committed'],
   properties: {
@@ -102,17 +179,34 @@ const OWNERS = {
   commit: 'release-manager',
 }
 
-const CAST_RULES = 'Elegís quién trabaja, no qué se hace. No inventes slugs: usá sólo los que ' +
-  'devuelve el CLI. Un cargo se suma por riesgo, plataforma o alcance, nunca por rutina.'
+// Clasificar decide dos cosas de una: cuántas perspectivas merece la tarea —el lane— y cuáles —el
+// cast—. El criterio va escrito porque sin él la clasificación es intuición, y la intuición se
+// infla hacia arriba: toda tarea termina pareciendo `full`, que es el carril que no hay que
+// justificar. Lo que decide es la superficie del cambio, no su tamaño en líneas: un `if` en el
+// chequeo de permisos es `full`, y un componente entero de presentación puede ser `directo`.
+const CLASSIFY_RULES = 'Clasificás quién trabaja y cuánta ceremonia merece la tarea; no decidís qué ' +
+  'se hace ni lo hacés. Lane: `express` si la aceptación nombra un valor literal y el resultado no ' +
+  'lo mira nadie —un typo, un umbral interno, un renombre—; `directo` si es igual de mecánico pero ' +
+  'cambia una superficie que alguien ve; `lite` si es comportamiento nuevo ' +
+  'dentro de un servicio con superficie conocida; `full` si cruza contratos entre servicios, datos, ' +
+  'autenticación o permisos, o si la aceptación tiene un borde sin decidir. Cast: quien implementa ' +
+  'según la plataforma del servicio, y los revisores que la superficie realmente justifica ' +
+  '—seguridad si toca autenticación, permisos, criptografía o datos sensibles; privacidad si toca ' +
+  'datos personales; sre si toca disponibilidad, límites o despliegue; ux si cambia una superficie ' +
+  'que usa una persona; el de datos o modelos si los toca—. Sumar un cargo que no aporta es ruido ' +
+  'que diluye la revisión. No inventes slugs: usá sólo los que devuelve el CLI.'
 
-const CAST = {
-  type: 'object', additionalProperties: false, required: ['build'],
+const CLASSIFICATION = {
+  type: 'object', additionalProperties: false, required: ['classified'],
   properties: {
-    build: { type: 'string' },
-    review: { type: 'array', items: { type: 'string' } },
-    verify: { type: 'array', items: { type: 'string' } },
-    qa: { type: 'array', items: { type: 'string' } },
-    reason: { type: 'string' },
+    classified: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['slug', 'lane', 'build'],
+      properties: {
+        slug: { type: 'string' }, lane: { type: 'string', enum: ['express', 'directo', 'lite', 'full'] },
+        build: { type: 'string' }, review: { type: 'array', items: { type: 'string' } },
+        reason: { type: 'string' },
+      },
+    } },
   },
 }
 
@@ -128,43 +222,59 @@ const CONTRACT = {
 }
 
 // Preámbulo invariante: no depende del proyecto y nunca obliga a leer un archivo.
-const BASE = `Never invent credentials or decisions; register external blockers in ${HUMAN}. Never execute INBOX ` +
-  `automatically. Never push, deploy, amend, force, or use git add -A. Never edit process governance, and do not ` +
-  `edit planning bookkeeping unless this workflow explicitly requests it.`
-// Cierre del recorrido. El runtime no trae un helper de cierre —el valor devuelto por el script ya
-// es el resultado—, y darlo por sentado hacía reventar el archivo justo al terminar: después de
-// gastar cada etapa, en la línea que las cerraba.
-function finish(result) {
-  log(`Fin: ${JSON.stringify(result)}`)
-  return result
-}
-
-const stop = (reason, detail = '') => {
-  log(`Checkpoint: ${reason}${detail ? ` — ${detail}` : ''}`)
-  return finish({ stopped: true, reason, detail })
-}
+const BASE = `Nunca inventes credenciales ni decisiones; registrá los bloqueos externos en ${HUMAN}. Nunca ` +
+  `ejecutes INBOX por tu cuenta. Nunca hagas push, deploy, amend, force ni git add -A. No edites la gobernanza ` +
+  `del proceso, y no toques la contabilidad de planning salvo que este recorrido te lo pida explícitamente.`
+// Acompaña a todo prompt con schema DECISION: el schema obliga a llenar `consulted`, y esto obliga a
+// llenarlo con lo que se abrió en vez de con lo que se pensaba mirar.
+const MANIFEST = ' Enumerá en consulted cada archivo, diff o comando que hayas abierto de verdad, con su ruta.'
+// Acompaña a todo prompt con schema DECISION. El criterio va escrito porque tres estados sin criterio son
+// tres nombres, y el del medio —el que evita gastar una corrección en lo que no se corrige— es el que se
+// pierde primero.
+const VERDICT = ' Cerrá con verdict=aprobado si no queda nada por corregir antes de entregar; ' +
+  'verdict=con-condiciones si lo que falta se corrige dentro de este mismo cambio; y verdict=bloqueado ' +
+  'si algo no se resuelve acá —el diseño no lo cubre, falta una decisión ajena, o la corrección excede el ' +
+  'alcance—. Marcá blocking=true sólo en el hallazgo que impide entregar: el resto queda registrado y no ' +
+  'manda a tocar código.'
+// Atajo para reconocer un gate que corrió pruebas sin preguntarle a nadie. No alcanza solo y no
+// pretende hacerlo: `mvn verify`, `gradle build`, `tox`, `bin/rails t` y cualquier `make` con nombre
+// propio corren pruebas y no se parecen a esto, así que el que corrió el comando además lo declara en
+// `ranTests` y vale cualquiera de los dos. Una lista de nombres siempre le va a faltar el siguiente;
+// lo que no puede es frenar una corrida legítima por no conocerlo.
+// El borde izquierdo va explícito en vez de `\b` porque `\b(?:` se lee igual que una llamada a `b()`
+// y la comprobación de identificadores del paquete de pruebas la marca como función inexistente.
+// Lo que hay que corregir antes de entregar. El resto de los hallazgos no desaparece: se registra.
+const blockers = (verdict) => verdict.concerns.filter((one) => one.blocking).map((one) => one.detail)
+const RUNS_TESTS = /(?:^|[\s/:=-])(?:tests?|specs?|pytest|jest|vitest|mocha|rspec|phpunit|ci|check)\b/i
+{{INCLUDE:shared/workflow-finish.js}}
 
 phase('Triage')
 // El contrato se lee una sola vez por corrida y viaja como texto: ningún subagente relee AGENTS.md,
 // ops.config.json ni PROTOCOL.md. `ops check` y el guard planning-drift siguen validando el resultado.
 const contract = await agent(
-  `${BASE}\n\nRead ${ROOT}/AGENTS.md, ${CONFIG} and ${P}/PROTOCOL.md exactly once and read nothing else. Report the ` +
-  `config values verbatim: project, workspaceRoots as "name → path" entries, runner.maxTaskHours, ` +
-  `runner.commitPerTask, and runner.humanCheckpointBetweenMilestones as humanCheckpoint. Copy the "## Contratos" ` +
-  `section of PROTOCOL.md into contracts literally, without rewording, summarising or reordering it. ` +
-  `In boundaries list only limits stated in AGENTS.md that constrain autonomous execution.`,
+  `${BASE}\n\nLeé ${ROOT}/AGENTS.md, ${CONFIG} y ${P}/PROTOCOL.md una sola vez y no leas nada más. Reportá los ` +
+  `valores de configuración textualmente: project, workspaceRoots como entradas "nombre → ruta", ` +
+  `runner.maxTaskHours, runner.commitPerTask y runner.humanCheckpointBetweenMilestones como humanCheckpoint. ` +
+  `Copiá la sección "## Contratos" de PROTOCOL.md dentro de contracts tal cual, sin reformular, resumir ni ` +
+  `reordenar. En boundaries listá sólo los límites que AGENTS.md enuncia y que restringen la ejecución autónoma.`,
   { schema: CONTRACT, label: 'contract-digest' },
 )
 if (!contract) return stop('contract-unavailable', `no se pudo leer ${CONFIG} ni ${P}/PROTOCOL.md`)
 
-const limits = (contract.boundaries || []).length ? ` Project limits: ${contract.boundaries.join('; ')}.` : ''
+const bounds = contract.boundaries || []
+const limits = bounds.length ? ` Límites del proyecto: ${bounds.join('; ')}.` : ''
 // Alcance de escritura: para subagentes que tocan código o ejecutan gates del producto.
-const SCOPE = `${BASE}\n\nProject ${contract.project}. workspaceRoots is the complete writable product boundary: ` +
-  `${contract.workspaceRoots.join('; ')}.${limits} This preamble already carries the contract; do not re-read ` +
-  `${ROOT}/AGENTS.md, ${CONFIG} or ${P}/PROTOCOL.md.`
+const SCOPE = `${BASE}\n\nProyecto ${contract.project}. workspaceRoots es el límite completo de escritura del ` +
+  `producto: ${contract.workspaceRoots.join('; ')}.${limits} Este preámbulo ya trae el contrato; no vuelvas a leer ` +
+  `${ROOT}/AGENTS.md, ${CONFIG} ni ${P}/PROTOCOL.md.`
 // Formatos de planning: sólo para subagentes que escriben roadmap, BACKLOG, WIP, DONE o gates.
-const LEDGER = `${SCOPE}\n\nPlanning contracts, verbatim from ${P}/PROTOCOL.md:\n${contract.contracts}`
+const LEDGER = `${SCOPE}\n\nContratos de planning, textuales de ${P}/PROTOCOL.md:\n${contract.contracts}`
 
+// Un subagente puede morir —error terminal tras reintentos, o alguien que lo saltea— y entonces el
+// runtime devuelve `null`. Sin comprobarlo, la primera propiedad que se le pide revienta el recorrido
+// con un TypeError en la fase que sea, y lo que quedó a medias es una tarea con WIP escrito y código
+// sin revisar. Cada llamada corta con su etapa puesta: «no contestó» no es lo mismo que «dijo que no»,
+// y sólo la segunda significa que alguien juzgó algo.
 const read = (prompt, options = {}) => agent(`${BASE}\n\n${prompt}`, options)
 const run = (prompt, options = {}) => agent(`${SCOPE}\n\n${prompt}`, options)
 const write = (prompt, options = {}) => agent(`${LEDGER}\n\n${prompt}`, options)
@@ -172,9 +282,9 @@ const write = (prompt, options = {}) => agent(`${LEDGER}\n\n${prompt}`, options)
 // Gate, mutex de WIP y selección de tarea salen de un comando determinista: AWAITING_REVIEW, BACKLOG,
 // WIP y HUMAN_ACTIONS nunca entran al contexto de un modelo, y su tamaño deja de costar tokens.
 const readContext = () => read(
-  `Run "node tools/ops.js context ${P} --json" from ${ROOT} and report only what it printed. Derive hasTask from ` +
-  `whether task is null, wipActive from whether wip is null, and lane from task.tier; copy slug, hito, service, ` +
-  `acceptance and epic from task. The command is the source of truth: do not open planning files to complete it.`,
+  `Corré "node tools/ops.js context ${P} --json" desde ${ROOT} y reportá sólo lo que imprimió. Derivá hasTask ` +
+  `de si task es null, wipActive de si wip es null y lane de task.tier; copiá slug, hito, service, acceptance, ` +
+  `epic y cast de task. El comando es la fuente de verdad: no abras archivos de planning para completarlo.`,
   { schema: CONTEXT, label: 'planning-context' },
 )
 
@@ -182,206 +292,377 @@ let planning = await readContext()
 if (!planning) return stop('context-unavailable', `no se pudo leer el estado de ${P}`)
 if (planning.blocked) return stop('awaiting-human-review', `${GATE} tiene un checkpoint humano sin resolver`)
 
-let currentHito = planning.wipActive ? planning.hito : ''
+let currentMilestone = planning.wipActive ? planning.hito : ''
 const completed = []
-let safety = 0
+// Tope de tareas por corrida. No protege de un hito grande —cincuenta tareas en un hito es un problema
+// de planificación, no de ejecución— sino de un ciclo: una tarea que vuelve a quedar elegible corre
+// para siempre. Se corta con motivo porque agotarlo en silencio se lee igual que haber terminado.
+const MAX_TASKS = 50
+let rounds = 0
+// Tareas que ya pasaron por el clasificador en esta corrida. Sin esto, una que vuelve sin lane
+// —porque la escritura falló o el modelo la salteó— se reclasifica en cada vuelta del bucle.
+const classified = new Set()
 
-while (safety++ < 50) {
+while (rounds++ < MAX_TASKS) {
   phase('Pick')
   if (!planning.hasTask && !planning.queued) {
     const expansion = await write(
-      `Read ${ROADMAP}. Expand only the next approved open epic into a new hito of ${BACKLOG}, preserving each story ` +
-      `slug, its criteria references and its service. Never promote ${P}/INBOX.md. Report whether you wrote anything.`,
+      `Leé ${ROADMAP}. Expandí sólo la próxima épica abierta y aprobada en un hito nuevo de ${BACKLOG}, ` +
+      `conservando el slug de cada historia, sus referencias a criterios y su servicio. Nunca promuevas ` +
+      `${P}/INBOX.md. Reportá si escribiste algo.`,
       { schema: EXPANSION },
     )
+    if (!expansion) return stop('agent-unavailable', 'Pick no devolvió resultado')
     if (!expansion.expanded) break
     planning = await readContext()
     if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
   }
-  if (!planning.hasTask || (currentHito && planning.hito !== currentHito)) break
+  if (!planning.hasTask || (currentMilestone && planning.hito !== currentMilestone)) break
   const task = {
     id: planning.slug, hito: planning.hito, service: planning.service,
     acceptance: planning.acceptance, epic: planning.epic,
   }
-  currentHito = task.hito
-  const direct = planning.lane === 'directo'
-  const lite = planning.lane === 'lite'
+  currentMilestone = task.hito
 
-  // Quién ejecuta cada fase. Los dueños por defecto son fijos y no gastan una llamada; los
-  // condicionales entran por riesgo, plataforma y alcance —nunca por rutina—, que es la misma
-  // regla que ya usa el team. En `directo` no hay condicionales: el lane baja ceremonia.
-  const cast = { ...OWNERS, build: '' }
-  if (!direct) {
-    phase('Cast')
-    const chosen = await read(
-      `${CAST_RULES}\n\nTarea ${task.id} en ${task.service}. Aceptación: ${task.acceptance}.\n` +
-      `Run "node tools/ops.js agents list ${ROOT} --json" and choose only from the slugs it lists.\n` +
-      `Elegí el cargo que implementa según la plataforma del servicio${lite ? '.' : ', y los cargos ' +
-      'condicionales que la superficie realmente justifica: seguridad si toca autenticación, permisos, ' +
-      'criptografía o datos sensibles; privacidad si toca datos personales; sre si toca disponibilidad, ' +
-      'límites o despliegue; ux si cambia una superficie que usa una persona; y el que corresponda a ' +
-      'datos o modelos si los toca. Dejá vacío lo que no aplique: sumar un cargo que no aporta es ruido ' +
-      'que diluye la revisión.'}`,
-      { schema: CAST, label: 'cast' },
+  // Ver la tarea y, si no está clasificada, clasificarla antes de ejecutarla. Se hace una vez por
+  // tarea y se escribe en su línea, así que la decisión sobrevive a la corrida y la puede corregir
+  // una persona antes de que se ejecute nada — al revés que la fase Cast, que la tomaba en caliente,
+  // costaba una llamada por tarea y la tiraba al terminar. Clasifica el hito entero de una sola
+  // llamada: lo que cuesta una vez no debería costar una vez por tarea.
+  //
+  // Un WIP activo no se reclasifica: la tarea ya está en vuelo con las fases que le tocaron, y
+  // cambiárselas a mitad de camino la deja con un plan aprobado bajo otro carril.
+  const unclassified = !planning.lane || !planning.cast.build
+  if (unclassified && !planning.wipActive && !classified.has(task.id)) {
+    phase('Classify')
+    classified.add(task.id)
+    const classification = await write(
+      `${CLASSIFY_RULES}\n\nRun "node tools/ops.js agents list ${ROOT} --json" and choose only from the slugs ` +
+      `it lists.\nClasificá en ${BACKLOG} todas las tareas en cola que no declaren lane o no declaren cast, ` +
+      `empezando por ${task.id} en ${task.service} —aceptación: ${task.acceptance}—. El lane va entre ` +
+      `corchetes después del slug y el reparto al final de la línea, con la forma ` +
+      `"(cast: quien-entrega → quien-revisa, otro)". No toques nada más de la línea, ni el orden del hito, ` +
+      `ni las tareas que ya declaran las dos cosas. Reportá lo que escribiste.`,
+      { schema: CLASSIFICATION },
     )
-    if (chosen) {
-      cast.build = chosen.build || ''
-      for (const key of ['review', 'verify', 'qa']) {
-        cast[key] = [OWNERS[key], ...(lite ? [] : chosen[key] || [])].filter(Boolean).join(', ')
-      }
-      log(`Cargos: build=${cast.build || '(sin asignar)'} · review=${cast.review} · qa=${cast.qa}`)
+    if (classification && classification.classified.length) {
+      log(`Clasificadas: ${classification.classified
+        .map((one) => `${one.slug} [${one.lane}] ${one.build}`).join(' · ')}`)
+      planning = await readContext()
+      if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
+      continue
     }
+    // Sin clasificación no se frena la tarea: `full` es el carril que no saltea nada, así que lo que
+    // se pierde es tiempo y no evidencia. Frenar acá cobraría una interrupción por lo único que el
+    // recorrido puede resolver solo.
+    log(`${task.id} sigue sin clasificar: corre por el carril completo`)
   }
+
+  const express = planning.lane === 'express'
+  const direct = planning.lane === 'directo'
+  const lite = planning.lane === 'lite'
+  // Lo mecánico no se planifica ni se pregunta si está listo: el clasificador ya leyó la aceptación y
+  // dijo que nombra un valor literal. Volver a preguntarlo son dos llamadas para llegar al mismo lado.
+  const mechanical = express || direct
+
+  // Quién ejecuta cada fase. Los dueños por defecto son fijos y no gastan una llamada; quien
+  // implementa y quiénes revisan por riesgo salen de la línea de la tarea. Los revisores valen en
+  // todos los carriles: los nombró quien ya sabía cuál era el carril, y descartarlos acá sería un
+  // segundo filtro que contradice al primero.
+  const cast = { ...OWNERS, build: planning.cast.build }
+  cast.review = [OWNERS.review, ...planning.cast.review].filter(Boolean).join(', ')
+  log(`Cargos: build=${cast.build || '(sin asignar)'} · review=${cast.review} · qa=${cast.qa}`)
   const asRole = (slugs) => (slugs
     ? `Actuá como ${slugs}, respetando el contrato de cada uno en su SKILL.md bajo agents/ y sus ` +
       `límites: un cargo que no puede decidir solo, no decide solo.\n\n`
     : '')
 
   if (!planning.wipActive) {
-    phase('Ready')
-    const ready = await read(
-      `${asRole(OWNERS.ready)}Check concrete acceptance, dependencies and unresolved decisions for ${task.id}: ` +
-      `${task.acceptance}. Clarify wording only; never expand scope.`, { schema: READY },
-    )
-    if (!ready.ready) {
-      await write(`Register ${task.id} in ${HUMAN} with reason and an exact human action: ${ready.reason}.`)
-      return stop('not-ready', ready.reason)
+    if (!mechanical) {
+      phase('Ready')
+      const ready = await read(
+        `${asRole(OWNERS.ready)}Revisá que ${task.id} tenga aceptación concreta, dependencias resueltas y ` +
+        `ninguna decisión pendiente: ${task.acceptance}. Aclará la redacción y nada más; nunca amplíes el ` +
+        `alcance.`,
+        { schema: READY },
+      )
+      if (!ready) return stop('agent-unavailable', 'Ready no devolvió resultado')
+      if (!ready.ready) {
+        await write(`Registrá ${task.id} en ${HUMAN} con el motivo y una acción humana exacta: ${ready.reason}.`)
+        return stop('not-ready', ready.reason)
+      }
+      if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
     }
-    if (ready.refinedAcceptance) task.acceptance = ready.refinedAcceptance
 
-    if (!direct && !lite) {
+    if (!mechanical && !lite) {
       phase('Decompose')
       const estimate = await run(
-        `Inspect ${task.service} and estimate ${task.id}. Split it only if it exceeds ${contract.maxTaskHours} hours.`,
+        `Inspeccioná ${task.service} y estimá ${task.id}. Partila sólo si supera ${contract.maxTaskHours} horas.`,
         { schema: ESTIMATE },
       )
+      if (!estimate) return stop('agent-unavailable', 'Decompose no devolvió resultado')
       if (estimate.needsSplit) {
-        await write(`Replace only ${task.id} in ${BACKLOG} with ordered, ` +
-          `independently verifiable subtasks: ${JSON.stringify(estimate.subtasks)}.`)
+        await write(`Reemplazá sólo ${task.id} en ${BACKLOG} por subtareas ordenadas y verificables de forma ` +
+          `independiente: ${JSON.stringify(estimate.subtasks)}.`)
         planning = await readContext()
         if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
         continue
       }
     }
 
+    // El plan de un cambio mecánico es el cambio, y la aceptación ya lo nombra. Pedirlo igual costaba
+    // dos llamadas —planificar y criticar el plan— para llegar a lo que la línea de la tarea ya decía.
+    let plan = { steps: [`Aplicar en ${task.service} lo que nombra la aceptación: ${task.acceptance}`] }
+    if (!mechanical) {
     phase('Plan')
-    let plan = await run(
-      `${asRole(OWNERS.plan)}Inspect real code, repository instructions, neighbouring conventions, epic context ` +
-      `and git status for ${task.id}. ` +
-      `Produce the smallest plan satisfying ${task.acceptance}. Planning files cannot be implementation files.`,
+    plan = await run(
+      `${asRole(OWNERS.plan)}Inspeccioná el código real, las instrucciones del repositorio, las convenciones ` +
+      `vecinas, el contexto de la épica y el git status de ${task.id}. Producí el plan más chico que satisfaga ` +
+      `${task.acceptance}. Un archivo de planning no puede ser un archivo de implementación. El plan cubre ` +
+      `sólo el cambio dentro de ${task.service}: correr los gates del repositorio, hacer QA, commitear y ` +
+      `cerrar la tarea son fases posteriores de este recorrido, cada una con su dueño, así que no van como ` +
+      `pasos.`,
       { schema: PLAN },
     )
-    if (!direct && !lite) {
+    if (!plan) return stop('agent-unavailable', 'Plan no devolvió resultado')
+    if (!lite) {
       phase('Critique')
       let critique = await read(
-        `Attack this plan for correctness, scope, security, tests and conflicts with existing ` +
-        `code: ${JSON.stringify(plan)}`,
+        `Atacá este plan por correctitud, alcance, seguridad, pruebas y conflictos con el código ` +
+        `existente.${MANIFEST}${VERDICT} Plan: ${JSON.stringify(plan)}`,
         { schema: DECISION },
       )
-      if (!critique.approved) {
+      if (!critique) return stop('agent-unavailable', 'Critique no devolvió resultado')
+      // Un plan bloqueado no se corrige: lo que lo bloquea está fuera de lo que una segunda pasada puede
+      // tocar, así que insistir gasta dos llamadas para llegar al mismo lugar.
+      if (critique.verdict === 'bloqueado') {
+        return stop('plan-blocked', blockers(critique).join('; ') || 'sin condiciones nombradas')
+      }
+      if (blockers(critique).length) {
         plan = await read(
-          `Revise the plan once for: ${critique.concerns.join('; ')}. Plan: ${JSON.stringify(plan)}`,
+          `Corregí el plan una vez por: ${blockers(critique).join('; ')}. Plan: ${JSON.stringify(plan)}`,
           { schema: PLAN },
         )
         critique = await read(
-          `Re-critique the revised plan against ${task.acceptance}: ${JSON.stringify(plan)}`,
+          `Volvé a criticar el plan corregido contra ${task.acceptance}.${MANIFEST}${VERDICT} ` +
+          `Plan: ${JSON.stringify(plan)}`,
           { schema: DECISION },
         )
-        if (!critique.approved) return stop('plan-rejected', critique.concerns.join('; '))
+        if (!plan || !critique) return stop('agent-unavailable', 'la revisión del plan no devolvió resultado')
+        if (critique.verdict === 'bloqueado' || blockers(critique).length) {
+          return stop('plan-rejected', blockers(critique).join('; ') || 'sin condiciones nombradas')
+        }
       }
+      // Acá el plan ya está aprobado por los dos caminos posibles, así que el contraste va una sola vez.
+      if (!critique.consulted.length) return stop('critique-unbacked', 'aprobó el plan sin declarar qué inspeccionó')
+    }
     }
-    await write(
-      `Persist active WIP before code: task=${task.id}, hito=${JSON.stringify(task.hito)}, ` +
-      `phase=Build, service=${task.service}, ` +
-      `acceptance=${JSON.stringify(task.acceptance)}, unchecked steps=${JSON.stringify(plan.steps)}. ` +
-      `Registrá además el reparto de cargos ${JSON.stringify(cast)} en las decisiones del WIP, para que ` +
-      `después se pueda auditar quién revisó qué. Follow the WIP contract exactly.`,
+    phase('WIP')
+    // Esta llamada escribe un archivo y nada más, y hay que decirlo con todas las letras. En una corrida
+    // real hizo el trabajo entero: leyó los pasos del plan como una orden, implementó, corrió RED/GREEN,
+    // cerró la tarea en DONE y dejó el WIP en IDLE. Build encontró todo hecho y lo atribuyó a «una corrida
+    // anterior», así que Review, Verify y QA nunca vieron ese código y el recorrido terminó reportando algo
+    // distinto de lo que decía planning. El permiso venía del preámbulo de escritura; lo que faltaba era el
+    // límite. `wipActive` es el contraste: si el WIP no quedó activo, esta fase hizo otra cosa.
+    const persisted = await write(
+      `Escribí el WIP y nada más: no toques código, no corras pruebas, no cierres la tarea y no escribas ` +
+      `en DONE. Los pasos van sin tildar porque todavía no ocurrieron. task=${task.id}, ` +
+      `hito=${JSON.stringify(task.hito)}, phase=Build, service=${task.service}, ` +
+      `acceptance=${JSON.stringify(task.acceptance)}, pasos sin tildar=${JSON.stringify(plan.steps)}. ` +
+      `Registrá el reparto de cargos ${JSON.stringify(cast)} en las decisiones del WIP, para que después se ` +
+      `pueda auditar quién revisó qué. Seguí el contrato de WIP exactamente y reportá con qué status quedó.`,
+      { schema: {
+        type: 'object', additionalProperties: false, required: ['wipActive'],
+        properties: { wipActive: { type: 'boolean' }, note: { type: 'string' } },
+      } },
     )
+    if (!persisted) return stop('agent-unavailable', 'la persistencia del WIP no devolvió resultado')
+    if (!persisted.wipActive) {
+      return stop('wip-not-persisted', `${task.id} entra a Build sin WIP activo: ${persisted.note || ''}`)
+    }
   }
 
   phase('Build')
   const build = await run(
-    `${asRole(cast.build)}Implement only ${task.id} inside ${task.service}. Resume at the first pending WIP ` +
-    `step; verify completed steps on disk ` +
-    `and tick each successful step. Use RED/GREEN for behavior. Acceptance: ${task.acceptance}.`, {
-      schema: { type: 'object', required: ['completed', 'summary'], properties: {
-        completed: { type: 'boolean' }, summary: { type: 'string' },
-        blockers: { type: 'array', items: { type: 'string' } },
-      } },
-    },
+    `${asRole(cast.build)}Implementá sólo ${task.id} dentro de ${task.service}. Retomá en el primer paso ` +
+    `pendiente del WIP; comprobá en el disco los pasos ya hechos y tildá cada uno que salga bien. Para cada ` +
+    `comportamiento escribí primero la prueba, corréla y anotá en redFirst el test y el fallo literal que ` +
+    `dio; recién después implementá. Un test que pasa antes de que exista el código no asercia lo que dice ` +
+    `aserciar: endurecelo y volvé a correr hasta verlo fallar. Corré las pruebas que necesites para ver ese ` +
+    `rojo y ese verde, y nada más: los gates completos, el QA, el commit y el cierre son fases posteriores, ` +
+    `así que no toques ${DONE} ni ${BACKLOG} ni el status del WIP. Lo que el plan no previó va en discovered y ` +
+    `no en el código a secas: kind=edge si esta tarea lo puede fijar —y entonces entra con su prueba, que ` +
+    `nombrás en test y anotás en redFirst—, kind=open si lo notaste y no impide entregar la aceptación: se ` +
+    `registra para que lo decida quien corresponde y el recorrido sigue. Si de verdad no podés entregar sin ` +
+    `esa decisión, eso no va en discovered: es completed=false con su blocker. ` +
+    `Aceptación: ${task.acceptance}.`,
+    { schema: BUILD },
   )
+  if (!build) return stop('agent-unavailable', 'Build no devolvió resultado')
   if (!build.completed) return stop('build-blocked', (build.blockers || []).join('; ') || build.summary)
+  // Construir no es cerrar. Pasó en una corrida real: el plan traía «VERIFY», «QA» y «Cierre — commit» como
+  // pasos, quien construyó los ejecutó, y la tarea salió del BACKLOG y entró a DONE sin que Review, Verify
+  // ni QA la miraran. El plan ya no los pide; esto detecta que igual hayan ocurrido.
+  if (build.closedTask) {
+    return stop('build-closed-task', `${task.id} se cerró en Build, sin pasar por Review, Verify ni QA`)
+  }
+  // Nombrar el test sin traer su fallo es volver a afirmar que hubo rojo, que es lo que el campo evita.
+  const unproven = build.redFirst.find((entry) => !entry.failure.trim())
+  if (unproven) return stop('build-unproven', `${unproven.test} se declara en rojo sin el fallo que lo muestra`)
+  // Lo que queda abierto no lo cierra quien lo encuentra, pero tampoco frena lo que sí se pudo entregar.
+  // Tres corridas reales terminaron acá y las tres traían `completed: true`: el hueco nunca fue «no puedo»
+  // sino «hay un borde que alguien tiene que decidir», y una aceptación escrita en prosa siempre tiene uno.
+  // Frenar por eso frenaba siempre, y un freno que salta siempre se termina apagando. Lo que de verdad
+  // bloquea ya tiene camino —`completed: false` con su blocker—; esto se registra y sigue.
+  const openDecisions = build.discovered.filter((entry) => entry.kind === 'open')
+  if (openDecisions.length) {
+    await write(`Registrá en ${HUMAN} una fila por cada decisión que ${task.id} dejó abierta, con qué la ` +
+      `cierra y quién puede tomarla. No inventes responsables ni fechas: ` +
+      `${JSON.stringify(openDecisions.map((entry) => entry.detail))}`)
+  }
+  // Y un caso que sí se fijó acá entra con su prueba o no entró: sin ella el comportamiento nuevo queda
+  // sin nada que lo sostenga, y nadie sabe después que debía existir.
+  // Los dos campos salen de la misma respuesta pero se escriben por separado, así que pedirles la misma
+  // cadena exacta frena una tarea correcta por haber nombrado el test de dos formas —`TestAlta` acá y
+  // `users_test.go::TestAlta` allá—. Alcanza con que uno nombre al otro; lo que sigue frenando, que es de
+  // lo que se trata, es el caso que no aparece en ningún rojo.
+  const namesTest = (red, item) => Boolean(item.test)
+    && (red.test.includes(item.test) || item.test.includes(red.test))
+  const loose = build.discovered.find((entry) => entry.kind === 'edge'
+    && !build.redFirst.some((red) => namesTest(red, entry)))
+  if (loose) return stop('edge-unproven', `${loose.detail} entró sin la prueba que lo fija`)
 
-  if (!direct) {
+  if (!express) {
     phase('Review')
     let review = await run(
-      `${asRole(cast.review)}Review the actual diff for acceptance, regressions, security, architecture, ` +
-      `generated code, migrations and accidental scope. Cada cargo revisa su dominio, no el ajeno.`,
+      `${asRole(cast.review)}Revisá el diff real por aceptación, regresiones, seguridad, arquitectura, código ` +
+      `generado, migraciones y alcance accidental. Cada cargo revisa su dominio, no el ajeno.${MANIFEST}` +
+      `${VERDICT}`,
       { schema: DECISION },
     )
-    if (!review.approved) {
-      await write(`Fix only these evidence-backed findings and update WIP: ${review.concerns.join('; ')}`)
-      review = await run(`Re-review the corrected diff for ${task.id}.`, { schema: DECISION })
-      if (!review.approved) return stop('review-failed', review.concerns.join('; '))
+    if (!review) return stop('agent-unavailable', 'Review no devolvió resultado')
+    if (review.verdict === 'bloqueado') {
+      return stop('review-blocked', blockers(review).join('; ') || 'sin condiciones nombradas')
+    }
+    if (blockers(review).length) {
+      await write(`Corregí sólo estos hallazgos con evidencia y actualizá el WIP: ${blockers(review).join('; ')}`)
+      review = await run(`Volvé a revisar el diff corregido de ${task.id}.${MANIFEST}${VERDICT}`,
+        { schema: DECISION })
+      if (!review) return stop('agent-unavailable', 'la re-revisión no devolvió resultado')
+      if (review.verdict === 'bloqueado' || blockers(review).length) {
+        return stop('review-failed', blockers(review).join('; ') || 'sin condiciones nombradas')
+      }
+    }
+    // Aprobar sin declarar qué se abrió no se arregla mandando a tocar código: falló quien revisó.
+    if (!review.consulted.length) return stop('review-unbacked', 'aprobó el diff sin declarar qué inspeccionó')
+    // Lo que no impide entregar no manda a tocar código, y tampoco desaparece: la mejora opinable que se
+    // corrige a las apuradas cuesta una vuelta y un riesgo que nadie pidió. Va a Propuestas y no a
+    // Lecciones porque lo que la revisión anotó es un cambio del producto con su evidencia; Lecciones es
+    // sobre cómo trabajamos, y ahí el hallazgo queda esperando una promoción que nadie va a hacer.
+    const noted = review.concerns.filter((one) => !one.blocking).map((one) => one.detail)
+    if (noted.length) {
+      await write(`Registrá en la sección Propuestas de ${P}/INBOX.md lo que la revisión de ${task.id} dejó ` +
+        `anotado sin frenar la entrega, sin promover ninguna: ${JSON.stringify(noted)}`)
     }
   }
 
   phase('Verify')
-  const verified = await run(
-    `${asRole(cast.verify)}Discover and run the real gates for ${task.service}: repository instructions first, ` +
-    `then applicable test, lint, ` +
-    `typecheck and build. Read actual exit codes. passed=true needs commands and no task-caused regression.`,
-    { schema: VERIFY },
-  )
+  const VERIFY_ASK = `${asRole(cast.verify)}Abrí el fuente de los tests que la tarea agregó o cambió y ` +
+    `contrastá cada criterio ` +
+    `de aceptación contra sus aserciones: en uncovered va el criterio que ningún test codifica, con su causa ` +
+    `—missing-test si el test falta o no asercia la propiedad, ambiguous si el criterio no dice qué habría ` +
+    `que aserciar—. Un test que pasa sin aserciarla no la cubre. Después descubrí y corré los gates reales ` +
+    `de ${task.service}: primero las instrucciones del ` +
+    `repositorio, después el test, lint, typecheck y build que apliquen. Leé los exit codes de verdad. ` +
+    `passed=true exige comandos corridos y ninguna regresión causada por la tarea. Marcá ranTests en el ` +
+    `comando que haya corrido las pruebas, sea cual sea su nombre. ` +
+    `Aceptación: ${task.acceptance}.`
+  let verified = await run(VERIFY_ASK, { schema: VERIFY })
+  if (!verified) return stop('agent-unavailable', 'Verify no devolvió resultado')
+  // Un criterio que nadie sabe cómo aserciar no es trabajo que falta sino una definición que falta, y
+  // definirla acá sería inventarla. Escribir la prueba que falta, en cambio, es trabajo del recorrido:
+  // hacer parar a una persona por eso le cobra una interrupción por algo que se resolvía solo.
+  const ambiguous = verified.uncovered.find((entry) => entry.cause === 'ambiguous')
+  if (ambiguous) {
+    await write(`Registrá ${task.id} en ${HUMAN}: el criterio "${ambiguous.criterion}" no dice qué habría ` +
+      `que aserciar, y hace falta la decisión que lo fija.`)
+    return stop('acceptance-ambiguous', ambiguous.criterion)
+  }
+  if (verified.uncovered.length) {
+    await run(`${asRole(cast.build)}Escribí sólo las pruebas que faltan en ${task.id}, con el mismo rojo ` +
+      `previo, y no toques el código de producción: ${verified.uncovered.map((e) => e.criterion).join('; ')}`)
+    verified = await run(VERIFY_ASK, { schema: VERIFY })
+    if (!verified) return stop('agent-unavailable', 'la segunda pasada de Verify no devolvió resultado')
+  }
   if (!verified.passed || !verified.commands.length) return stop('verify-failed', verified.details)
+  // Verde por ausencia: los gates pasaron y ninguno corrió las pruebas que esta tarea escribió. El exit
+  // code de lint o de build no dice nada del comportamiento, y la corrida cerraba igual.
+  const ranTests = verified.commands.some((entry) => entry.ranTests || RUNS_TESTS.test(entry.cmd))
+  if (build.redFirst.length && !ranTests) {
+    return stop('verify-untested', `${task.id} escribió pruebas y ningún gate corrió una`)
+  }
+  if (verified.uncovered.length) {
+    return stop('verify-hollow', `sin test que lo codifique: ${verified.uncovered.map((e) => e.criterion).join('; ')}`)
+  }
 
-  phase('QA')
-  const qa = await run(
-    `${asRole(cast.qa)}${direct || lite
-      ? 'Perform the cheapest real acceptance check'
-      : 'Exercise real consumer-visible behavior'} for ` +
-    `${task.id}. Unit tests alone are not QA. Start only minimum runtime and tear it down. ` +
-    `Acceptance: ${task.acceptance}.`,
-    { schema: QA },
-  )
-  if (!qa.passed) return stop('qa-failed', qa.evidence)
+  // QA ejercita comportamiento, y lo mecánico no lo cambia: el valor literal que la aceptación nombra
+  // ya lo comprobó Verify contra el test, y en `directo` además lo mira el revisor que nombra el cast.
+  let qa = { passed: true, evidence: 'carril mecánico: la aceptación queda comprobada en Verify' }
+  if (!mechanical) {
+    phase('QA')
+    qa = await run(
+      `${asRole(cast.qa)}${lite
+        ? 'Hacé la comprobación de aceptación real más barata'
+        : 'Ejercitá el comportamiento real que ve quien lo usa'} para ` +
+      `${task.id}. Las pruebas unitarias solas no son QA. Levantá el mínimo runtime necesario y bajalo ` +
+      `después. Aceptación: ${task.acceptance}.`,
+      { schema: QA },
+    )
+    if (!qa) return stop('agent-unavailable', 'QA no devolvió resultado')
+    if (!qa.passed) return stop('qa-failed', qa.evidence)
+  }
 
   phase('Commit')
   const commit = contract.commitPerTask ? await run(
-    `${asRole(OWNERS.commit)}Find the git repo owning ${task.service}, inspect status/diff, stage explicit task ` +
-    `files, create one Conventional ` +
-    `Commit with footer "Task: ${task.id}", then verify log/status. Never amend or push; report unrelated leftovers.`,
+    `${asRole(OWNERS.commit)}Encontrá el repositorio git dueño de ${task.service}, inspeccioná status y diff, ` +
+    `stageá por nombre los archivos de la tarea, creá un solo Conventional Commit con el footer ` +
+    `"Task: ${task.id}" y después verificá log y status. Nunca amend ni push; reportá lo que quedó suelto ` +
+    `y no era de la tarea.`,
     { schema: COMMIT },
-  ) : { committed: true, reason: 'runner.commitPerTask is disabled' }
+  ) : { committed: true, reason: 'runner.commitPerTask está apagado' }
+  if (!commit) return stop('agent-unavailable', 'Commit no devolvió resultado')
   if (!commit.committed) return stop('commit-failed', commit.reason)
 
   phase('Done')
   await write(
-    `Atomically close ${task.id}: append it under its hito in ${DONE} with acept, done, qa, ` +
-    `tests and commit evidence; ` +
-    `remove it and its indented notes from ${BACKLOG}; close its epic only if no tagged task remains; ` +
-    `reset ${WIP} to ` +
-    `status IDLE. Facts: build=${build.summary}; verify=${JSON.stringify(verified.commands)}; qa=${qa.evidence}; ` +
-    `commit=${commit.hash || commit.reason}.`,
+    `Cerrá ${task.id} de forma atómica: agregala bajo su hito en ${DONE} con evidencia de acept, done, qa, ` +
+    `tests y commit; sacala junto con sus notas indentadas de ${BACKLOG}; cerrá su épica sólo si no queda ` +
+    `ninguna tarea etiquetada; y dejá ${WIP} en status IDLE. Hechos: build=${build.summary}; ` +
+    `verify=${JSON.stringify(verified.commands)}; qa=${qa.evidence}; commit=${commit.hash || commit.reason}.`,
   )
   completed.push(task.id)
   planning = await readContext()
   if (!planning) return stop('context-unavailable', `no se pudo releer el estado de ${P}`)
 }
 
+if (rounds > MAX_TASKS) {
+  return stop('milestone-too-long', `la corrida agotó el tope de ${MAX_TASKS} tareas sin cerrar el hito`)
+}
+
 phase('Closing')
 const closing = await write(
-  `Run "node tools/ops.js check ${P}" from ${ROOT}. If red, repair only deterministic derived state; never rewrite ` +
-  `acceptance or decisions to force green.`, {
+  `Corré "node tools/ops.js check ${P}" desde ${ROOT}. Si sale en rojo, reparás sólo estado derivado ` +
+  `determinista; nunca reescribas aceptación ni decisiones para forzar el verde.`, {
     schema: {
       type: 'object', required: ['passed', 'details'],
       properties: { passed: { type: 'boolean' }, details: { type: 'string' } },
     },
   },
 )
+if (!closing) return stop('agent-unavailable', 'Closing no devolvió resultado')
 if (!closing.passed) return stop('planning-check-failed', closing.details)
 if (completed.length && contract.humanCheckpoint) await write(
-  `Create ${GATE} with the completed hito, tasks ${completed.join(', ')}, evidence, pending human actions and exact ` +
-  `continuation instructions. Never push or deploy.`,
+  `Creá ${GATE} con el hito terminado, las tareas ${completed.join(', ')}, la evidencia, las acciones humanas ` +
+  `pendientes y las instrucciones exactas para continuar. Nunca hagas push ni deploy.`,
 )
-return finish({ done: completed, count: completed.length, hito: currentHito })
+return finish({ done: completed, count: completed.length, hito: currentMilestone })