@trycore/spec-build-harness 0.8.5 → 0.10.0

package/skills/building-a-micro-change/SKILL.md

@@ -46,7 +46,8 @@ producto.
    que cruzas uno, **detente y escala** a `building-a-slice`.
 3. **Test de regresión — solo si cambia comportamiento.** Si el micro-change repara un bug,
    añade/ajusta un test que falle antes y pase después (red→green del fix, delega en
-   `superpowers:test-driven-development`). Para cambios **no conductuales** (typo en copy, docs,
+   `superpowers:test-driven-development`) y deja **la suite del módulo tocado en verde** (no hace
+   falta la suite completa del repo). Para cambios **no conductuales** (typo en copy, docs,
    config) **no** se exige test.
 4. **PR a `main`.** Abre el Pull Request (`gitflow-guard.sh` impide la integración por push directo).
    En la descripción del PR indica que es un micro-change y por qué califica (qué límite NO cruza).
@@ -63,11 +64,28 @@ producto.
 `scaffold-guard` no aplica: no hay slice activo y el carril exige proyecto en fase `active` (scaffold
 ya confirmado).
 
+## Ámbito de las reglas pesadas — este carril está EXENTO
+
+Las reglas de **mutación obligatoria por test**, **evidencia anclada a sha** y **regresión con
+worktree/baseline** aplican al **inner loop de slices** (fase tdd→dod de `building-a-slice`; ver
+`../building-a-slice/references/evidence-budget.md`), **no** a este carril. Un micro-change exige
+exactamente:
+
+1. **1 test de regresión si cambia comportamiento** (paso 3 del pipeline), y
+2. **la suite del módulo tocado en verde**.
+
+Nada más. La mutación aquí es **opcional** — recomendada solo si ese test es la **única defensa de
+un invariante**. Presupuesto de latencia: un micro-change típico (fix de pocas líneas + su test)
+debe poder cerrar en **< 30 min** de terminal; si el ritual lo excede sistemáticamente, sobra
+ritual, no carril. Esta exención **no relaja los límites duros del Paso 0**: nueva dependencia,
+endpoint/API nueva o cambio de dominio/datos siguen escalando a `building-a-slice`.
+
 ## Estado y trazabilidad
 
-El micro-change **no escribe** `build-state.json` — es mantenimiento fuera de banda, trazado por el
-historial de git y el PR. No entra a `history[]`, así que `reflect-nudge.sh` **no** sugiere
-reflexionar por él (no hay aprendizaje de épica que capturar en un typo).
+El micro-change **no transiciona el estado del slice** — ni reclama, ni reporta gates, ni archiva:
+es mantenimiento fuera de banda, trazado por el historial de git y el PR. No entra al histórico de
+épicas, así que `reflect-nudge.sh` **no** sugiere reflexionar por él (no hay aprendizaje de épica que
+capturar en un typo).
 
 ## Reglas duras
 

package/skills/building-a-slice/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: building-a-slice
-description: Use when building, continuing, or shipping a product epic (EP-XXX) end to end — drives the fast inner-loop pipeline (DoR → OpenSpec change linked to its epic → TDD → journey-smoke → api/data → reduced DoD → PR+archive → ask for Release Gate) using the build-state.json file to synchronize agents. Heavy reviews (security/design/UX/three-way coherence/architecture/integration) run once per release in the releasing-a-version skill, not per epic. The epic is the build unit; the HUs it covers are its internal scope. Delegates to opsx:* for changes and superpowers:test-driven-development for TDD; never reimplements them.
+description: Use when building, continuing, or shipping a product epic (EP-XXX) end to end — drives the fast inner-loop pipeline (DoR → OpenSpec change linked to its epic → TDD → journey-smoke → api/data → reduced DoD → PR+archive → ask for Release Gate) synchronizing agents through the Agent Orchestrator Runtime (slice-ops.sh) — or the local state file in legacy mode. Heavy reviews (security/design/UX/three-way coherence/architecture/integration) run once per release in the releasing-a-version skill, not per epic. The epic is the build unit; the HUs it covers are its internal scope. Delegates to opsx:* for changes and superpowers:test-driven-development for TDD; never reimplements them.
 ---
 
 # Construir un slice (épica EP-XXX) — Build
@@ -21,18 +21,22 @@ el avance en el estado.
 > **aquí** y ábrelo como épica.
 
 ## Principio de operación
-- **Una sola fuente de verdad**: `.claude/state/build-state.json` (schema + protocolo en
-  `.claude/state/README.md`). Lee antes de actuar; escribe una vez por transición.
+- **Una sola fuente de verdad, según el modo**: pregunta primero
+  `bash .claude/hooks/build/slice-ops.sh mode`. En `dual`/`runtime` el estado vive en el
+  **Agent Orchestrator Runtime** y toda transición pasa por `slice-ops.sh`
+  (`references/runtime-protocol.md`); en modo `legacy` la fuente es el fichero local
+  (`references/state-protocol.md`). Lee antes de actuar; una transición = una llamada.
 - **Secuencial**: un slice activo a la vez. Un gate no se salta.
 - **Divulgación progresiva**: carga el `references/<tema>.md` solo cuando la fase lo necesita.
 - **Delega en subagentes** para revisión pesada y para **explorar** (devuelven síntesis condensada,
   protegen el presupuesto de atención de la sesión principal para **cablear**, no para descubrir).
 - **Refresh de contexto = estado por defecto**: cada iteración nace **headless / contexto virgen** y
