@ingeniomaps/cauce 0.75.0 → 0.76.0

package/CHANGELOG.md

@@ -14,6 +14,53 @@ desde este repositorio no va, porque el que lee no puede actuar sobre eso. Cuand
 unas pocas líneas casi siempre es porque cuenta cómo se descubrió el problema o por qué se eligió el
 diseño — eso vive en el commit y en el código.
 
+## [0.76.0] - 2026-09-10
+
+### Corregido
+
+- **Un comando que no encuentra tu planning lo dice, en vez de contestar un hecho sobre un directorio que
+  no existe.** `context` y `tree` ya lo hacían desde 0.71.0; los otros nueve no. `claim` contestaba «no
+  está en BACKLOG», `release` «no está tomada por nadie», `evidence` «DONE no tiene ninguna entrada»,
+  `runners` «ningún runner tiene trabajo abierto» — todos hechos concretos sobre lo que no pudieron leer.
+  **Cuatro de ellos salían con exit 0**, así que un script veía éxito.
+
+  El daño no es el mensaje sino lo que induce: en una corrida real, `claim` dijo «no está en BACKLOG»
+  sobre una tarea que **sí** estaba, y el recorrido mandó a una persona a promover lo único que ya estaba
+  bien, citando la regla correcta con la conclusión al revés. Ahora los once comandos que reciben un
+  planning fallan igual, con la ruta **resuelta** puesta — que es lo que hace falta cuando el error es de
+  resolución: en sidecar, `<empresa>-ops/planning` escrito desde adentro de la raíz apunta a
+  `<empresa>-ops/<empresa>-ops/planning`.
+
+  **Lo que te pide algo**: si tenías un script que trataba ese vacío como «nada que hacer», ahora falla.
+  Es la misma dirección que 0.63.0 y 0.71.0 ya tomaron. Y `ops check` sobre una ruta que no existe pasa a
+  decir eso en vez de «falta BACKLOG.md»: sale con 2 y nombra la ruta.
+
+### Agregado
+
+- **La entrada declara también `review:`, y `check` cruza los dos.** El carril dice cuánta ceremonia
+  **merecía** la tarea; `review:` dice cuánta **recibió** —el veredicto y quién revisó, o `n/a — razón`
+  cuando no corrió—. Es la dimensión que la propia ADR OPS-006 nombraba como la que falta: «se sabría
+  comparando hallazgos de review por carril, y hoy no se registra esa dimensión en DONE».
+
+  Con los dos campos, `check` avisa lo que hasta ahora no tenía cómo ver: una entrada cuyo carril convoca
+  revisor —`directo`, `lite`, `full`— y cuya revisión no corrió. `express` queda afuera porque es el único
+  que legítimamente no convoca a nadie. Avisa y no falla: es un hecho del pasado que no se arregla
+  editando la entrada, y el único camino al verde sería reescribir el registro.
+
+- **La entrada de una tarea cerrada declara `lane:`, el carril con el que corrió.** El carril decide qué
+  fases recibe una tarea —`express` se saltea Ready, Plan y QA; `full` las corre todas— y viajaba sólo en
+  la línea del BACKLOG, que **se borra al cerrar**. Con eso, «¿esta tarea recibió la ceremonia que su
+  superficie pedía?» dejaba de tener dónde contestarse: en una instancia real, **0 de 79 entradas de DONE
+  registraban el carril**. Ahora queda en el registro, y `sin clasificar` es un valor y no un hueco — dice
+  que la línea no lo declaraba, que es distinto de que nadie llenara el campo.
+
+  El plan en vuelo también lo lleva: una corrida que se reanuda arma la tarea desde `wip/<runner>.md`, y
+  sin el campo ahí llegaba al cierre con el carril ya perdido aunque la tarea sí lo tuviera.
+
+  **Lo que te pide algo**: `ops check` **avisa** cuántas entradas no lo traen y **no falla** — las
+  escritas antes de esta versión no lo tienen y no hay de dónde sacárselo. Lo que sí falla es un valor
+  inventado. Si cerrás a mano, agregá `lane:` a la entrada; si cerrás con `autobuild`, ya lo escribe.
+
 ## [0.75.0] - 2026-09-10
 
 ### Cambiado

