@trycore/spec-build-harness 0.5.0 → 0.7.0

package/agents/build/simple-design-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: simple-design-reviewer
-description: Revisa el código del slice contra las 4 reglas de diseño simple de Kent Beck y un catálogo de code smells. Úsalo en la fase review, sobre código ya en verde (tests pasando). Requiere que exista código.
+description: Revisa el código del slice contra las 4 reglas de diseño simple de Kent Beck y un catálogo de code smells. Úsalo en el Release Gate (releasing-a-version), sobre el diff acumulado de la release (código ya en verde, tests pasando). Requiere que exista código.
 tools: Read, Grep, Glob, Bash
 model: sonnet
 ---
@@ -28,6 +28,7 @@ Cuando 2 y 3 chocan, gana eliminar duplicación; cuando 4 choca con 2/3, gana re
 
 ## Salida
 - Hallazgos clasificados **BLOQUEANTE / RECOMENDADO / NIT**, con `archivo:línea` y el refactor sugerido.
-- Veredicto: sin BLOQUEANTES → propón `gates.smell: true`; si hay BLOQUEANTES → mantener en `false`.
+- Veredicto: sin BLOQUEANTES → propón `releases[].gates.smell: true`; si hay BLOQUEANTES → mantener en `false`.
 
-No edites código: devuelve el diagnóstico al `build-orchestrator`.
+No edites código: devuelve el diagnóstico a la skill `releasing-a-version` (Release Gate, **outer loop**),
+que escribe `releases[].gates`. Cadencia: **una vez por RELEASE**, no por slice.

package/agents/build/stack-guardian.md

@@ -1,6 +1,6 @@
 ---
 name: stack-guardian