-  reconstruye el estado **desde disco** (git + `build-state.json` + logs), no desde la conversación
-  viva. Mantén el **`wiring_checklist[]`** (un item por escenario AC y por punto de integración entre
-  capas): nace `failing`, pasa a `passing` **solo tras prueba real ejecutada**. Deja una nota en
-  `progress_log[]` por hito. **Mientras quede un item `failing`, el slice NO está terminado.** Ver
-  `references/state-protocol.md`.
+  reconstruye el estado **desde disco** (git + `build-state.json` en modo legacy + logs), no desde la conversación
+  viva. Mantén el **checklist de cableado** (un item por escenario AC y por punto de integración
+  entre capas): nace `failing`, pasa a `passing` **solo tras prueba real ejecutada**
+  (`slice-ops.sh wiring update … --evidence-file`). Deja una nota por hito
+  (`slice-ops.sh progress`). **Mientras quede un item `failing`, el slice NO está terminado.**
+  Protocolo: `references/runtime-protocol.md` (modos `dual`/`runtime`).
 
 ## Dos loops
 
@@ -71,9 +75,10 @@ Los archivos `*.workflow.js` bajo `workflows/` son **plantillas de referencia**
 no scripts a correr verbatim (si contradicen `METODOLOGIA.md`, gana la metodología). Reglas duras:
 - **Opt-in y solo para épicas grandes.** Los workflows del inner loop solo aplican a épicas troceadas por el
   gate de tamaño (`sub_slices[]` no vacío); **nunca** en el camino caliente ≤ ~20 min de una épica atómica.
-- **Read-only sobre el estado.** Ningún workflow escribe `build-state.json`: devuelven un diagnóstico y
-  `build-orchestrator` (o el agente dueño del gate) aplica el mapeo respetando el protocolo (una transición =
-  una escritura; gates monótonos; **validar contra el schema tras escribir**).
+- **Read-only sobre el estado.** Ningún workflow transiciona el estado (ni por `slice-ops.sh` ni, en modo legacy,
+  escribiendo en `build-state.json`—legacy protocol—): devuelven un diagnóstico y `build-orchestrator` (o el agente dueño del gate)
+  aplica el mapeo respetando el protocolo (una transición = una escritura; gates monótonos; en legacy, validar contra
+  el schema tras escribir).
 - **Subagentes de exploración = solo-lectura** (Read/Grep/Glob); el cableado lo hace la sesión.
 
 Ver `workflows/README.md`. Hoy: `workflows/explore-fanout.workflow.js` (exploración fan-out) y