package/automatization/workflows/autobuild.js

@@ -607,7 +607,8 @@ while (rounds++ < MAX_TASKS) {
       `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)}. ` +
+      `acceptance=${JSON.stringify(task.acceptance)}, lane=${planning.lane || 'sin clasificar'}, ` +
+      `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ó.`,
       { label: 'wip', schema: {
@@ -790,7 +791,8 @@ while (rounds++ < MAX_TASKS) {
   phase('Done')
   await write(
     `Cerrá ${task.id} de forma atómica: escribí ${doneFile(task.id)} con su evidencia —acept, ` +
-    `fecha: ${planning.today}, done, qa, tests y commit, en el formato de entrada que trae este preámbulo—; ` +
+    `fecha: ${planning.today}, done, qa, tests, commit, lane y review, en el formato de entrada que trae ` +
+    `este preámbulo—; ` +
     `sacala junto con sus notas indentadas de ${BACKLOG}; cerrá su épica sólo si no queda ` +
     `ninguna tarea etiquetada; dejá ${P}/${planning.wipFile} en status IDLE; y soltá la reserva corriendo ` +
     `"node tools/ops.js release ${P} ${task.id}". En decisions no nombres una fase ni un cargo ` +

package/engine/cli/archive.js

@@ -11,7 +11,7 @@ const P = require('../planning/parser')
 const PC = require('../planning/contracts')
 const AD = require('../planning/adoption')
 const F = require('../core/files')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 // La fecha de hoy, la misma que usan los comandos que leen.
 const TODAY = () => new Date().toISOString().slice(0, 10)
@@ -24,7 +24,7 @@ const TODAY = () => new Date().toISOString().slice(0, 10)
 // trabajo de arreglar, y uno que crece a mano deja de ser una lista de perdones para ser una amnistía.
 // Achicarlo sí es a mano, borrando el renglón que `check` señala.
 function adopt(dir) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const target = path.join(root, AD.BASELINE)
   if (fs.existsSync(target)) {
     // Un baseline que ya trae huella no se toca: regenerarlo es exactamente lo que la huella impide.
@@ -79,7 +79,7 @@ function archiveHumanActions(root) {
 // no hace falta: sin esto contestaría «La épica debe ser NNN», que manda a corregir la forma de algo que
 // no existe.
 function archive(dir, rawNum) {
-  if (String(rawNum || '') === 'human-actions') return archiveHumanActions(path.resolve(dir || '.'))
+  if (String(rawNum || '') === 'human-actions') return archiveHumanActions(planningRoot(dir))
   return fail('Sólo se archiva `human-actions`. La evidencia de una tarea ya vive en su propio archivo '
     + 'de `done/`, así que archivar una épica dejó de tener sentido.', 2)
 }

package/engine/cli/claims.js

@@ -9,12 +9,12 @@ const path = require('node:path')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const ST = require('../planning/state')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 const TODAY = () => new Date().toISOString().slice(0, 10)
 
 function claim(dir, slug, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   if (!slug) return fail('Falta el slug. `ops claim <planning-dir> <tarea>`', 2)
   const state = ST.snapshot(root)
   const task = state.milestones.flatMap((milestone) => milestone.tasks).find((one) => one.slug === slug)
@@ -82,7 +82,7 @@ function claim(dir, slug, cli) {
 }
 
 function release(dir, slug) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   if (!slug) return fail('Falta el slug. `ops release <planning-dir> <tarea>`', 2)
   const from = CL.runner()
   const taken = CL.read(root).find((one) => one.slug === slug)
@@ -103,7 +103,7 @@ function release(dir, slug) {
 // La persona elige; el agente exporta. Pedirle a una persona que escriba una variable de entorno para
 // retomar su propio trabajo es hacerle hacer de intérprete.
 function runners(dir, cli) {
-  const root = path.resolve(dir || '.')
+  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()

package/engine/cli/io.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const fs = require('node:fs')
 const path = require('node:path')
 
 // Terminar la corrida con un mensaje y un código. Vive aparte porque lo usa cada familia de comandos, y
@@ -15,4 +16,32 @@ function opsRoot(dir) {
   return path.resolve(dir || process.env.OPS_ROOT || '.')
 }
 
-module.exports = { fail, opsRoot }
+// La raíz de planning de un comando: resuelta **y comprobada**, en un solo lugar. Lo que no se pudo leer
+// no contesta como si se hubiera leído, y eso no puede depender de que cada comando se acuerde: sobre un
+// directorio ausente, `claim` no encuentra el slug, `evidence` no encuentra entradas y `runners` no
+// encuentra runners, y los tres reportan ese vacío como un hecho del dominio.
+//
+// El daño no es el mensaje sino la acción que induce. Medido en una corrida real: `claim` contestó «no
+// está en BACKLOG» sobre una tarea que **sí** estaba, y el recorrido mandó a una persona a promover lo
+// único que ya estaba bien, citando la regla correcta con la conclusión al revés (caso 075). Y cuatro de
+// los ocho comandos que lo hacían salían con **exit 0**, así que un script veía éxito.
+//
+// Va en la resolución y no en cada comando porque es lo que cierra la clase en vez de la instancia: la
+// misma se arregló de a una en `stagedFiles` (0.63.0) y en `context` (0.71.0), y volvió las dos veces.
+//
+// La ruta va **resuelta** y no como se escribió, porque el error que ataca es de resolución: en sidecar
+// `<empresa>-ops/planning` desde adentro de la raíz apunta a `<empresa>-ops/<empresa>-ops/planning`.
+function planningRoot(dir) {
+  const root = path.resolve(dir || '.')
+  if (!fs.existsSync(root)) {
+    return fail(`no existe el planning en ${root} (ruta resuelta). Comprobá desde dónde estás invocando.`, 2)
+  }
+  // Existir no alcanza: un directorio cualquiera contestaría cola vacía igual. `BACKLOG.md` es el archivo
+  // del que sale la cola, así que sin él la respuesta no significa nada.
+  if (!fs.existsSync(path.join(root, 'BACKLOG.md'))) {
+    return fail(`${root} (ruta resuelta) no es un planning: falta BACKLOG.md.`, 2)
+  }
+  return root
+}
+
+module.exports = { fail, opsRoot, planningRoot }

package/engine/cli/planning.js

@@ -23,7 +23,7 @@ const OB = require('../core/onboarding')
 const C = require('../config/validate')
 const CP = require('../config/paths')
 const AG = require('../agents/catalog')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 // Qué dimensiones enumera el molde de `organization/` y cuáles dejaron de estar. Un agente que reescribe
 // esos archivos tiende a quedarse con el contenido y perder la estructura: el resultado se lee entero y
@@ -36,7 +36,7 @@ const { fail } = require('./io')
 // entrada de hace tres meses no tiene con qué cruzarse—. Acá se pregunta por una entrada, que es como
 // se cierra una tarea: se escribe la evidencia y se la mira contra el árbol y contra lo que corrió.
 function evidence(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const opsDir = path.join(root, '..')
   const entries = P.readDone(root).entries
   const slug = cli.value('--task')
@@ -76,7 +76,7 @@ function evidence(dir, cli) {
 const TODAY = () => new Date().toISOString().slice(0, 10)
 
 function check(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const errors = []
   const warnings = []
   // El plan no está: `wip/` es local y gitignoreado, así que un clon nuevo no lo trae y eso no es un
@@ -148,6 +148,7 @@ function check(dir, cli) {
     epics, milestones, done, wips, roles, humanActions: P.readHumanActions(root), adopted: new Set(adopted),
   }))
   warnings.push(...AD.report({ done, epics, adopted }))
+  warnings.push(...PC.doneCeremonyWarnings(done, new Set(adopted)))
   // Sin `RECURRING.md` no dice una palabra: una instancia que actualiza y no declara trabajo recurrente
   // no tiene por qué enterarse de que el contrato existe. Vencida avisa y no frena — lo que frena vive
   // en `HUMAN_ACTIONS.md`, y un aviso que salta siempre se termina apagando.
@@ -265,10 +266,9 @@ function treeJson({ epics, milestones, done, wips, inbox, queued, claims }) {
 }
 
 function tree(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   // Mismo motivo que en `context`, y por eso comparten la comprobación: sin ella un planning ausente
   // dibujaba un árbol vacío, que se lee como un roadmap sin épicas en vez de como una ruta equivocada.
-  assertPlanning(root)
   const state = ST.snapshot(root)
   if (cli.has('--json')) return treeJson(state)
   const { epics, milestones, done, wips, inbox, queued, claims } = state
@@ -307,29 +307,9 @@ function tree(dir, cli) {
   console.log(`${paint('1', 'DONE')}   ${done.entries.length} tareas\n`)
 }
 
-// Lo que no se pudo leer no contesta como si se hubiera leído: la misma regla que `stagedFiles` aplica
-// sobre el índice de git, y que esta familia ya aplicaba al `--hito` inexistente. Faltaba la raíz, y ahí
-// pesa más, porque el consumidor no siempre es una persona: `autobuild` toma la cola vacía como permiso
-// para expandir una épica, así que un error de ruta promovía trabajo en vez de fallar.
-//
-// La ruta va **resuelta** y no como se escribió, porque el error que ataca es de resolución: en sidecar
-// `<empresa>-ops/planning` desde adentro de la raíz apunta a `<empresa>-ops/<empresa>-ops/planning`.
-function assertPlanning(root) {
-  if (!fs.existsSync(root)) {
-    return fail(`no existe el planning en ${root} (ruta resuelta). Comprobá desde dónde estás invocando.`, 2)
-  }
-  // Existir no alcanza: un directorio cualquiera contestaría cola vacía igual. `BACKLOG.md` es el archivo
-  // del que sale la cola, así que sin él la respuesta no significa nada.
-  if (!fs.existsSync(path.join(root, 'BACKLOG.md'))) {
-    return fail(`${root} (ruta resuelta) no es un planning: falta BACKLOG.md.`, 2)
-  }
-  return null
-}
-
 // Contexto mínimo suficiente para ejecutar una tarea, en lugar de releer roadmap, BACKLOG y WIP enteros.
 function context(dir, cli) {
-  const root = path.resolve(dir || '.')
-  assertPlanning(root)
+  const root = planningRoot(dir)
   const state = ST.snapshot(root)
   // Acotar la cola a un hito es como un equipo se reparte trabajo sin coordinarse: dos personas en hitos
   // distintos casi nunca dependen entre sí ni tocan los mismos archivos. Lo que se acota es qué se
@@ -473,7 +453,7 @@ function context(dir, cli) {
 // `BACKLOG.md` es la cola de lo aprobado y la escribe una persona — ningún comando del motor la toca,
 // ni siquiera `integration promote`, que aterriza en el roadmap. Pegarla es el acto de promoción.
 function recurring(dir, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   const file = RC.read(root)
   if (!file.exists) return console.log(`= este planning no declara trabajo recurrente (${RC.FILE})`)
   const state = RC.status({ ...file, done: P.readDone(root), today: TODAY() })

package/engine/cli/worktree.js

@@ -15,7 +15,7 @@ const ST = require('../planning/state')
 const CL = require('../planning/claims')
 const R = require('../core/repos')
 const O = require('../core/ownership')
-const { fail } = require('./io')
+const { fail, planningRoot } = require('./io')
 
 const git = (cwd, ...args) => spawnSync('git', args, { cwd, encoding: 'utf8' })
 
@@ -33,7 +33,7 @@ function existing(repo, branch) {
 }
 
 function worktree(dir, slug, cli) {
-  const root = path.resolve(dir || '.')
+  const root = planningRoot(dir)
   if (!slug) return fail('Falta el slug. `ops worktree <planning-dir> <tarea>`', 2)
   const state = ST.snapshot(root)
   const task = state.milestones.flatMap((milestone) => milestone.tasks).find((one) => one.slug === slug)

package/engine/planning/contracts.js

@@ -87,6 +87,12 @@ function validateDoneEntry(entry, cited = []) {
 //
 // Los criterios que la historia declaró cubrir los cita el roadmap y no la entrada, así que el cruce
 // sólo existe si la entrada dice de qué épica viene.
+// El vocabulario del carril tal como se escribe en una entrada de DONE: los cuatro de la línea del
+// BACKLOG más el que dice que la línea no lo declaraba. `sin clasificar` no es un hueco disimulado — es
+// el estado que `PROTOCOL.md` ya llama estado y no error, y escribirlo distingue «corrió sin carril» de
+// «nadie escribió el campo», que es justo lo que este campo vino a poder contestar.
+const LANE_VALUES = [...P.LANES, 'sin clasificar']
+
 function doneEntryErrors(entry, epics = []) {
   const at = `${entry.source} ${entry.slug}`
   const errors = []
@@ -97,11 +103,58 @@ function doneEntryErrors(entry, epics = []) {
   if (!entry.done) errors.push(`${at}: falta done:`)
   if (!entry.qa) errors.push(`${at}: falta qa:`)
   if (!entry.commit) errors.push(`${at}: falta commit:`)
+  // El carril con el que la tarea corrió. Ausente **avisa** y no frena, porque toda entrada escrita antes
+  // de que el campo existiera lo está y no hay de dónde sacárselo: exigirlo pondría en rojo el `check` de
+  // cada instancia que actualiza, por algo que nadie puede arreglar. Escrito mal sí frena, porque eso es
+  // un valor que alguien puso y de él depende leer si la ceremonia fue la que correspondía (OPS-006).
+  if (entry.lane && !LANE_VALUES.includes(entry.lane)) {
+    errors.push(`${at}: lane "${entry.lane}" no existe; usá ${LANE_VALUES.join(' | ')}`)
+  }
   const story = epics.find((epic) => epic.num === entry.epic)?.stories
     .find((candidate) => candidate.slug === entry.slug)
   return [...errors, ...validateDoneEntry(entry, story ? story.criteria : [])]
 }
 
+// Un carril declara **cuánta ceremonia** merecía la tarea; `n/a` en `review:` dice que la revisión no
+// corrió. `express` es el único que no convoca revisor, así que en los otros tres esa combinación es la
+// ADR incumplida, escrita en el propio registro.
+const CONVOCAN_REVISOR = ['directo', 'lite', 'full']
+const SIN_REVISION = /^n\/a\b/i
+
+// Lo que el registro puede decir sobre la ceremonia, y lo que todavía no. Los dos campos avisan en vez de
+// fallar por lo que dice `doneEntryErrors`, y cuentan en vez de listar porque al principio son todas: lo
+// que se lee es que el número baje. Cuando llegue a cero, exigirlos deja de costarle nada a nadie.
+//
+// El cruce sí nombra las tareas, porque son pocas y cada una es una pregunta concreta para una persona.
+// Y también avisa en vez de fallar, por una razón distinta de la de los campos: es un hecho del pasado
+// que no se arregla editando la entrada, así que el único camino al verde sería reescribir el registro.
+// Un gate que se apaga mintiendo es peor que no tenerlo.
+//
+// `sin clasificar` queda afuera del cruce a propósito: el recorrido corre esas tareas por el carril
+// completo, pero eso lo sabe el recorrido y no la entrada. Avisar sobre lo que hay que deducir es lo que
+// llena de ruido un aviso que después nadie mira.
+function doneCeremonyWarnings(done, adopted = new Set()) {
+  const propias = done.entries.filter((entry) => !adopted.has(entry.slug))
+  const warnings = []
+  const sinLane = propias.filter((entry) => !entry.lane)
+  if (sinLane.length) {
+    warnings.push(`planning/done: ${sinLane.length} entrada(s) sin lane:, así que no se puede comprobar `
+      + 'sobre el registro que la ceremonia que recibieron fue la que su superficie pedía (OPS-006)')
+  }
+  const sinReview = propias.filter((entry) => !entry.review)
+  if (sinReview.length) {
+    warnings.push(`planning/done: ${sinReview.length} entrada(s) sin review:, que es la dimensión con la `
+      + 'que OPS-006 dice que se mide si el carril elegido fue el correcto')
+  }
+  const saltadas = propias.filter((entry) => CONVOCAN_REVISOR.includes(entry.lane)
+    && entry.review && SIN_REVISION.test(entry.review))
+  if (saltadas.length) {
+    warnings.push(`planning/done: ${saltadas.map((entry) => entry.slug).join(', ')} declara(n) un carril `
+      + 'que convoca revisor y una revisión que no corrió: el carril reduce ceremonia, nunca evidencia')
+  }
+  return warnings
+}
+
 function duplicates(values) {
   return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))]
 }
@@ -308,6 +361,7 @@ function validateState({
 module.exports = {
   validateState,
   doneEntryErrors,
+  doneCeremonyWarnings,
   validCommitTrace,
   validDecisionTrace,
   validTestTrace,

package/engine/planning/parser.js

@@ -254,7 +254,7 @@ function doneFiles(dir) {
 
 // `fecha` entra al vocabulario porque un campo que no esté acá no corta al anterior: sin nombrarlo, el
 // `done:` de la entrada se lo tragaría entero como parte de su propio texto.
-const DONE_FIELDS = 'acept|fecha|done|qa|tests|decisions|commit'
+const DONE_FIELDS = 'acept|fecha|done|qa|tests|decisions|commit|lane|review'
 
 // Un campo vale hasta el próximo campo, una línea en blanco o el fin de la entrada. Mismo corte que ya
 // se arregló para los criterios y las historias, con el mismo síntoma: el valor es prosa y se envuelve a
@@ -287,7 +287,8 @@ function readDone(dir) {
         epic: ((match[2].match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
         acceptance: field('acept'), fecha: field('fecha'),
         done: field('done'), qa: field('qa'), tests: field('tests'),
-        decisions: field('decisions'), commit: field('commit'),
+        decisions: field('decisions'), commit: field('commit'), lane: field('lane'),
+        review: field('review'),
         source: path.relative(dir, file), raw: match[0].trimEnd(),
       })
     }
@@ -370,6 +371,10 @@ function parseWip(text, runner) {
   if (!task) return null
   return {
     task, runner, phase: field('phase') || '?', service: field('service'),
+    // El carril viaja en el WIP porque la línea del BACKLOG deja de existir al cerrar, y sin esto una
+    // corrida que se reanuda llega al cierre con el carril ya perdido: `currentTask` arma la tarea desde
+    // el WIP y le pone `tier` vacío. Medido — la tarea reanudada devolvía `""` (caso 074).
+    lane: field('lane'),
     complete: (text.match(/^\d+\.\s+\[[xX]\]/gm) || []).length,
     pending: (text.match(/^\d+\.\s+\[\s\]/gm) || []).length,
   }

package/engine/planning/state.js

@@ -50,7 +50,7 @@ function currentTask({ milestones, done, wips = [], claims = [] }, blockers = []
   if (wip) {
     const active = queue.find((task) => task.slug === wip.task)
       || {
-        slug: wip.task, hito: '', tier: '', cast: { build: '', review: [] },
+        slug: wip.task, hito: '', tier: wip.lane || '', cast: { build: '', review: [] },
         service: wip.service, acceptance: '', epic: '', criteria: [],
       }
     return { task: active, claimed: mine.has(wip.task), skipped: [], taken: [], waiting: [] }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingeniomaps/cauce",
-  "version": "0.75.0",
+  "version": "0.76.0",
   "description": "Sistema portable de planificación y ejecución verificable para cualquier proyecto",
   "keywords": [
     "planning",

package/template/planning/PROTOCOL.md

@@ -13,7 +13,14 @@ invariantes.
   opcionales: sin ellos la tarea está sin clasificar, que es un estado y no un error. Una tarea con
   dependencias no se ofrece ni se toma hasta que todas estén en DONE.
 - DONE: un archivo por tarea cerrada, `done/<slug>.md`, con su entrada `[x]` y los campos `acept:`,
-  `fecha:` en AAAA-MM-DD, `done:`, `qa:`, `tests:` y `commit:`. La fecha es la del cierre, y es lo que
+  `fecha:` en AAAA-MM-DD, `done:`, `qa:`, `tests:`, `commit:` y `lane:`. `lane:` repite el carril con el
+  que la tarea corrió —`express`, `directo`, `lite`, `full`— o `sin clasificar` si su línea no lo
+  declaraba, y existe porque el carril decide qué fases corren y su línea del BACKLOG se borra al cerrar:
+  sin él, si una tarea recibió la ceremonia que le tocaba sólo lo sabe quien estuvo en la sesión.
+  `check` avisa cuántas entradas no lo traen y falla si trae un valor que no existe. `review:` dice qué
+  pasó con la revisión —el veredicto y quién revisó— o `n/a — razón` cuando no corrió; es la dimensión con
+  la que OPS-006 dice que se mide si el carril elegido fue el correcto, y `check` cruza los dos: un carril
+  que convoca revisor con una revisión que no corrió es la ADR incumplida, escrita en el propio registro. La fecha es la del cierre, y es lo que
   ordena una evidencia que ya no depende de su posición dentro de un archivo. `tests:` enlaza cada criterio
   mediante `CN → prueba`; usa `A → prueba` cuando no hay épica o `n/a — razón` si no existe una
   superficie ejecutable. `decisions:` es opcional y, si aparece, cita `[fuente: ...]` o

package/template/planning/done/README.md

@@ -12,6 +12,8 @@ tarea entregó y con qué se comprueba.
   tests: C1 → nombre de prueba o comando; C2 → nombre de prueba o comando
   decisions: decisión no obvia [fuente: ruta/archivo] o [supuesto: motivo verificable]
   commit: abc1234 feat(scope): subject (repo@branch)
+  lane: full
+  review: aprobado por tech-lead, sobre api/alta.go
 ```
 
 El contrato completo de esos campos está en `../PROTOCOL.md`; acá va por qué el archivo es uno por tarea.
@@ -27,6 +29,27 @@ El nombre del archivo es una conveniencia; lo que identifica la tarea es el slug
 el archivo no cambia de qué tarea habla, y cerrar dos veces la misma sigue siendo un error que `check`
 rechaza, ahora entre archivos.
 
+## Por qué el carril
+
+El carril decide qué fases corre una tarea: `express` se saltea Ready, Plan y QA; `full` las corre
+todas. Ese dato vive en la línea del BACKLOG, y la línea **se borra al cerrar** — así que la pregunta
+«¿esta tarea recibió la ceremonia que su superficie pedía?» dejaba de tener dónde contestarse, y quedaba
+en la memoria de quien estuvo en la sesión. `lane:` la devuelve al registro.
+
+Se escribe aunque sea `sin clasificar`, que es distinto de no escribirlo: uno dice que la tarea corrió
+sin carril declarado y el otro, que nadie llenó el campo.
+
+## Por qué la revisión
+
+El carril dice cuánta ceremonia **merecía** la tarea; `review:` dice cuánta **recibió**. Con los dos, la
+pregunta que OPS-006 dejó pendiente —«¿el carril elegido fue el correcto?»— se contesta desde el registro
+en vez de desde la memoria de la sesión.
+
+`express` es el único carril que no convoca revisor, así que ahí `n/a — razón` es lo correcto. En
+`directo`, `lite` y `full` una revisión que no corrió es la ADR incumplida, y `check` lo avisa nombrando
+la tarea. Avisa y no falla: es un hecho del pasado que no se arregla editando la entrada, y el único
+camino al verde sería reescribir el registro.
+
 ## Por qué la fecha
 
 Mientras las entradas vivían en un archivo, «la última» era la última del archivo. Con archivos sueltos

package/template/planning/wip/README.md

@@ -12,6 +12,7 @@ phase: Build
 started: AAAA-MM-DD
 service: ruta
 acceptance: "criterio observable"
+lane: full
 ---
 
 ## Plan aprobado
@@ -24,6 +25,10 @@ acceptance: "criterio observable"
 - (ninguno)
 ```
 
+`lane:` viaja acá por la misma razón por la que existe en DONE: la línea del BACKLOG se borra al
+cerrar, y una corrida que se reanuda arma la tarea desde este archivo. Sin el campo, el cierre de una
+corrida reanudada escribe `sin clasificar` sobre una tarea que sí tenía carril.
+
 Sin archivo, el runner está en IDLE: un clon nuevo no trae ninguno y eso no es un error.
 
 ## Por qué uno por runner y no uno solo