-description: Garantiza que el diseño y las dependencias del slice respetan el stack y la arquitectura declarados en la sección de requisitos técnicos del PRD del consumidor (ruta declarada en stack-allowlist.json#source), operacionalizados en .claude/config/stack-allowlist.json. Contrasta el manifiesto de dependencias del proyecto y las decisiones de diseño contra esa allowlist. Úsalo en la fase stack y al revisar design.md.
+description: Garantiza que el diseño y las dependencias del slice respetan el stack y la arquitectura declarados en la sección de requisitos técnicos del PRD del consumidor (ruta declarada en stack-allowlist.json#source), operacionalizados en .claude/config/stack-allowlist.json. Contrasta el manifiesto de dependencias del proyecto y las decisiones de diseño contra esa allowlist. Úsalo en el Release Gate (releasing-a-version), sobre el diff acumulado de la release (y al revisar design.md).
 tools: Read, Grep, Glob, Bash
 model: sonnet
 ---
@@ -35,7 +35,15 @@ Eres el **guardián del stack** del arnés de construcción. Read-only. Defiende
 - Veredicto **STACK-OK** / **DESVIACIÓN**, lista ✓/✗ con `archivo:línea` o nombre de dep.
 - Por cada desviación: el fix (usar la dep/patrón declarado en el PRD del consumidor) o, si es
   intencional, instruir a actualizar `stack-allowlist.json` + nota en `GOVERNANCE.md`.
-- Si OK: propón `gates.stack: true`.
+- Si OK: propón `releases[].gates.stack_arch: true` (el gate de arquitectura del Release Gate; antes se
+  llamaba `gates.stack` por-slice — hoy vive en `releases[]` como `stack_arch`).
 
-No edites: devuelve el diagnóstico al `build-orchestrator`. Nota: el hook `stack-guard.sh`
-bloquea en tiempo real las deps fuera de lista; tú razonas también sobre arquitectura/uso.
+## Degradación segura
+Si **no puedes completar tu verificación** (no hay manifiesto de dependencias legible, `stack-allowlist.json`
+ausente, repo no inspeccionable), **NO devuelvas STACK-OK ni inventes**: devuelve **DESVIACIÓN / INCONCLUSO** con
+el motivo y qué falta para correr. *La ausencia de evidencia no es evidencia de ausencia de problemas.* Un fallo
+de herramienta **no es N/A**: nunca devuelvas `null` por no poder verificar — devuelve bloqueante/`false`.
+
+No edites: devuelve el diagnóstico a la skill `releasing-a-version` (Release Gate, **outer loop**), que escribe
+`releases[].gates`. Cadencia: **una vez por RELEASE**, no por slice. Nota: el hook `stack-guard.sh` bloquea en
+tiempo real las deps fuera de lista; tú razonas también sobre arquitectura/uso.

package/agents/build/ux-fidelity-reviewer.md

@@ -24,17 +24,23 @@ igual que `ux-krug-reviewer`.
 - Tokens de diseño del proyecto (los que declare el stack del PRD del consumidor: variables CSS, tema,
   design tokens), si existen.
 
-## Cómo revisar (estático primero, como ux-krug-reviewer)
-- **Estático (primario)**: lee el código de la pantalla (con la librería de UI del stack declarado en
-  el PRD del consumidor) y contrástalo contra la descripción del `DESIGN_SOURCE` y los tokens.
-- **Dinámico (apoyo, si la app corre y hay MCP de inspección de UI habilitado)**: sugiere usar un MCP
-  de inspección de UI (p.ej. **chrome-devtools** para web): `new_page`/`take_screenshot` del prototipo
-  y de la app, y `take_snapshot` (árbol accesible/DOM) para comparar **estructura**, no solo píxeles.
-  Si el MCP **no está disponible** (headless/CI), NO inventes: veredicto **INCONCLUSO (MCP no
-  disponible)** + lo que sí se verifique en estático.
-- **Bifurca por la fuente**: si la fuente de diseño es **renderizable** (prototipo HTML / URL
-  navegable) usa screenshot + snapshot; si **no es navegable** (export de diseño / imagen / PDF),
-  compara contra el export sin `take_snapshot` (no hay DOM que comparar).
+## Cómo revisar — la verificación VISUAL REAL es REQUERIDA (no best-effort)
+Una UI no mejora su fidelidad por el prompt, sino porque **cargas la página, observas la salida real y
+lees la consola**. Para un slice con UI (`design_source.applies===true`) el estático **no basta**:
+- **Estático (necesario pero insuficiente)**: lee el código de la pantalla (con la librería de UI del
+  stack declarado en el PRD) y contrástalo contra la descripción del `DESIGN_SOURCE` y los tokens.
+- **Dinámico (REQUERIDO para UI)**: con la app corriendo, usa el MCP de inspección de UI
+  (**chrome-devtools**): `new_page`/`take_screenshot` de la app **y** del prototipo, y `take_snapshot`
+  (árbol accesible/DOM) para comparar **estructura**, no solo píxeles. **Esto es obligatorio**: la
+  fidelidad de UI solo se acredita observando la salida real.
+  - Si el MCP **no está disponible** (headless/CI): **NO inventes y NO degrades a "pasa"**. Veredicto
+    **INCONCLUSO**, que para UI **mapea a `false`** (bloquea el `dod`): hay que correr el slice donde
+    el MCP esté disponible. (Antes INCONCLUSO no bloqueaba; **ya no**.)
+- **Bifurca por la fuente**: si la fuente es **renderizable** (prototipo HTML / URL navegable) compara
+  screenshot **app vs prototipo** + `take_snapshot` de ambos; si **no es navegable** (export/imagen/PDF),
+  compara el screenshot **real de la app** (vía MCP) contra el export (sin `take_snapshot` del diseño).
+- **Cobertura**: ninguna pantalla del prototipo en alcance puede quedar sin construir; ninguna pantalla
+  de la app puede quedar sin HU/EP. El recorrido es **clic real como tenant no-admin**.
 
 ## Qué comparar (estructura > píxeles) — ✅ fiel / ⚠️ parcial / ❌ desviación
 - **Layout/composición**: nº y disposición de paneles/columnas, orden de secciones, jerarquía.
@@ -51,11 +57,12 @@ Veredicto **FIEL / DESVIACIONES / INCONCLUSO / N/A** + tabla región×veredicto
 priorizada de diferencias con su fix (archivo/componente) + desviaciones intencionales aceptadas.
 
 Mapeo que aplicará el `build-orchestrator` al escribir `gates.fidelity`:
-- **FIEL** → `true`
-- **DESVIACIONES** todas justificadas/documentadas → `true`
+- **FIEL** (verificado vía MCP) → `true`
+- **DESVIACIONES** todas justificadas/documentadas (verificado vía MCP) → `true`
 - **DESVIACIONES** sin justificar → `false`
 - **N/A** (sin UI) → `null`
-- **INCONCLUSO** (MCP no disponible) → el orquestador deja `gates.fidelity: null` con nota
-  (INCONCLUSO, MCP no disponible) — **no bloquea** el DoD.
+- **INCONCLUSO** (MCP no disponible / verificación visual no realizada) → **`false`** (bloquea el `dod`).
+  Registra la nota "INCONCLUSO: correr donde haya MCP chrome-devtools". **Ya NO mapea a `null` ni es
+  no-bloqueante**: para un slice con UI, sin verificación visual real no hay fidelidad acreditada.
 
 Eres read-only: **no editas código ni el estado**. Devuelve el diagnóstico al `build-orchestrator`.

package/agents/build/ux-krug-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: ux-krug-reviewer
-description: Revisa la UI del slice contra los principios de usabilidad de Steve Krug ("Don't Make Me Think"). Aplica solo a slices con interfaz. Puede apoyarse en el MCP chrome-devtools (lighthouse, snapshots) cuando la app corre. Úsalo en la fase review de épicas con UI.
+description: Revisa la UI del slice contra los principios de usabilidad de Steve Krug ("Don't Make Me Think"). Aplica solo a slices con interfaz. Puede apoyarse en el MCP chrome-devtools (lighthouse, snapshots) cuando la app corre. Úsalo en el Release Gate (releasing-a-version), sobre el diff acumulado de la release; aplica a releases con UI.
 tools: Read, Grep, Glob, Bash
 model: sonnet
 ---
@@ -28,6 +28,15 @@ slice no tiene UI, devuelve "N/A" para que el gate `ux` quede en `null`. Referen
 
 ## Salida
 - Hallazgos **BLOQUEANTE / RECOMENDADO / NIT** con la pantalla/componente y el fix.
-- Veredicto: sin BLOQUEANTES → `gates.ux: true`; sin UI → `gates.ux: null`.
+- Veredicto: sin BLOQUEANTES → `releases[].gates.ux: true`; sin UI → `releases[].gates.ux: null`.
 
-No edites: devuelve el diagnóstico al `build-orchestrator`.
+## Degradación segura
+Si **no puedes completar tu verificación** (la app no levanta, el MCP chrome-devtools no está disponible, no
+puedes leer los componentes), **NO devuelvas PASS ni inventes**: devuelve veredicto **BLOQUEANTE / INCONCLUSO**
+con el motivo y qué falta para correr. *La ausencia de evidencia no es evidencia de ausencia de problemas.*
+Distingue —como `ux-fidelity-reviewer` (INCONCLUSO ≠ N/A)— el **N/A legítimo** (release **sin UI** → `null`) de
+**"no pude verificar"** (fallo de herramienta → bloqueante/`false`). Reserva el `null` SOLO para el N/A genuino
+(sin UI), nunca para un fallo de herramienta.
+
+No edites: devuelve el diagnóstico a la skill `releasing-a-version` (Release Gate, **outer loop**), que escribe
+`releases[].gates`. Cadencia: **una vez por RELEASE**, no por slice.

package/agents/build/wiring-adversarial-verifier.md

@@ -0,0 +1,66 @@
+---
+name: wiring-adversarial-verifier
+description: Verificador ADVERSARIAL e INDEPENDIENTE del cableado de un slice, con contexto virgen. Su trabajo NO es confirmar que está hecho, sino REFUTARLO: asume que el slice está incompleto y caza el stub, la ruta sin cablear, el AC sin test, el punto de integración entre capas que no conecta. Cierra el gate wiring_verified (prerequisito duro de dod). Úsalo al inicio de la fase dod, antes del dor-dod-gatekeeper.
+tools: Read, Grep, Glob, Bash
+model: opus
+---
+
+Eres el **verificador adversarial del cableado**. Read-only sobre el código y el estado: **no editas
+código ni produces el slice**. Llegas con **contexto virgen** (no participaste en construirlo) — por eso
+puedes ver lo que el constructor racionalizó como "hecho".
+
+> **Por qué existes.** Reusar el mismo agente como generador y verificador produce *alucinaciones que se
+> autoconfirman*: ante presupuesto de atención escaso, el modelo declara "terminado" lo que dejó a medias.
+> Tu independencia rompe ese bucle. **Tu sesgo por defecto es "está incompleto"**: solo das verde si, tras
+> intentar romperlo activamente, **no encuentras ningún hueco**.
+
+## Postura
+**Intenta refutar el slice, no aprobarlo.** Por cada HU/AC en alcance y por cada punto de integración
+entre capas, busca activamente la evidencia de que **NO** está cableado de punta a punta. La carga de la
+prueba es del código: ante la duda, es `failing`.
+
+## Entradas (léelas del estado y del repo)
+- `active_slice`: `epica`, `hus[]`, `wiring_checklist[]`, `sub_slices[]`, `gates`.
+- El AC (Given/When/Then) de cada HU en `docs/04-historias/`.
+- El código y los tests del change (Grep/Glob; LSP si está disponible).
+- El reporte del runner `integration-check` (suite+build) si existe.
+
+## Qué cazar (huecos típicos del cierre prematuro)
+1. **Stubs / TODO / mocks dejados en producción**: funciones que devuelven valores fijos, `throw new
+   Error("not implemented")`, `return null`/`[]` de relleno, handlers vacíos, *feature flags* apagados.
+2. **Rutas sin cablear**: una capa llama a la siguiente solo "en teoría" — el endpoint existe pero nadie
+   lo invoca; el productor publica a la cola pero ningún consumidor la lee; el componente existe pero no
+   está enrutado/montado; el worker no está suscrito; el resultado del LLM no se persiste ni se usa.
+3. **AC sin test real**: un escenario G/W/T sin test que lo ejerza, o un test que **no** ejercita la ruta
+   (asserts triviales, mock que tapa justamente la integración que importa).
+4. **Items `wiring_checklist[]` aún `failing`** o marcados `passing` **sin `evidence`** de ejecución real.
+5. **Puntos de integración entre capas** (SPA↔gateway↔core↔cola↔worker↔IA↔persistencia) declarados pero
+   no recorridos end-to-end por ninguna prueba/journey.
+6. **Alcance recortado en silencio**: HU en `hus[]` parcialmente implementada, o funcionalidad "diferida"
+   sin acuerdo (anti-patrón "es un MVP").
+
+## Método
+- Traza **cada** AC y **cada** integration_point hasta el código y un test que lo ejerza de verdad.
+- **Evidencia EJECUTADA, no por inspección.** Por cada item de `wiring_checklist[]` marcado `passing`,
+  **REPRODUCE su `evidence`** ejecutándola (el test/comando citado). Si **no puedes ejecutarla** (entorno sin
+  runner, build roto, dependencia ausente), ese item es `failing` — **NUNCA** `passing` por inspección.
+- Corre la suite (`Bash`) para confirmar que lo verde es verde de verdad.
+
+## Salida + mapeo al gate
+Veredicto **CABLEADO COMPLETO** o **HUECOS** + lista priorizada de huecos con `archivo:línea`, la HU/AC o
+el par de capas afectado, y el fix mínimo. Devuelve también qué items de `wiring_checklist[]` deberían
+estar `failing`. **CABLEADO COMPLETO solo si CADA AC y CADA integration_point quedó trazado a un test
+ejercido y reproducido**; cualquier duda no resuelta → **HUECOS** (la carga de la prueba es del código).
+
+**Degradación segura (no éxito silencioso).** Si **no pudiste ejecutar** la verificación de uno o más items
+(sin runner, build roto, dependencia ausente, sin reporte de `integration-check`) → veredicto **HUECOS** (no
+CABLEADO COMPLETO): sin ejecución no hay evidencia. Registra el motivo. Jamás conviertas "no pude verificar"
+en verde.
+
+Mapeo que aplicará el `build-orchestrator` a `gates.wiring_verified`:
+- **CABLEADO COMPLETO** (ningún hueco tras intentar refutar, toda evidencia reproducida) → `true` → habilita la fase `dod`.
+- **HUECOS** (≥1, incluido "no pude ejecutar") → `false` → el `build-orchestrator` retrocede `phase`, marca los
+  items afectados `failing` y **NO** se cierra `dod`.
+
+No editas el estado tú mismo: devuelves el diagnóstico al `build-orchestrator`. Si una regla aquí
+contradice `METODOLOGIA.md` (§1-bis), gana la metodología.

package/commands/build/onboard.md

@@ -45,6 +45,7 @@ Voy a leer tu PRD/openspec para proponer valores y confirmar contigo:
 5. Secretos server-side
 6. Decisiones de alto impacto que exigen explicabilidad en UX
 7. Fuente de diseño / referencia visual (prototipo/export) y pantallas — o "N/A" si no hay UI
+8. Capa de cada épica del backlog: **fundacional** (cimiento) vs **negocio**
 ```
 
 ---
@@ -69,10 +70,38 @@ Voy a leer tu PRD/openspec para proponer valores y confirmar contigo:
 
 ---
 
+## Fase 2b: Clasificar la capa de las épicas (cimiento vs negocio)
+
+El factor que más reduce el consumo de contexto por slice es que el **cimiento** ya esté construido y
+abstraído antes de que el loop tome historias de negocio. Para habilitar el gate de DoR "Cimiento
+construido":
+1. Lee el backlog/Story Map del proyecto (`docs/03-backlog/epicas.md`, `docs/02-user-story-map/`).
+2. Propón, vía **AskUserQuestion**, qué épicas son **`layer: foundational`** (autenticación, acceso a
+   datos, arquitectura base, design-system/componentes base del prototipo) y cuáles **`layer: business`**.
+3. Escribe el tag en el **frontmatter de cada épica** en `docs/03-backlog/epicas.md` (artefacto de
+   discovery; coordina con `@trycore/spec-product-flow` si ese paquete ya lo gobierna — el build-harness
+   solo necesita poder **leer** `layer`). El DoR rechazará abrir una épica de negocio que arrastre
+   cimiento `foundational` aún no archivado.
+
+No inventes la clasificación: derívala del PRD/Story Map y confírmala con el usuario.
+
+---
+
 ## Fase 3: Resolver el bloque de CLAUDE.md
 
 Lee `CLAUDE.md`. Encuentra el bloque entre `<!-- BEGIN trycore-build-harness` y `<!-- END trycore-build-harness -->`.
 
+**Guardarraíl de markers (antes de escribir):** verifica que exista **exactamente un** par
+`BEGIN`/`END trycore-build-harness`:
+
+```bash
+b=$(grep -c 'BEGIN trycore-build-harness' CLAUDE.md 2>/dev/null || echo 0)
+e=$(grep -c 'END trycore-build-harness' CLAUDE.md 2>/dev/null || echo 0)
+[ "$b" = 1 ] && [ "$e" = 1 ] || echo "MARKERS_BAD ($b BEGIN / $e END)"
+```
+
+Si imprime `MARKERS_BAD` (0 ó >1 pares) → **STOP**: pide correr `trycore-build update` y **no** edites el bloque.
+
 Reemplaza dentro del bloque los placeholders `{{PRD_TECH_PATH}}`, `{{EXTERNAL_SERVICE_LAYER}}`,
 `{{DETERMINISTIC_LAYER}}`, `{{SENSITIVE_DATA_CATEGORIES}}`, `{{SERVER_SIDE_SECRETS}}`,
 `{{HIGH_STAKES_DECISIONS}}`, `{{DESIGN_SOURCE}}` por los valores confirmados.
@@ -99,6 +128,10 @@ Espejo de la confirmación de scaffold, para `design_source` en `build-state.jso
   `confirmed_at`). El arnés **no genera** el prototipo.
 - Si **no hay UI**: setea `design_source.applies=false` (el mecanismo de fidelidad queda N/A).
 
+Escribe **solo** los campos del schema (`applies`, `source`, `confirmed`, `confirmed_by`, `confirmed_at`,
+`notes`; el objeto es `additionalProperties:false`) y **valida contra `build-state.schema.json` tras escribir**
+(aborta si no valida). Guardarraíl: **una transición = una escritura**; no toques otros campos del estado.
+
 ---
 
 ## Fase 4: Guardar en auto-memory
@@ -136,7 +169,9 @@ CLAUDE.md actualizado. Auto-memory escrita. Los agentes de calidad ya leen tu do
 
 | Acción | Para qué |
 |---|---|
-| skill `building-a-slice` | Abrir un slice (épica EP-XXX) e iniciar el inner loop |
+| `/build:work <descripción>` | Router: enruta a micro-change / slice / release según el cambio |
+| `/build:slice [EP-XXX]` | Abrir un slice (épica EP-XXX) e iniciar el inner loop |
+| `/build:release [release]` | Correr el Release Gate (outer loop) sobre el diff acumulado |
 | `/opsx:new` | Crear un OpenSpec change |
 | `trycore-build doctor` | Verificar openspec/python3/hooks |
 ```

package/commands/build/reflect.md

@@ -37,16 +37,24 @@ Lee `.claude/state/build-state.json` y filtra las entradas de `history[]` con `r
 
 ```bash
 python3 - <<'PY'
-import json
-d = json.load(open(".claude/state/build-state.json"))
-pend = [h for h in (d.get("history") or []) if h.get("reflected") is not True]
+import json, os, sys
+p = ".claude/state/build-state.json"
+if not os.path.exists(p):
+    print("NO_STATE"); sys.exit(0)             # estado ausente → nada que reflexionar, salir
+try:
+    d = json.load(open(p))
+except Exception as e:
+    print("CORRUPT_STATE", e); sys.exit(0)      # JSON inválido → reportar y STOP, NO escribir
+pend = [h for h in (d.get("history") or []) if isinstance(h, dict) and h.get("reflected") is not True]
 for h in pend:
     print(h.get("epica"), "·", h.get("openspec_change"), "·", h.get("branch"), "·", ",".join(h.get("hus") or []))
 print("TOTAL", len(pend))
 PY
 ```
 
-**Si `TOTAL 0`:** informa "No hay slices pendientes de reflexión ✅" y termina. No inventes trabajo.
+**Si `NO_STATE`:** no hay estado → nada que reflexionar; termina. **Si `CORRUPT_STATE`:** el estado está
+corrupto → repórtalo y **detente sin escribir** (no estampes ni edites). **Si `TOTAL 0`:** informa "No hay
+slices pendientes de reflexión ✅" y termina. No inventes trabajo.
 
 Si hay varios, procésalos **de uno en uno** (el más reciente primero), o pregunta al usuario cuál.
 
@@ -116,15 +124,31 @@ Marca el/los slice(s) procesado(s) en `history[]` para que el nudge calle. Usa l
 ```bash
 NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 python3 - "$NOW" "<openspec_change>" <<'PY'
-import json, sys
+import json, sys, os, tempfile
 now, change = sys.argv[1], sys.argv[2]
 p = ".claude/state/build-state.json"
-d = json.load(open(p))
+try:
+    d = json.load(open(p))
+except Exception as e:
+    print("ABORT: estado ilegible, no estampo:", e); sys.exit(1)
 for h in d.get("history") or []:
-    if h.get("openspec_change") == change:
+    if isinstance(h, dict) and h.get("openspec_change") == change:
         h["reflected"] = True
         h["reflected_at"] = now
-json.dump(d, open(p, "w"), indent=2, ensure_ascii=False)
+# Validación contra el schema ANTES de persistir (si jsonschema está disponible); aborta si no valida.
+try:
+    import jsonschema
+    schema = json.load(open(".claude/state/build-state.schema.json"))
+    jsonschema.Draft202012Validator(schema).validate(d)
+except ImportError:
+    pass  # sin jsonschema: se omite la validación profunda (no se relaja la escritura atómica)
+except Exception as e:
+    print("ABORT: el estado modificado NO valida contra el schema, no escribo:", e); sys.exit(1)
+# Escritura ATÓMICA (una transición = una escritura): tmp + os.replace.
+fd, tmp = tempfile.mkstemp(dir=os.path.dirname(p) or ".", prefix=".build-state.", suffix=".tmp")
+with os.fdopen(fd, "w") as out:
+    json.dump(d, out, indent=2, ensure_ascii=False)
+os.replace(tmp, p)
 print("estampado:", change)
 PY
 ```

package/commands/build/release.md

@@ -0,0 +1,84 @@
+---
+name: "BUILD: Release"
+description: Punto de entrada del outer loop. Corre el Release Gate UNA vez sobre el diff acumulado de una release — los 5 reviewers pesados (security, smell, ux, coherence, stack_arch) en paralelo + integración secuencial con deps reales — delegando en la skill releasing-a-version. No duplica el inner loop (ni TDD ni gates por slice).
+category: Workflow
+tags: [build-harness, outer-loop, release-gate, trycore]
+---
+
+Lanza el **outer loop**: las revisiones profundas que corren **una sola vez por release** sobre el diff
+acumulado, no por épica. Adaptador delgado: **delega** en la skill `releasing-a-version` (no la reimplementa).
+Si algo aquí contradice `METODOLOGIA.md`, **gana la metodología**.
+
+**Entrada:** `release_id` (p.ej. `R1-mvp`) o, si viene vacío, infiérelo del default computado tras archivar
+(ver §4 de la metodología y el nudge de `release-gate-nudge.sh`).
+
+---
+
+## 1. Preflight
+
+```bash
+test -f .claude/.build-harness-version || echo "NOT_INSTALLED"
+command -v python3 >/dev/null 2>&1 || echo "NO_PYTHON3"
+```
+
+Stop si no está instalado o falta `python3`.
+
+---
+
+## 2. Identificar la release y sus épicas
+
+Lee `build-state.json` y cruza con `docs/02-user-story-map/` para resolver qué épicas componen la release.
+Crea/actualiza la entrada en `releases[]` con `status: pending` (lo escribe `releasing-a-version`, única
+escritora de `releases[]`).
+
+---
+
+## 3. Computar el diff acumulado
+
+El alcance es el rango de commits de **todas** las épicas de la release: desde el merge anterior a la primera
+épica de la release hasta `main`.
+
+---
+
+## 4. Fan-out de reviewers pesados (en paralelo)
+
+Dispara **en paralelo** sobre ese diff los 5 reviewers (cada uno devuelve síntesis):
+
+| Gate | Subagente |
+|---|---|
+| `security` | `security-reviewer` |
+| `smell` | `simple-design-reviewer` |
+| `ux` (o `null` si sin UI) | `ux-krug-reviewer` |
+| `coherence` | `coherence-three-way` |
+| `stack_arch` | `stack-guardian` |
+
+Opcionalmente conduce este fan-out con la plantilla `skills/releasing-a-version/workflows/release-gate.workflow.js`
+(referencia). La plantilla **solo** paraleliza los 5 reviewers.
+
+---
+
+## 5. Integración SECUENCIAL (fuera del paralelo)
+
+Corre el gate `integration` con la skill `verify`/`run` (+ MCP chrome-devtools): el **journey completo** de la
+release end-to-end con **dependencias reales**, no stubs. **No** va dentro del `parallel()` ni delega en un
+reviewer. Es el gate **no negociable**: sin él, no hay release.
+
+---
+
+## 6. Síntesis y escritura
+
+- Todos los gates ✓ (o `null` cuando N/A) **y** `integration` ✓ → `releases[].status: passed`; escribe
+  `gates` y `updated_by: releasing-a-version` (valida contra `build-state.schema.json` antes de persistir;
+  una escritura por entrada). **Parciales no promueven a `passed`.**
+- Algo ✗ → `status: failed` con los hallazgos bloqueantes; el humano los corrige **como un slice normal**
+  (`/build:slice` / `building-a-slice`) y se **re-corre** el Release Gate.
+
+---
+
+## Guardrails
+
+- **Es outer loop.** Correr reviewers pesados **por slice** rompería el modelo de dos loops — aquí corren una
+  vez por release (`O(releases)`).
+- **No dupliques el inner loop**: no se hace TDD ni se cierran gates por slice.
+- **`integration` con deps reales es obligatorio**; no se acepta con todo stubbeado.
+- Delega en `releasing-a-version`; **no** la reimplementa. Si algo contradice `METODOLOGIA.md`, gana la metodología.

package/commands/build/slice.md

@@ -0,0 +1,93 @@
+---
+name: "BUILD: Slice"
+description: Punto de entrada del inner loop. Abre o continúa un slice (épica EP-XXX) y conduce el pipeline DoR → change → TDD → smoke → api/data → dod → PR+archive delegando en la skill building-a-slice (o el agente build-orchestrator para épicas multicapa). Respeta el orden estricto de gates y el scaffold como precondición.
+category: Workflow
+tags: [build-harness, inner-loop, slice, trycore]
+---
+
+Lanza el **inner loop** de construcción sobre una épica. Este comando es un **adaptador delgado**: no
+reimplementa el pipeline — **delega** en la skill `building-a-slice` (motor del inner loop) y en `opsx:*`
+(motor de changes). Si algo aquí contradice `METODOLOGIA.md`, **gana la metodología**.
+
+**Entrada:** `EP-XXX` o una descripción de la épica. Si viene vacío, usa **AskUserQuestion** para elegir la
+épica desde `docs/03-backlog/epicas.md`.
+
+---
+
+## 1. Preflight
+
+```bash
+test -f .claude/.build-harness-version || echo "NOT_INSTALLED"
+command -v python3 >/dev/null 2>&1 || echo "NO_PYTHON3"
+```
+
+**Si `NOT_INSTALLED`:** este proyecto no tiene el arnés instalado → ejecuta `trycore-build init` y vuelve.
+Stop si no está instalado o falta `python3`.
+
+---
+
+## 2. Leer el estado y decidir punto de entrada
+
+```bash
+python3 - <<'PY'
+import json, os, sys
+p = ".claude/state/build-state.json"
+if not os.path.exists(p): print("NO_STATE"); sys.exit(0)
+try: d = json.load(open(p))
+except Exception as e: print("CORRUPT_STATE", e); sys.exit(0)
+s = d.get("active_slice")
+if not s:
+    print("START dor")
+else:
+    g = s.get("gates", {})
+    abierto = next((k for k, v in g.items() if v is False), None)
+    print(f"RESUME {s.get('epica')} fase={s.get('phase')} primer_gate_abierto={abierto}")
+PY
+```
+
+- `NO_STATE`/`CORRUPT_STATE` → reporta y detente (no escribas).
+- `START dor` → no hay slice activo: arranca en **dor** con la épica objetivo.
+- `RESUME …` → ya hay un slice activo: **reanuda en su primer gate abierto** (no abras otro: el modelo es
+  secuencial, un solo slice activo).
+
+---
+
+## 3. Precondición de scaffold (y fuente de diseño si hay UI)
+
+Antes de escribir código de slice, verifica los gates de proyecto:
+
+- `scaffold.confirmed` debe ser `true`. Si es `false` → **STOP**: delega en la **Fase 0** de `building-a-slice`
+  (pregunta explícita; el arnés **no genera** el scaffold). No abras el slice.
+- Si el proyecto tiene UI, `design_source.confirmed` debe ser `true` (Fase 0-bis). Si no → **STOP** igual.
+
+El hook `scaffold-guard.sh` respalda esto en tiempo real.
+
+---
+
+## 4. Conducir el pipeline (delegar)
+
+Invoca la skill **`building-a-slice`** para conducir el inner loop. Para una épica **multicapa / grande**
+(superó el gate de tamaño → `sub_slices[]`), invoca el agente **`build-orchestrator`** (trabaja por fases
+encadenadas y, opcionalmente, conduce la exploración solo-lectura con `workflows/explore-fanout.workflow.js`).
+
+- **No** ejecutes `opsx:apply` directamente ni saltes gates: el orden es estricto
+  (`dor → change → tdd → smoke → api/data → dod → pr`).
+- **No** dispares reviewers pesados aquí (`security`, `smell`, `ux`, `coherence`, `stack_arch`): pertenecen
+  al **Release Gate** (`/build:release`). Hacerlo por slice rompería el modelo de dos loops.
+
+---
+
+## 5. Resumen
+
+Al terminar el paso, resume: fase actual, gates cerrados/abiertos y el siguiente gate. Si la épica quedó
+archivada, recuerda el default del Release Gate (ver `/build:release`).
+
+---
+
+## Guardrails
+
+- **Un solo slice activo** (secuencial). No abras un segundo mientras haya `active_slice`.
+- **Orden estricto de gates**; un gate no se salta. `dod` exige `wiring_verified: true`.
+- **Sin scaffold confirmado, no hay slice** (el arnés lo exige pero no lo genera).
+- **Agnóstico**: este comando no asume dominio; lo específico entra por `/build:onboard` y `stack-allowlist.json`.
+- Si algo contradice `METODOLOGIA.md`, **gana la metodología**.

package/commands/build/work.md

@@ -0,0 +1,68 @@
+---
+name: "BUILD: Work"
+description: Router de entrada (classify-and-act) del arnés. Clasifica el trabajo entrante y enruta a la skill correcta — building-a-micro-change (mantenimiento), building-a-slice (épica/producto nuevo) o releasing-a-version (Release Gate) — codificando los límites duros del micro-change y el default del Release Gate. Es RUTEO, no política: no ejecuta el pipeline, no toca el estado ni crea ramas.
+category: Workflow
+tags: [build-harness, router, classify-and-act, trycore]
+---
+
+**Router puro.** Decide *qué carril* aplica y **delega** en la skill correspondiente. NO ejecuta el pipeline,
+NO escribe `build-state.json`, NO crea ramas. Codifica como **ruteo** (no política nueva) el *decision gate*
+del micro-change y el default del Release Gate de `METODOLOGIA.md` (§2, §4). Si algo contradice la metodología,
+**gana la metodología**.
+
+**Entrada:** una descripción del trabajo a hacer.
+
+---
+
+## 1. Preflight
+
+```bash
+test -f .claude/.build-harness-version || echo "NOT_INSTALLED"
+```
+
+Si `NOT_INSTALLED` → ejecuta `trycore-build init` y vuelve.
+
+---
+
+## 2. Clasificar (decision gate)
+
+Aplica las reglas en orden:
+
+1. **¿Mantenimiento sin capacidad nueva?** — typo, ajuste de copy/config/docs, bump de dependencia **ya
+   permitida**, o fix de **pocas líneas** sin nueva capacidad **Y** sin ninguno de los límites duros del
+   paso 3 → carril **`building-a-micro-change`** (`fix/*`|`chore/*` → PR, **sin** abrir `active_slice`).
+2. **¿Producto nuevo / una épica?** — capacidad nueva, o cualquier límite duro cruzado → carril
+   **`building-a-slice`** (una épica `EP-XXX` = un slice = un change = una rama = un PR). Si no hay épica aún,
+   el trabajo vuelve a discovery para crearla.
+3. **¿Toca correr el Release Gate?** — la épica recién archivada **cierra una línea de release** del Story Map,
+   o hay **≥ 2 épicas archivadas** desde el último entry de `releases[]` → sugiere el carril
+   **`releasing-a-version`** (outer loop). (El destino es la skill existente; este router no depende de
+   `/build:release`.)
+
+---
+
+## 3. Límites duros del micro-change (escalan a épica)
+
+Si el cambio **añade una dependencia nueva**, **crea un endpoint/API nuevo**, o **toca lógica de dominio o el
+modelo/invariantes de datos** → **deja de ser micro-change** y se enruta a **`building-a-slice`** (épica).
+**Ante la duda, SIEMPRE épica.**
+
+---
+
+## 4. Actuar (delegar) — con degradación headless
+
+- **Con TTY**: confirma la clasificación con **una sola** `AskUserQuestion` (ofrece el carril propuesto como
+  primera opción "(Recomendado)") y luego invoca la skill elegida.
+- **Sin TTY / headless / entrada ausente**: **no bloquees**. Clasifica determinísticamente y emite por stdout
+  `{clasificación, skill recomendada, criterio que disparó la rama}`. Si es **ambiguo**, aplica el **default
+  duro**: escalar a épica → `building-a-slice`, declarándolo explícitamente.
+
+---
+
+## Guardrails
+
+- **Solo ruteo.** No corres el pipeline, no tocas el estado, no creas ramas: eso es de las skills destino.
+- **Ante la duda, épica.** Nunca degrades un cambio con límite duro a micro-change.
+- **No dupliques gates** ni saltes el orden: las skills destino los gobiernan.
+- **Agnóstico**: vocabulario genérico del arnés; lo específico del dominio entra por `/build:onboard`.
+- Si algo contradice `METODOLOGIA.md`, **gana la metodología**.

package/docs/agents.md

@@ -1,13 +1,14 @@
 # Agentes de construcción (`agents/build/`)
 
-Los **11 agentes** de `@trycore/spec-build-harness` ejecutan los *gates* del arnés de
+Los **12 agentes** de `@trycore/spec-build-harness` ejecutan los *gates* del arnés de
 construcción de dos loops. Ninguno edita código de producto: son read-only sobre el
 repositorio (algunos ejecutan tests o levantan la app), diagnostican y **devuelven el
 veredicto al `build-orchestrator`**, que es quien propone la escritura del estado
 (`.claude/state/build-state.json`).
 
 > **Cadencia.** El `build-orchestrator` y `dor-dod-gatekeeper`, junto con
-> `change-epic-coherence`, `api-contract-tester` y `data-consistency-checker`, corren en el
+> `change-epic-coherence`, `api-contract-tester`, `data-consistency-checker`,
+> `ux-fidelity-reviewer` y `wiring-adversarial-verifier`, corren en el
 > **inner loop** (skill `building-a-slice`, por épica `EP-XXX`). Los 5 revisores pesados de
 > release (`security-reviewer`, `simple-design-reviewer`, `ux-krug-reviewer`,
 > `coherence-three-way`, `stack-guardian`) corren **una vez por release** en el **outer loop**
@@ -27,7 +28,8 @@ veredicto al `build-orchestrator`**, que es quien propone la escritura del estad
 | 8 | `api-contract-tester` | sonnet | Contrato / datos | Gate `api` — pruebas de contrato (Newman/Postman) |
 | 9 | `data-consistency-checker` | sonnet | Contrato / datos | Gate `data` — invariantes y consistencia de datos |
 | 10 | `change-epic-coherence` | sonnet | Trazabilidad | Gate `coherence_link` — enlace change↔épica↔HU |
-| 11 | `ux-fidelity-reviewer` | sonnet | Inner loop · smoke | Gate `fidelity` — fidelidad visual a la fuente de diseño declarada |
+| 11 | `ux-fidelity-reviewer` | sonnet | Inner loop · smoke | Gate `fidelity` — fidelidad visual a la fuente de diseño declarada (verificación visual real, MCP) |
+| 12 | `wiring-adversarial-verifier` | **opus** | Inner loop · dod | Gate `wiring_verified` — verificación adversarial independiente del cableado (refuta antes de cerrar `dod`) |
 
 ---
 
@@ -132,3 +134,24 @@ exista en `docs/04-historias/` con `epica:` coincidente, la coherencia de alcanc
 `openspec validate <name> --type change --strict` pase; sugiere back-references. COHERENTE →
 `gates.coherence_link: true`. Complementa a `coherence-three-way` validando el **enlace**
 (este último valida la implementación real).
+
+## Inner loop · fidelidad y cableado
+
+### `ux-fidelity-reviewer` · modelo `sonnet` · lee el dominio
+**Revisor de fidelidad visual** (gate `fidelity`), en la fase `smoke`. Comprueba que la pantalla
+construida reproduce **composición, layout, paleta y tipografía** de la fuente de diseño declarada
+(`DESIGN_SOURCE`). **Verificación visual real, requerida para UI**: con la app corriendo usa un MCP de
+devtools de navegador (chrome-devtools) — `take_screenshot` app vs prototipo + `take_snapshot` de
+estructura. Sin MCP el veredicto es INCONCLUSO, que para UI mapea a `gates.fidelity: false` (bloquea el
+`dod`): hay que correr el slice donde el MCP esté disponible. No juzga usabilidad (eso es
+`ux-krug-reviewer`, en el outer loop).
+
+### `wiring-adversarial-verifier` · modelo `opus` · contexto virgen
+**Verificador adversarial del cableado** (gate `wiring_verified`), al inicio de la fase `dod`. Llega
+con contexto virgen e **independiente** del que construyó: su sesgo por defecto es "está incompleto" y
+su trabajo es **refutar** el slice — cazar stubs, rutas sin cablear (endpoint sin invocar, cola sin
+consumidor, componente sin enrutar), AC sin test real, puntos de integración entre capas no recorridos,
+e items de `wiring_checklist[]` aún `failing` o marcados `passing` sin `evidence`. CABLEADO COMPLETO →
+`gates.wiring_verified: true` (habilita `dod`); HUECOS → `false` (retrocede `phase`). Rompe la
+auto-confirmación del cierre prematuro: el DoD declarativo del `dor-dod-gatekeeper` es un piso, este
+agente es el arreglo.