@@ -86,20 +91,22 @@ confirmado explícitamente**. El arnés **NO genera** el scaffold (es agnóstico
 **bloquea el avance** hasta confirmarlo. Es la precondición del primer slice; el *esqueleto que
 camina* se construye **encima** del scaffold ya existente.
 
-1. Lee `build-state.json`. Si `scaffold.confirmed` ya es `true` → continúa a la Fase 1 (dor).
+1. Consulta el hecho: `bash .claude/hooks/build/slice-ops.sh status` (campo `scaffold`). Si ya
+   está confirmado → continúa a la Fase 1 (dor).
 2. Si es `false` → **pregunta explícitamente** (AskUserQuestion): *"¿Existe un scaffold runnable del
    proyecto (arranca vacío: el script de build/dev corre sin error)?"*
    - **No** → **STOP**. Indica crearlo según el stack permitido (`.claude/config/stack-allowlist.json`
      / el PRD técnico). **No lo generes tú.** No abras el slice.
-   - **Sí** → registra en el estado `scaffold.confirmed=true` (con `confirmed_by`, `confirmed_at`,
-     `notes` — p.ej. "build/dev arranca vacío sin error") y continúa.
+   - **Sí** → reporta el hecho confirmado por la persona:
+     `slice-ops.sh fact scaffold-confirmed --by «quién» --notes «build/dev arranca vacío sin error»`
+     (en modo `legacy` el comando devuelve rc 3 y lo escribes en el fichero) y continúa.
 3. El gate lo valida también el `dor-dod-gatekeeper` (criterio duro de DoR) y lo respalda el hook
    determinista `scaffold-guard.sh` (bloquea escribir código de slice sin scaffold confirmado).
 
 ## Fase 0-bis · Fuente de diseño (seguro para slices con UI)
 
 Espejo de la Fase 0, para proyectos **con UI**. Antes de abrir el primer slice con UI:
-1. Lee `design_source` en `build-state.json`.
+1. Consulta la fuente de diseño con `slice-ops.sh status` (campo `design_source`).
    - `applies` indeterminado (ausente) → pregunta *"¿este proyecto tiene UI?"* y fija `applies`.
    - `applies === false` → N/A, salta esta fase.
    - `confirmed === true` → continúa.
@@ -108,7 +115,8 @@ Espejo de la Fase 0, para proyectos **con UI**. Antes de abrir el primer slice c
    - **No** → **STOP**. Ofrece dos salidas: **generarla con `/build:prototype`** (skill
      `prototyping-screens`; la confirmación sigue siendo humana) o declarar una fuente externa
      (ruta/URL del prototipo o export). No abras el slice con UI sin fuente confirmada.
-   - **Sí** → registra `design_source.source`, `confirmed=true`, `confirmed_by`, `confirmed_at`, `notes`.
+   - **Sí** → repórtalo:
+     `slice-ops.sh fact design-source --applies true --source «ruta/URL» --confirmed true --by «quién»`.
 3. Lo respalda el hook determinista `design-source-guard.sh` (bloquea código de slice UI sin fuente
    confirmada) y lo valida el `dor-dod-gatekeeper` (criterio duro de DoR).
 
@@ -121,7 +129,7 @@ Espejo de la Fase 0, para proyectos **con UI**. Antes de abrir el primer slice c
 | 3 · tdd | red → green → refactor | `superpowers:test-driven-development` | `tdd` | — |
 | 4 · smoke | Recorrer el journey-hasta-aquí end-to-end con el **runner determinista fuera-de-chat** (`integration-check`: suite+build+reporte) en **sesión/contexto virgen**; **slices con UI:** fidelidad por **verificación visual REAL** (MCP chrome-devtools, screenshot app vs prototipo) | runner `integration-check`, skill `verify`/`run` + MCP chrome-devtools, `ux-fidelity-reviewer` | `journey_smoke`,`fidelity` | `integration-check.md`, `mcp-map.md` |
 | 5 · api/data | contratos + consistencia (si aplican al slice) | `api-contract-tester`, `data-consistency-checker` | `api`,`data` | `newman-tests.md`, `data-consistency.md` |
-| 6 · dod | **Primero** verificación adversarial INDEPENDIENTE del cableado (contexto virgen: refuta stubs/rutas sin cablear/AC sin test/items `failing`) → `wiring_verified`; **solo entonces** Definition of Done | `wiring-adversarial-verifier`, `dor-dod-gatekeeper` | `wiring_verified`,`dod` | `dod.md`, `integration-check.md` |
+| 6 · dod | **Primero** verificación adversarial INDEPENDIENTE del cableado (contexto virgen: refuta stubs/rutas sin cablear/AC sin test/items `failing`) → `wiring_verified`; **solo entonces** Definition of Done. **Máximo 2 pasadas completas por slice** (condición de parada, ver abajo) | `wiring-adversarial-verifier`, `dor-dod-gatekeeper` | `wiring_verified`,`dod` | `dod.md`, `integration-check.md` |
 | 7 · pr | Abrir PR + archivar change en el mismo PR | `opsx:archive`, `opsx:sync` | — | `gitflow.md` |
 | 8 · release? | Preguntar si correr el Release Gate ahora | usuario (default computado) | — | abajo |
 
@@ -139,7 +147,26 @@ chrome-devtools** (screenshot app vs prototipo). Sin MCP, `fidelity` queda `fals
 pantalla del prototipo en alcance sin construir; ninguna pantalla de la app sin HU/EP) y el
 **journey-smoke de clic real como tenant no-admin**.
 
-MCP/LSP por gate: ver `references/mcp-map.md`. Protocolo de estado: `references/state-protocol.md`.
+**Condición de parada del bucle adversarial (fase dod): máximo 2 pasadas completas por slice.** Sin
+esta cota, tres reglas legítimas (sesgo «está incompleto», «nadie cierra sus propios gates» y el
+patrón medido de que los arreglos siembran hallazgos nuevos) se combinan en un bucle sin salida. La
+salida definida es esta y no depende de que alguien corte el bucle a mano:
+- **Pasada 1** completa; **pasada 2** incremental (solo items cuyo código cambió desde su
+  `verified_at_sha` + el diff de los arreglos y sus rutas gemelas).
+- Los hallazgos de la 2ª pasada que estén en **código nuevo del cierre** se arreglan y se cierran
+  con **mutación verificada** (re-ejecutar la evidencia del item afectado tras el fix) — **sin
+  tercera pasada**.
+- La revisión independiente restante se **difiere EXPLÍCITAMENTE al Release Gate**
+  (`releasing-a-version`), declarándolo en el PR del slice: los gates `wiring_verified`/`dod` se
+  cierran **honestos** (todo lo verificado, verificado; lo diferido, declarado — no es recorte en
+  silencio, lo custodia el gate que ya existe para eso).
+- **Excepción única**: un hallazgo ALTA en código **preexistente** durante la 2ª pasada habilita una
+  pasada extra **acotada a ese frente** (nunca una tercera pasada completa).
+
+MCP/LSP por gate: ver `references/mcp-map.md`. Protocolo de estado: **`references/runtime-protocol.md`**
+(modos `dual`/`runtime`, vía `slice-ops.sh`) o `references/state-protocol.md` (modo `legacy`).
+Presupuesto de mutación y anclaje de la evidencia (determinista vs viva): `references/evidence-budget.md`.
+¿Suite del destino con rojos heredados? Medición de regresión con baseline cacheado por sha: `references/regression-baseline.md` (script `assets/baseline-verdict.sh`).
 
 ## Fase 8 · ¿Release Gate ahora? (default computado, humano decide)
 
@@ -159,8 +186,9 @@ El usuario siempre puede sobreescribir el default. Si acepta, invoca la skill
    primero (pregunta explícita; STOP si no existe). Sin scaffold confirmado no se abre slice.
 2. Pregunta/identifica la **épica** objetivo (`EP-XXX` en `docs/03-backlog/epicas.md`) y reúne las
    **HU que cubre** (las que tienen `epica: EP-XXX` en `docs/04-historias/`) → poblarán `hus[]`.
-3. Lee `build-state.json`. Si hay `active_slice`, retoma su primer gate abierto; si es `null`,
-   arranca en **dor**.
+3. Reclama o retoma: `slice-ops.sh claim --epic EP-XXX` (rc 7 = sin trabajo; rc 3 = modo legacy o
+   dual, donde el slice lo decide el fichero). Luego `slice-ops.sh next-step` te dice dónde seguir;
+   si no hay slice, arranca en **dor**.
 4. Invoca al `build-orchestrator` para conducir el pipeline, o ejecuta fase a fase tú mismo
    respetando los gates.
 
@@ -178,9 +206,15 @@ El usuario siempre puede sobreescribir el default. Si acepta, invoca la skill
   generador y verificador produce auto-confirmación. La generación y la verificación van separadas.
   Opcionalmente, esa verificación se **conduce** con la plantilla read-only
   `workflows/wiring-verify.workflow.js` (envuelve al `wiring-adversarial-verifier`); `build-orchestrator`
-  sigue siendo quien **escribe** `gates.wiring_verified` a partir del veredicto que la plantilla devuelve.
+  sigue siendo quien **escribe** `gates.wiring_verified` a partir del veredicto que la plantilla devuelve
+  y quien **estampa** `verified_at_sha` en los items reproducidos. **Máximo 2 pasadas completas por
+  slice** (condición de parada de la fase dod, ver arriba); lo diferido se declara en el PR y lo
+  custodia el Release Gate.
 - **Producto completo, no MVP.** El alcance acordado se construye entero. **Recortar o diferir es
   bloqueante explícito** que requiere acuerdo del equipo — nunca una decisión del modelo. No derives
   en lo complejo. La verificación es **ejecutada, no por inspección** (ver `METODOLOGIA.md` y el
   bloque del arnés en `CLAUDE.md`).
+- **Todo acto de dominio pasa por `slice-ops.sh`**: nunca armes peticiones al runtime a mano ni
+  edites el fichero de estado en modo `runtime`. Un `rc 6` es la compuerta del servidor funcionando:
+  muestra su razón y corrige la causa, no lo reintentes.
 - Si una regla aquí contradice la metodología Trycore (`METODOLOGIA.md`), **gana la metodología**.

package/skills/building-a-slice/assets/baseline-verdict.sh

@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+# baseline-verdict.sh — veredicto de baseline cacheado por sha (skill building-a-slice).
+#
+# Responde «¿rompí algo?» en proyectos con tests rojos «ambientales» heredados SIN pagar
+# el ritual de worktree + suite ×2 en cada medición: cachea el conjunto de ficheros rojos
+# del baseline (origin/<destino>) en un JSON versionable por sha, y la medición de
+# regresión pasa a ser UNA corrida de la suite del working tree + comparación estilo comm.
+#
+# Uso:
+#   baseline-verdict.sh capture <ref>   # captura el veredicto del baseline en un worktree temporal
+#   baseline-verdict.sh compare <ref>   # corre la suite actual 1 vez y compara contra el cache
+#
+# <ref> DEBE ser un ref remoto (`origin/<rama>`) o un sha verificado como remoto
+# (`git branch -r --contains <sha>` no vacío). Los refs locales se RECHAZAN: comparar
+# contra un ref local obsoleto ya produjo una medición falsa (issue #30 del arnés).
+#
+# Parametrización (env), agnóstica del runner de tests:
+#   BASELINE_SUITE_CMD   comando de la suite (default: `npm test`; con vitest, p.ej.
+#                        `npx vitest run`). Puede salir ≠0 — los rojos son el dato, no un error.
+#   BASELINE_RED_FILTER  pipeline shell que lee la salida de la suite por stdin y emite un
+#                        fichero rojo por línea. Default (formato `FAIL <fichero> …`, como el
+#                        reporter de vitest): grep '^\s*FAIL\s' | awk '{print $2}' | sort -u
+#   BASELINE_DIR         dónde viven los JSON (default: `.baseline/` en la raíz del repo).
+#   BASELINE_LINK_DIRS   dirs a symlinkear de la raíz al worktree temporal en `capture`
+#                        (default: `node_modules`; separa con espacios; vacío = ninguno).
+#   BASELINE_NO_FETCH=1  no hacer `git fetch origin` antes de resolver el ref.
+#
+# Salidas: 0 sin regresiones · 1 regresiones nuevas · 2 uso/guard de ref · 3 cache
+# inválido o inexistente (re-captura) · 4 error de entorno (git/worktree/suite ilocalizable).
+set -uo pipefail
+
+SUITE_CMD="${BASELINE_SUITE_CMD:-npm test}"
+RED_FILTER="${BASELINE_RED_FILTER:-grep -E '^[[:space:]]*FAIL([[:space:]]|\$)' | awk '{print \$2}' | sort -u}"
+LINK_DIRS="${BASELINE_LINK_DIRS-node_modules}"
+
+usage() {
+  sed -n '2,29p' "$0" | sed 's/^# \{0,1\}//'
+}
+
+err() { echo "✗ $*" >&2; }
+info() { echo "▶ $*"; }
+
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || { err "no estamos dentro de un repo git"; exit 4; }
+cd "$ROOT" || exit 4
+BASE_DIR="${BASELINE_DIR:-$ROOT/.baseline}"
+
+CMD="${1:-}"; REF="${2:-}"
+case "$CMD" in
+  capture|compare) : ;;
+  -h|--help|help|"") usage; exit 2 ;;
+  *) err "subcomando desconocido: $CMD"; usage; exit 2 ;;
+esac
+[ -n "$REF" ] || { err "falta <ref> (p.ej. origin/main)"; exit 2; }
+
+# ── Guard de ref remoto ──────────────────────────────────────────────────────
+# Acepta SOLO `origin/...` o un sha contenido en alguna rama remota. Nunca refs
+# locales: `main` local puede estar detrás de `origin/main` y la medición sale falsa.
+if [ "${BASELINE_NO_FETCH:-0}" != 1 ]; then
+  git fetch --quiet origin 2>/dev/null || info "aviso: git fetch origin falló; sigo con los refs remotos ya conocidos"
+fi
+
+SHA=""
+if [[ "$REF" == origin/* ]]; then
+  SHA="$(git rev-parse --verify --quiet "refs/remotes/${REF}^{commit}")" \
+    || { err "el ref remoto '$REF' no existe (¿git fetch origin?)"; exit 2; }
+elif [[ "$REF" =~ ^[0-9a-f]{7,40}$ ]]; then
+  SHA="$(git rev-parse --verify --quiet "${REF}^{commit}")" \
+    || { err "el sha '$REF' no existe en este repo"; exit 2; }
+  if [ -z "$(git branch -r --contains "$SHA" 2>/dev/null)" ]; then
+    err "el sha '$REF' no está contenido en ninguna rama remota (git branch -r --contains vacío)."
+    err "GUARD: la comparación es SIEMPRE contra origin/<destino>, nunca contra un ref local"
+    err "(este error ya ocurrió y costó una medición falsa). Usa origin/<rama> o un sha ya pusheado."
+    exit 2
+  fi
+else
+  err "ref local rechazado: '$REF'."
+  err "GUARD: la comparación es SIEMPRE contra origin/<destino>, nunca contra un ref local"
+  err "(este error ya ocurrió y costó una medición falsa). Usa origin/<rama> o un sha remoto."
+  exit 2
+fi
+
+CACHE_FILE="$BASE_DIR/baseline-verdict.${SHA}.json"
+
+# ── Suite → conjunto ordenado de ficheros rojos ──────────────────────────────
+# Corre BASELINE_SUITE_CMD en $1 (dir), deja los rojos (uno por línea, sort -u) en $2.
+run_suite_red_files() {
+  local dir="$1" out="$2" raw
+  raw="$(mktemp)"
+  info "corriendo suite en $dir: $SUITE_CMD"
+  ( cd "$dir" && bash -c "$SUITE_CMD" ) >"$raw" 2>&1
+  local rc=$?
+  [ $rc -ne 0 ] && info "la suite salió con rc=$rc (esperable con rojos heredados)"
+  bash -c "$RED_FILTER" <"$raw" | LC_ALL=C sort -u >"$out"
+  rm -f "$raw"
+}
+
+# ─────────────────────────────────────────────────────────────────────────────
+if [ "$CMD" = capture ]; then
+  WT="$(mktemp -d)/baseline-wt"
+  cleanup() { git worktree remove --force "$WT" >/dev/null 2>&1; rm -rf "$(dirname "$WT")"; }
+  trap cleanup EXIT
+  git worktree add --quiet --detach "$WT" "$SHA" || { err "no pude crear el worktree temporal de $SHA"; exit 4; }
+  for d in $LINK_DIRS; do
+    [ -e "$ROOT/$d" ] && [ ! -e "$WT/$d" ] && ln -s "$ROOT/$d" "$WT/$d"
+  done
+
+  REDS="$(mktemp)"
+  run_suite_red_files "$WT" "$REDS"
+
+  mkdir -p "$BASE_DIR"
+  CAPTURED_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)" SHA="$SHA" REF="$REF" \
+  SUITE_CMD="$SUITE_CMD" RED_FILTER="$RED_FILTER" CACHE_FILE="$CACHE_FILE" \
+  python3 - "$REDS" <<'PY'
+import json, os, sys
+red = [l.rstrip("\n") for l in open(sys.argv[1]) if l.strip()]
+doc = {
+    "sha": os.environ["SHA"],
+    "ref": os.environ["REF"],
+    "captured_at": os.environ["CAPTURED_AT"],
+    "suite_cmd": os.environ["SUITE_CMD"],
+    "red_filter": os.environ["RED_FILTER"],
+    "red_files": sorted(red),
+}
+with open(os.environ["CACHE_FILE"], "w") as f:
+    json.dump(doc, f, ensure_ascii=False, indent=2)
+    f.write("\n")
+PY
+  [ $? -eq 0 ] || { err "no pude escribir el JSON del veredicto"; exit 4; }
+  N="$(grep -c . "$REDS" || true)"
+  rm -f "$REDS"
+  info "baseline capturado: $N fichero(s) rojo(s) en $REF @ $SHA"
+  info "veredicto: $CACHE_FILE (versiónalo en git si quieres compartirlo)"
+  exit 0
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# compare
+if [ ! -f "$CACHE_FILE" ]; then
+  err "no hay veredicto cacheado para $REF @ $SHA — el sha remoto cambió o nunca se capturó."
+  OLD="$(ls "$BASE_DIR"/baseline-verdict.*.json 2>/dev/null | head -3)"
+  [ -n "$OLD" ] && err "caches existentes (obsoletos para este sha): $(echo "$OLD" | tr '\n' ' ')"
+  err "re-captura con: bash ${0##*/} capture $REF"
+  exit 3
+fi
+
+BASE_REDS="$(mktemp)"; CUR_REDS="$(mktemp)"
+trap 'rm -f "$BASE_REDS" "$CUR_REDS"' EXIT
+python3 -c 'import json,sys; [print(f) for f in json.load(open(sys.argv[1]))["red_files"]]' \
+  "$CACHE_FILE" | LC_ALL=C sort -u >"$BASE_REDS" \
+  || { err "el cache $CACHE_FILE no es un veredicto válido; re-captura"; exit 3; }
+
+run_suite_red_files "$ROOT" "$CUR_REDS"
+
+NEW="$(LC_ALL=C comm -13 "$BASE_REDS" "$CUR_REDS")"   # rojo ahora, no estaba: REGRESIÓN
+FIXED="$(LC_ALL=C comm -23 "$BASE_REDS" "$CUR_REDS")" # estaba rojo, ya no: arreglado
+SAME="$(LC_ALL=C comm -12 "$BASE_REDS" "$CUR_REDS")"  # rojo en ambos: heredado sin cambio
+
+count() { [ -n "$1" ] && printf '%s\n' "$1" | grep -c . || echo 0; }
+echo ""
+echo "── veredicto vs $REF @ $SHA (capturado $(python3 -c 'import json,sys;print(json.load(open(sys.argv[1]))["captured_at"])' "$CACHE_FILE")) ──"
+echo "  regresiones nuevas : $(count "$NEW")"
+[ -n "$NEW" ] && printf '%s\n' "$NEW" | sed 's/^/    ✗ /'
+echo "  arreglados         : $(count "$FIXED")"
+[ -n "$FIXED" ] && printf '%s\n' "$FIXED" | sed 's/^/    ✓ /'
+echo "  heredados sin cambio: $(count "$SAME")"
+
+if [ -n "$NEW" ]; then
+  err "hay regresiones nuevas respecto del baseline $REF"
+  exit 1
+fi
+info "sin regresiones nuevas respecto del baseline $REF"
+exit 0

package/skills/building-a-slice/references/dod.md

@@ -1,7 +1,7 @@
 # Definition of Done (DoD) — checklist de salida **por slice** (inner loop)
 
 Un slice (épica) **no se archiva ni se mergea** hasta cumplir TODO esto. Lo valida
-`dor-dod-gatekeeper` leyendo los gates de `build-state.json`. Es el DoD **reducido**: las revisiones
+`dor-dod-gatekeeper` leyendo los gates del slice (`slice-ops.sh status`; en modo legacy, del fichero). Es el DoD **reducido**: las revisiones
 pesadas (seguridad, diseño, UX, coherencia triple, arquitectura, integración) **no** se piden aquí
 — se piden una vez por release en el **Release Gate** (`release-dod.md` de la skill
 `releasing-a-version`).
@@ -26,9 +26,18 @@ pesadas (seguridad, diseño, UX, coherencia triple, arquitectura, integración)
   duro de `dod`**: el DoD declarativo de este checklist es un **piso, no el arreglo** (la auto-confirmación
   surge de reusar el mismo agente como generador y verificador). Esa verificación puede conducirse,
   opcionalmente, con la plantilla read-only `../workflows/wiring-verify.workflow.js` (envuelve al verificador;
-  `build-orchestrator` es quien escribe el gate a partir de su veredicto).
+  `build-orchestrator` es quien escribe el gate a partir de su veredicto y estampa `verified_at_sha`
+  en los items cuya evidencia fue reproducida — las pasadas 2+ son **incrementales**: solo re-ejecutan
+  items cuyo código cambió desde su sha).
+  **Condición de parada: máximo 2 pasadas completas por slice.** Hallazgos de la 2ª pasada en código
+  nuevo del cierre → se arreglan y se cierran con **mutación verificada**, sin tercera pasada; la
+  revisión independiente restante se **difiere explícitamente al Release Gate** y se declara en el PR
+  (gates honestos, no recorte en silencio). Excepción: un hallazgo ALTA en código **preexistente**
+  durante la 2ª pasada habilita una pasada extra **acotada** a ese frente.
 - [ ] **OpenSpec**: todas las tasks `[x]`; el archive del change va **en el mismo PR** (no PR aparte).
-- [ ] **Docs/trazabilidad**: back-ref del change añadida en la épica y en cada HU de `hus[]`.
+- [ ] **Docs/trazabilidad**: back-ref del change añadida en la épica y en cada HU de `hus[]`. Si la
+  condición de parada del bucle adversarial aplicó, el **PR declara** qué revisión quedó diferida al
+  Release Gate.
 - [ ] **Hooks verdes (automáticos, no son gates de agente)**: `lint-typecheck.sh` (lint + chequeo de tipos del stack declarado), `stack-guard.sh` (deps en allowlist según la sección de requisitos técnicos del PRD del consumidor, ruta declarada en `stack-allowlist.json#source`), `gitflow-guard.sh` (rama `feature/*`, sin commits directos a `main`).
 
 **Todo ✓** → `gates.dod: true`; se hace `opsx:archive` + se abre/mergea el PR. **Algo ✗** → listar

package/skills/building-a-slice/references/dor.md

@@ -11,7 +11,7 @@ la épica; lo de abajo aplica a la épica y a **cada HU** que cubre (`hus[]`). L
 - [ ] **Dependencias resueltas**: las épicas/HU de las que depende están archivadas (`history[]`) o explícitamente no bloquean. **Excepción dura — cimiento:** si la dependencia es **infraestructura fundacional** (autenticación, acceso a datos, arquitectura base, design-system/componentes base), la cláusula "explícitamente no bloquean" **NO aplica**: debe estar **construida y archivada** antes (ver criterio "Cimiento construido").
 - [ ] **Cimiento construido (épicas de negocio)**: si esta épica es `layer: business`, todo el cimiento que arrastra (auth, acceso a datos, arquitectura base, design-system/componentes base) ya existe como épica(s) `layer: foundational` **archivada(s)** en `history[]`. Si arrastra cimiento no construido → **STOP**: extráelo a una épica fundacional previa y constrúyela primero. Las épicas fundacionales se priorizan **antes** que las de negocio.
 - [ ] **Caparazón construido (solo greenfield — gate PROACTIVO)**: si `project_kind === "greenfield"`
-  y `foundation.required === true` en `build-state.json`, ninguna épica `layer: business` entra a
+  y `foundation.required === true` en los hechos de proyecto del runtime (`slice-ops.sh status`; en modo legacy, `build-state.json`), ninguna épica `layer: business` entra a
   construcción mientras la épica caparazón (`foundation.epic`) no esté **archivada con su checklist
   evidenciada** (`foundation.completed_at` estampado). Las épicas `layer: foundational` (la
   caparazón `foundation.epic` u otras fundacionales) sí pueden abrir. A diferencia de "Cimiento
@@ -40,7 +40,8 @@ la épica; lo de abajo aplica a la épica y a **cada HU** que cubre (`hus[]`). L
 - [ ] **Clasificación `layer`**: `foundational` (auth/datos/design-system/arquitectura base) | `business`. Se escribe en `active_slice.layer`. Gatea el front paralelo (foundational nunca en paralelo).
 - [ ] **`files_scope`**: globs de los archivos que la épica tocará (p.ej. `src/reports/**`). Fuente de la disjunción inter-épica. Se escribe en `active_slice.files_scope`.
 
-**Si todo ✓** → `dor-dod-gatekeeper` abre `active_slice` en `build-state.json` con `epica`, `hus[]`,
+**Si todo ✓** → el slice se abre por el claim del runtime (`slice-ops.sh claim --epic EP-XXX`), que
+devuelve `slice_id`, épica, historias,
 `phase: dor`, `gates.dor: true` y el resto en `false` —incluido **`wiring_verified: false`**—
 (`fidelity`/`api` en `null` si la épica no toca UI/endpoints; `fidelity` arranca en `false` si toca UI).
 **Si algo ✗** → no se abre el slice; se reporta qué falta y se vuelve a discovery (Trycore).

package/skills/building-a-slice/references/evidence-budget.md

@@ -0,0 +1,51 @@
+# Presupuesto de mutación y clases de evidencia — inner loop (fase tdd→dod)
+
+> **Si una regla aquí contradice la metodología Trycore (`METODOLOGIA.md`), gana la metodología.**
+
+Estas reglas acotan **dónde rinde el rigor** del inner loop sin bajarlo donde importa. Aplican a la
+construcción de slices (fase tdd→dod de `building-a-slice`). El carril `building-a-micro-change`
+está **exento** (ver su SKILL.md): allí basta 1 test de regresión si cambia comportamiento + la
+suite del módulo tocado en verde.
+
+## Presupuesto de mutación
+
+La regla «un test no vale hasta que su mutación lo tumba» nació de un patrón real (tests-teatro:
+fixtures irreales, comparaciones vacuas, skips que siempre saltan) y **no se elimina — se acota**:
+
+- **Obligatoria** para los tests que sostienen un item de `wiring_checklist[]` (escenarios AC de HU,
+  puntos de integración entre capas): son los que **compran el veredicto del gate**. La evidencia de
+  un item del checklist sigue exigiendo la mutación que lo demuestra — manual o por reporte
+  automatizado.
+- **Opcional** para tests auxiliares de helpers/unidades internas. Recomendada solo si ese test es
+  la **única defensa de un invariante**; en el resto, la suite en verde basta.
+
+### Vía automatizada (alternativa al ciclo manual)
+
+El ciclo manual — editar producción → correr la suite → revertir, N veces — puede sustituirse por
+**una corrida de testing por mutación acotada a los ficheros cambiados del slice** (la herramienta
+la aporta el stack del consumidor; p. ej. Stryker en stacks JS/TS, con `--mutate` restringido al
+diff). El **reporte** de esa corrida es la evidencia: cada mutante sobreviviente en un fichero que
+sostiene un item del checklist es un hueco a cerrar. El arnés no impone ni configura la herramienta;
+si el stack no tiene una, el ciclo manual sigue valiendo — pero solo dentro del presupuesto de
+arriba.
+
+## Dos clases de evidencia y su anclaje
+
+Todo artefacto de evidencia declara `{sha, hora, rama}`. Lo que cambia entre clases es **a qué sha
+se ancla** y **cuándo caduca**:
+
+| Clase | Qué es | Ancla | Caduca cuando |
+|---|---|---|---|
+| **Determinista** | Runners sin LLM: suites, smoke, contratos | **HEAD** (se re-ancla siempre) | HEAD se mueve (regenerar cuesta segundos) |
+| **Viva** | Corridas contra el **LLM real del proyecto** | **Último commit que tocó el módulo bajo medición** | Cambió el código que mide — y solo entonces |
+
+Para la evidencia **viva**:
+
+- El ancla se obtiene con `git log -1 --format=%H -- <rutas del módulo>`. Un commit de docs, de
+  estado o de **otro** módulo **no la invalida**.
+- El artefacto declara ambos valores:
+  - `anchored_at.sha` — el sha del módulo (**normativo**: contra este se valida el anclaje).
+  - `head_at_run` — HEAD al momento de la corrida (**informativo**).
+- **Regenerar solo cuando cambió el código que mide** (el sha del módulo se movió). Re-anclar por
+  commits ajenos al módulo es la cinta de correr que esta regla elimina: cada regeneración mueve
+  HEAD y fabrica el "hallazgo" de la pasada siguiente.

package/skills/building-a-slice/references/exploration-fanout.md

@@ -13,7 +13,7 @@ profundo" puede repartirse con subagentes **solo-lectura por área** (frontend/b
 
 ## Blindaje read-only de cada subagente de área (al nivel de los reviewers pesados)
 - **Solo-lectura sobre código y estado**: el prompt de cada subagente declara *"NO editas código ni
-  `build-state.json`; tu única salida es la síntesis"* y **rechaza** cualquier instrucción de escribir.
+  el estado del slice; tu única salida es la síntesis"* y **rechaza** cualquier instrucción de escribir.
 - **Tools restringidas**: `Read`/`Grep`/`Glob` (sin `Edit`/`Write`/`Bash`-mutante). Opcionalmente, el tipo
   de agente built-in `Explore` (read-only).
 - **Fail-closed**: si un subagente devuelve algo que no sea síntesis (p.ej. un diff), se **descarta y se

package/skills/building-a-slice/references/gitflow.md

@@ -8,7 +8,7 @@ de forma determinista (bloquea commit/push directo a `main` y ramas no tipadas).
 ```bash
 git switch main && git pull --ff-only          # parte de main al día
 git switch -c feature/<slug>                    # rama tipada: feature/* | fix/* | chore/*
-# ... TDD + gates (estado en build-state.json) ...
+# ... TDD + gates (se reportan con slice-ops.sh gate) ...
 git add -A && git commit -m "<tipo>: <mensaje>" # commit en la rama feature (nunca en main)
 git push -u origin feature/<slug>               # push de la rama feature (nunca a main)
 gh pr create --base main --head feature/<slug> --fill   # integración por PR

package/skills/building-a-slice/references/regression-baseline.md

@@ -0,0 +1,67 @@
+# Baseline de regresión — «¿rompí algo?» con tests rojos heredados
+
+Cómo medir regresión de un slice cuando la suite del destino **no está verde** por tests rojos
+«ambientales» heredados. Sin esto, la pregunta «¿rompí algo?» exige el ritual completo (worktree
+del destino + suite ×2 + comparar conjuntos de rojos) en **cada** medición — un impuesto de
+~35 min que paga todo slice. Si algo aquí contradice `METODOLOGIA.md`, **gana la metodología**.
+
+## Dos vías (no excluyentes)
+
+1. **La buena — suite verde.** Sanear o cuarentenar los rojos heredados (skip anotado con su
+   issue, o arreglo) hasta que la suite del destino esté verde. Entonces «¿rompí algo?» vuelve a
+   ser **una** corrida normal y esta referencia deja de aplicar. Es **trabajo del proyecto
+   consumidor** (sus suites, sus issues): el arnés no lo hace por él, pero es el estado objetivo.
+2. **La pragmática — baseline cacheado por sha** (mientras la suite no esté verde). El veredicto
+   del baseline (el conjunto de ficheros rojos de `origin/<destino>`) se captura **una vez** y se
+   cachea en un JSON versionable (`baseline-verdict.<sha>.json`). La medición de regresión de un
+   slice pasa a ser: **1 corrida de la suite del working tree + comparación estilo `comm`** contra
+   el JSON. Ni worktree ni segunda suite por medición.
+
+## El script: `assets/baseline-verdict.sh`
+
+Bash portable (macOS/Linux), agnóstico del runner de tests. En el consumidor queda instalado en
+`.claude/skills/building-a-slice/assets/baseline-verdict.sh`.
+
+```bash
+# 1) capturar el baseline (una vez por sha del destino; ~el coste del ritual, pagado UNA vez)
+bash .claude/skills/building-a-slice/assets/baseline-verdict.sh capture origin/main
+
+# 2) medir regresión del slice (cada vez que haga falta; 1 corrida de suite)
+bash .claude/skills/building-a-slice/assets/baseline-verdict.sh compare origin/main
+```
+
+- `capture <ref>` corre la suite del sha remoto en un **worktree temporal** (symlinkeando
+  `node_modules` por defecto, `BASELINE_LINK_DIRS`) y escribe
+  `.baseline/baseline-verdict.<sha>.json` con el conjunto ordenado de ficheros rojos +
+  metadatos (`captured_at`, `suite_cmd`, `red_filter`). Versiona el JSON en git si quieres que
+  todo el equipo/agente reuse la captura.
+- `compare <ref>` corre la suite del working tree **una vez** y reporta tres conjuntos:
+  **regresiones nuevas** (rojo que no estaba en el baseline → sale con rc 1), **arreglados** y
+  **heredados sin cambio** (no cuentan como regresión). **Invalidación automática**: si el sha de
+  `origin/<destino>` ya no coincide con ningún cache, lo dice y pide re-capturar (rc 3).
+
+### Parametrización (agnóstica del runner)
+
+| Variable | Default | Qué es |
+|---|---|---|
+| `BASELINE_SUITE_CMD` | `npm test` | Comando de la suite. Con vitest, p.ej. `npx vitest run`. Puede salir ≠0 (los rojos son el dato). |
+| `BASELINE_RED_FILTER` | `grep -E '^[[:space:]]*FAIL([[:space:]]\|$)' \| awk '{print $2}' \| sort -u` | Pipeline shell que lee la salida de la suite y emite un fichero rojo por línea (el default entiende el formato `FAIL <fichero> …` de reporters tipo vitest; ajústalo a tu runner). |
+| `BASELINE_DIR` | `.baseline/` en la raíz | Dónde viven los JSON de veredicto. |
+| `BASELINE_LINK_DIRS` | `node_modules` | Dirs de la raíz a symlinkear en el worktree de `capture`. |
+| `BASELINE_NO_FETCH=1` | — | No hacer `git fetch origin` antes de resolver el ref. |
+
+## Guard: siempre contra `origin/<destino>`, nunca un ref local
+
+El script **rechaza refs locales** (rc 2): solo acepta `origin/<rama>` o un sha verificado como
+remoto (`git branch -r --contains <sha>` no vacío). Comparar contra la rama local (que puede ir
+detrás del remoto) **ya produjo una medición falsa** que costó un hallazgo ALTA corregir — el
+guard no es negociable y no se puentea editando el JSON a mano.
+
+## Cuándo usar cada cosa
+
+- Suite del destino **verde** → ni cache ni ritual: una corrida normal (esta referencia N/A).
+- Suite del destino **con rojos heredados** → `compare` contra el cache en cada medición del
+  slice; `capture` solo cuando el destino avanza (el propio `compare` avisa con rc 3).
+- El cache **no sustituye** los gates del pipeline (`tdd`, `journey_smoke`, `wiring_verified`):
+  solo abarata la pregunta «¿introduje regresiones respecto del destino?». Y cada slice es una
+  oportunidad de mover rojos heredados a la vía buena (arreglar o cuarentenar con issue).