@trycore/spec-build-harness 0.4.0 → 0.6.0

package/docs/hooks.md

@@ -1,12 +1,12 @@
 # Hooks del arnés de construcción
 
-Este documento describe los **8 hooks** que `@trycore/spec-build-harness` instala en el proyecto del consumidor. Todos viven en `hooks/build/` (un script bash por hook) y se cablean a los eventos de Claude Code mediante una **cadena de comando única**, idéntica en ambos canales de instalación.
+Este documento describe los **9 hooks** que `@trycore/spec-build-harness` instala en el proyecto del consumidor. Todos viven en `hooks/build/` (un script bash por hook) y se cablean a los eventos de Claude Code mediante una **cadena de comando única**, idéntica en ambos canales de instalación.
 
-Los hooks son el sistema nervioso del arnés: vigilan GitFlow, el stack declarado y el scaffold (bloqueantes), inyectan el estado del build al iniciar la sesión, delegan estilo/typecheck a herramientas, y recuerdan validar trazabilidad, gates abiertos y reflexionar al cerrar un slice. No reemplazan a los agentes ni a las skills; los **complementan** liberando capacidad de razonamiento del modelo y poniendo barandillas mecánicas donde un olvido cuesta caro.
+Los hooks son el sistema nervioso del arnés: vigilan GitFlow, el stack declarado, el scaffold y la fuente de diseño (bloqueantes), inyectan el estado del build al iniciar la sesión, delegan estilo/typecheck a herramientas, y recuerdan validar trazabilidad, gates abiertos y reflexionar al cerrar un slice. No reemplazan a los agentes ni a las skills; los **complementan** liberando capacidad de razonamiento del modelo y poniendo barandillas mecánicas donde un olvido cuesta caro.
 
 ---
 
-## Resumen de los 8 hooks
+## Resumen de los 9 hooks
 
 | Hook | Evento | Matcher | Qué hace | ¿Bloqueante? |
 |---|---|---|---|---|
@@ -14,12 +14,13 @@ Los hooks son el sistema nervioso del arnés: vigilan GitFlow, el stack declarad
 | `gitflow-guard.sh` | `PreToolUse` | `Bash` | Enforce GitHub Flow estricto sobre `git commit` / `git push`. | **Sí (exit 2)** |
 | `stack-guard.sh` | `PreToolUse` | `Write\|Edit\|MultiEdit` | Bloquea dependencias en `package.json` fuera de la allowlist del stack del PRD. | **Sí (exit 2)** |
 | `scaffold-guard.sh` | `PreToolUse` | `Write\|Edit\|MultiEdit` | Bloquea escribir código de slice (fases `red…data`) si el scaffold no está confirmado (`scaffold.confirmed`). | **Sí (exit 2)** |
+| `design-source-guard.sh` | `PreToolUse` | `Write\|Edit\|MultiEdit` | Bloquea escribir código de un slice **con UI** (`gates.fidelity===false`, fases `red…data`) si la fuente de diseño del proyecto no está confirmada (`design_source.confirmed`). | **Sí (exit 2)** |
 | `lint-typecheck.sh` | `PostToolUse` | `Write\|Edit\|MultiEdit` | Corre prettier/eslint/tsc sobre el archivo `.ts`/`.tsx` editado. | No |
 | `coherence-flag.sh` | `PostToolUse` | `Write\|Edit\|MultiEdit` | Recuerda validar la trazabilidad de un `proposal.md` de OpenSpec recién tocado. | No |
 | `build-gate-check.sh` | `Stop` | `.*` | Al cerrar el turno, avisa si el slice activo tiene gates abiertos. | No |
 | `reflect-nudge.sh` | `Stop` | `.*` | Al cerrar el turno, sugiere `/build:reflect` si hay slice(s) archivado(s) sin reflexionar (`reflected != true`). | No |
 
-> Tres bloqueantes (`gitflow-guard`, `stack-guard`, `scaffold-guard`) y cinco informativos. Los bloqueantes usan `exit 2`: Claude Code devuelve el `stderr` al modelo y aborta la herramienta; el resto siempre sale `0`.
+> Cuatro bloqueantes (`gitflow-guard`, `stack-guard`, `scaffold-guard`, `design-source-guard`) y cinco informativos. Los bloqueantes usan `exit 2`: Claude Code devuelve el `stderr` al modelo y aborta la herramienta; el resto siempre sale `0`.
 
 ---
 
@@ -84,6 +85,10 @@ Refuerza el **scaffold como "Paso 1 fundamental"**. Bloquea con `exit 2` la escr
 
 Cierra el **ciclo autocorrectivo**. Al terminar el turno, si en `history[]` hay slice(s) archivado(s) con `reflected != true`, imprime un *nudge* sugiriendo ejecutar `/build:reflect` para capturar las convenciones aprendidas (y errores recurrentes) en el bloque `trycore-build-learnings` de `CLAUDE.md`. **Nunca bloquea** el cierre de sesión: si falta `python3` o el estado, sale `0` en silencio (**fail-open**). El razonamiento —qué se aprendió— vive en el comando `/build:reflect`, no en el hook; este solo recuerda. Tras reflexionar y estampar `reflected: true`, el nudge calla.
 
+### 9. `design-source-guard.sh` — `PreToolUse` · Write/Edit/MultiEdit · **bloqueante** (desde v0.5.0)
+
+Refuerza el **seguro de fuente de diseño** (espejo de `scaffold-guard`, para slices con UI). Bloquea con `exit 2` la escritura de **código de un slice con UI** —cuando `active_slice.phase` ∈ `red`/`green`/`refactor`/`smoke`/`api`/`data` **y** `active_slice.gates.fidelity === false` (marcado UI-pendiente por la DoR)— mientras el proyecto tenga UI (`design_source.applies === true`) y `design_source.confirmed` no sea `true`. **Permite** todo lo demás: slices sin UI (`gates.fidelity === null` o ausente), proyectos sin UI (`applies !== true`), fases de planificación (`dor`/`change`), o fuente ya confirmada. El arnés **exige** la fuente de diseño pero **no genera** el prototipo; la confirmación es **explícita** (vía `building-a-slice` Fase 0-bis / `dor-dod-gatekeeper`), nunca auto-detectada. Guarda `python3` fail-closed dirigido. En la práctica, como `design_source` es gate de proyecto, solo muerde la **primera** construcción de UI sin fuente declarada.
+
 ---
 
 ## La cadena de comando única (sin doble disparo entre canales)
@@ -107,7 +112,7 @@ Como la cadena es **carácter por carácter idéntica** en ambos canales, si el
 
 Los hooks parsean el JSON del evento con `python3`. Qué pasa si **falta** `python3` depende de si el hook es bloqueante:
 
-- **Bloqueantes** (`gitflow-guard`, `stack-guard`, `scaffold-guard`) → **fail-closed dirigido**: si no pueden analizar el comando/edición, solo bloquean (`exit 2`) cuando la entrada *cruda* parece relevante (un `git commit`/`push`, una edición que menciona `package.json`, o código de slice sin scaffold confirmado); en cualquier otro caso salen `0`. Esto evita falsos negativos peligrosos sin frenar el trabajo no relacionado. El mensaje pide instalar `python3` (verificable con `trycore-build doctor`).
+- **Bloqueantes** (`gitflow-guard`, `stack-guard`, `scaffold-guard`, `design-source-guard`) → **fail-closed dirigido**: si no pueden analizar el comando/edición, solo bloquean (`exit 2`) cuando la entrada *cruda* parece relevante (un `git commit`/`push`, una edición que menciona `package.json`, o código de slice sin scaffold/fuente de diseño confirmados); en cualquier otro caso salen `0`. Esto evita falsos negativos peligrosos sin frenar el trabajo no relacionado. El mensaje pide instalar `python3` (verificable con `trycore-build doctor`).
 - **No bloqueantes** (`load-build-state`, `lint-typecheck`, `coherence-flag`, `build-gate-check`, `reflect-nudge`) → si falta `python3`, simplemente **omiten** su trabajo y salen `0` (fail-open).
 
 > `python3` es un **requisito duro**: `trycore-build init` y `trycore-build doctor` **fallan** si no está presente, justo porque toda la cadena de hooks depende de él para leer el JSON del evento.
@@ -126,6 +131,7 @@ Los hooks que tocan el código construido se **auto-arman**: permanecen **inerte
 | `lint-typecheck.sh` | Inerte (sale `0` de inmediato). |
 | `coherence-flag.sh` | Funciona siempre (depende de OpenSpec, no del código). |
 | `scaffold-guard.sh` | Permite (sin slice en fases de código no hay nada que bloquear; también permite crear el scaffold). |
+| `design-source-guard.sh` | Permite (sin slice UI en fases de código, o sin `design_source.applies=true`, no hay nada que bloquear). |
 | `build-gate-check.sh` | Inerte (sale `0` de inmediato). |
 | `reflect-nudge.sh` | Silencioso (en `authoring` no hay slices archivados que reflexionar). |
 
@@ -141,7 +147,7 @@ Una sola definición de hooks, expresada en dos archivos espejo según el canal:
 
 `trycore-build init` hace un **merge idempotente y aditivo** en el `settings.json` del consumidor (lógica en `src/lib/settings-merge.ts`; espejo documental en `templates/settings-hooks.template.json`):
 
-- Agrega las 5 agrupaciones de hooks (las 8 invocaciones: `PreToolUse·Write` agrupa `stack-guard` + `scaffold-guard`; `PostToolUse·Write` agrupa `lint-typecheck` + `coherence-flag`; `Stop` agrupa `build-gate-check` + `reflect-nudge`) sin pisar lo que ya exista.
+- Agrega las 5 agrupaciones de hooks (las 9 invocaciones: `PreToolUse·Write` agrupa `stack-guard` + `scaffold-guard` + `design-source-guard`; `PostToolUse·Write` agrupa `lint-typecheck` + `coherence-flag`; `Stop` agrupa `build-gate-check` + `reflect-nudge`) sin pisar lo que ya exista.
 - Agrega **permisos mínimos y enumerados** (sin `mcp__*` ni rutas absolutas):
 
   ```

package/hooks/build/design-source-guard.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# design-source-guard.sh — PreToolUse · Write/Edit/MultiEdit
+# Backstop determinista del "seguro de fuente de diseño": no se escribe código de un slice
+# CON UI sin que la fuente de diseño del proyecto esté confirmada. Espejo de scaffold-guard.sh.
+# Bloquea (exit 2) SOLO si: hay active_slice en fase de código (red/green/refactor/smoke/api/data),
+# el proyecto tiene UI (design_source.applies===true), el slice está marcado UI-pendiente
+# (gates.fidelity===false) y design_source.confirmed!==true.
+# AUTO-ARME: si no existe build-state.json, exit 0.
+set -uo pipefail
+
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null || echo "${CLAUDE_PROJECT_DIR:-$(pwd)}")"
+STATE="$ROOT/.claude/state/build-state.json"
+[ -f "$STATE" ] || exit 0
+
+INPUT="$(cat)"  # consumir stdin (protocolo de hook); la decisión es por estado.
+
+# Guarda python3 [H4]: si falta, no podemos leer el estado de forma fiable. Fail-closed.
+if ! command -v python3 >/dev/null 2>&1; then
+  echo "⛔ design-source-guard: python3 no disponible; no puedo verificar el gate de fuente de diseño. Instala python3 (trycore-build doctor)." >&2
+  exit 2
+fi
+
+VERDICT="$(STATE="$STATE" python3 <<'PY' 2>/dev/null
+import os, sys, json
+try:
+    d = json.load(open(os.environ["STATE"]))
+except Exception:
+    sys.exit(0)  # estado ilegible -> no bloquear (auto-arme)
+slice_ = d.get("active_slice")
+if not slice_:
+    sys.exit(0)  # sin slice: permitir declarar / planificar
+code_phases = {"red", "green", "refactor", "smoke", "api", "data"}
+if slice_.get("phase") not in code_phases:
+    sys.exit(0)  # fases dor/change/pr/archived: permitido
+ds = d.get("design_source") or {}
+if ds.get("applies") is not True:
+    sys.exit(0)  # proyecto sin UI (o indeterminado): mecanismo apagado
+if (slice_.get("gates") or {}).get("fidelity") is not False:
+    sys.exit(0)  # solo UI-pendiente (false) cuenta; null/ausente -> no bloquear
+if ds.get("confirmed") is True:
+    sys.exit(0)  # fuente de diseño confirmada: permitido
+print("BLOCK")
+PY
+)"
+
+if [ "$VERDICT" = "BLOCK" ]; then
+  echo "⛔ design-source-guard: el slice con UI está en fase de código pero la fuente de diseño NO está confirmada." >&2
+  echo "   Declara y confirma primero el DESIGN_SOURCE del proyecto (ver building-a-slice Fase 0-bis / DoR)." >&2
+  echo "   El arnés NO genera el prototipo: declara la fuente (prototipo/export) y confírmala." >&2
+  exit 2
+fi
+exit 0

package/hooks/build/load-build-state.sh

@@ -39,8 +39,24 @@ if not s:
 else:
     g=s.get("gates",{})
     abiertos=[k for k,v in g.items() if v is False]
-    print(f"   Slice activo: {s.get('hu')} ({s.get('epica')}) · change={s.get('openspec_change')} · fase={s.get('phase')}")
+    hus=", ".join(s.get("hus") or []) or "—"
+    print(f"   Slice activo: {s.get('epica')} [{hus}] · change={s.get('openspec_change')} · fase={s.get('phase')}")
     print(f"   Gates pendientes: {', '.join(abiertos) if abiertos else 'ninguno ✅'}")
+    # Handoff fino en disco (A1): items de cableado aún FAILING + última bitácora.
+    # Una sesión fresca arranca de aquí; mientras queden failing, el cableado NO está hecho.
+    failing=[w for w in (s.get("wiring_checklist") or []) if w.get("status")=="failing"]
+    if failing:
+        muestra="; ".join(f"{w.get('id')}({w.get('kind')})" for w in failing[:8])
+        extra=f" (+{len(failing)-8} más)" if len(failing)>8 else ""
+        print(f"   ⚠️  Cableado pendiente ({len(failing)} item/s failing): {muestra}{extra}")
+        print("       NO declares el slice terminado mientras queden items failing (verifica con prueba real).")
+    pend=[ss for ss in (s.get("sub_slices") or []) if ss.get("status")!="done"]
+    if pend:
+        print(f"   ⚠️  Sub-slices pendientes: {', '.join(ss.get('id') for ss in pend)}")
+    log=s.get("progress_log") or []
+    if log:
+        last=log[-1]
+        print(f"   Última bitácora: [{last.get('by')}] {last.get('note')}")
 PY
 fi
 exit 0

package/hooks/build-harness.json

@@ -31,6 +31,10 @@
           {
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/scaffold-guard.sh\""
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/design-source-guard.sh\""
           }
         ]
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycore/spec-build-harness",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Arnés agéntico de construcción de Trycore para Claude Code: pipeline de dos loops (slice por épica + release gate) con gates de calidad, estado compartido y OpenSpec. Compañero de @trycore/spec-product-flow. Agnóstico al proyecto.",
   "type": "module",
   "bin": {

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

@@ -25,7 +25,14 @@ el avance en el estado.
   `.claude/state/README.md`). Lee antes de actuar; escribe una vez por transición.
 - **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 (devuelven síntesis, protegen el contexto).
+- **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`.
 
 ## Dos loops
 
@@ -39,6 +46,21 @@ inner loop: **≤ ~20 min por épica** y producto que **camina end-to-end en tod
 > cada paso sea un stub. Cada épica posterior **engorda** un paso de ese esqueleto y mantiene el
 > `journey_smoke` verde. Nunca se construyen capas horizontales aisladas que "se juntan al final".
 
+> **Cimiento antes que negocio (épicas fundacionales).** Las épicas marcadas `layer: foundational`
+> (autenticación, acceso a datos, arquitectura base, design-system/componentes base) se construyen
+> **antes** que las `layer: business`. El DoR **rechaza** abrir una épica de negocio que arrastra
+> cimiento no construido y lo extrae a una épica fundacional previa (ver `dor.md`). Así cada slice de
+> negocio **solo toca lógica aplicable** y no quema contexto creando infra.
+
+> **Descomposición por tamaño (no one-shot).** Una épica que supera el **gate de tamaño**
+> (heurística por defecto: **> 3 HU** ó **≥ 3 capas tocadas**; configurable por proyecto) es
+> demasiado grande para una pasada: el DoR obliga a trocearla en **sub-slices verificables**
+> (`sub_slices[]`) construidos **de a uno**, con `journey_smoke` verde entre cada uno antes de pasar
+> al siguiente. El orquestador trabaja por **fases encadenadas** (mapear → generar → revisar →
+> fix-loop → optimizar) y reparte la exploración **"ancho antes que profundo"** con subagentes
+> **solo-lectura por área** (frontend/backend/datos); el **cableado** lo hace la sesión, no
+> subagentes que escriben en paralelo. Trocear acota además el tamaño del `wiring_checklist[]`.
+
 ## Fase 0 · Scaffold (Paso 1 fundamental — precondición restrictiva)
 
 Antes de abrir **cualquier** slice, el scaffold runnable del proyecto debe **existir y estar
@@ -56,6 +78,21 @@ camina* se construye **encima** del scaffold ya existente.
 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`.
+   - `applies` indeterminado (ausente) → pregunta *"¿este proyecto tiene UI?"* y fija `applies`.
+   - `applies === false` → N/A, salta esta fase.
+   - `confirmed === true` → continúa.
+2. `applies===true && confirmed===false` → **pregunta explícita** (AskUserQuestion): *"¿Existe una
+   fuente de diseño declarada (prototipo/export) para la UI de este proyecto?"*
+   - **No** → **STOP**. Indica declararla (ruta/URL del prototipo o export). El arnés **NO la genera**.
+     No abras el slice con UI.
+   - **Sí** → registra `design_source.source`, `confirmed=true`, `confirmed_by`, `confirmed_at`, `notes`.
+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).
+
 ## Pipeline — inner loop (carga la referencia indicada en cada paso)
 
 | Fase | Acción | Delega en | Gate | Referencia |
@@ -63,9 +100,9 @@ camina* se construye **encima** del scaffold ya existente.
 | 1 · dor | Validar Definition of Ready | `dor-dod-gatekeeper` | `dor` | `dor.md` |
 | 2 · change | `opsx:new` + bloque `## Trazabilidad`; validar enlace (barato) | `opsx:new`, `change-epic-coherence` | `coherence_link` | `link-change-epic.md` |
 | 3 · tdd | red → green → refactor | `superpowers:test-driven-development` | `tdd` | — |
-| 4 · smoke | Recorrer el journey-hasta-aquí end-to-end | skill `verify` / `run` (+ MCP chrome-devtools) | `journey_smoke` | `mcp-map.md` |
+| 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 | Definition of Done (por slice, reducido) | `dor-dod-gatekeeper` | `dod` | `dod.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` |
 | 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 |
 
@@ -73,6 +110,16 @@ Los gates `stack`, `security`, `smell`, `ux` y la coherencia triple completa **y
 aquí**: pertenecen al Release Gate. Las **deps** siguen vigiladas en tiempo real por el hook
 `stack-guard.sh`; lint/tsc/gitflow por sus hooks.
 
+El gate `fidelity` (fidelidad a la fuente de diseño) **sí** es de inner loop: se computa en `smoke`,
+con la app ya levantada, y es vivo por-slice; complementa al `ux-krug-reviewer` (usabilidad), que
+sigue en el Release Gate. **Estricto para UI:** una UI no mejora su fidelidad por el prompt sino
+porque el agente **carga la página, observa la salida real y lee la consola**. Para slices con UI
+(`design_source.applies===true`), `fidelity` **solo cierra con verificación visual real vía MCP
+chrome-devtools** (screenshot app vs prototipo). Sin MCP, `fidelity` queda `false` (INCONCLUSO ya
+**no** pasa) → el `dod` no cierra: corre el slice donde haya MCP. Mantén **cobertura** (ninguna
+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`.
 
 ## Fase 8 · ¿Release Gate ahora? (default computado, humano decide)
@@ -107,4 +154,11 @@ El usuario siempre puede sobreescribir el default. Si acepta, invoca la skill
 - El enlace change↔épica va en `## Trazabilidad` del `proposal.md`, **nunca** en frontmatter YAML
   (rompe `openspec validate`). Ver `link-change-epic.md`.
 - Integración solo por **PR** a `main` (el hook `gitflow-guard.sh` bloquea commits/push directos).
+- **`dod` exige `wiring_verified: true`** (verificación adversarial independiente, contexto virgen).
+  El DoD declarativo del gatekeeper es un **piso, no el arreglo**: reusar el mismo agente como
+  generador y verificador produce auto-confirmación. La generación y la verificación van separadas.
+- **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`).
 - Si una regla aquí contradice la metodología Trycore (`METODOLOGIA.md`), **gana la metodología**.

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

@@ -11,6 +11,20 @@ pesadas (seguridad, diseño, UX, coherencia triple, arquitectura, integración)
 - [ ] **`coherence_link`** — `change-epic-coherence` confirma el enlace change↔épica (bloque `## Trazabilidad`, `openspec validate` ok). Es el chequeo **barato**; la trazabilidad triple completa va al Release Gate.
 - [ ] **`data`** — `data-consistency-checker` valida invariantes de datos (salida de servicios externos validada contra esquema antes de alimentar la capa de decisión determinista del dominio) (si el slice toca datos).
 - [ ] **`api`** — `api-contract-tester` (Newman) 100% verde (o `null` si el slice no tiene endpoints).
+- [ ] **`fidelity` (slices con UI)** — `ux-fidelity-reviewer` devuelve **FIEL** (o DESVIACIONES todas
+  justificadas/documentadas) → `gates.fidelity: true`; `null` si el slice no tiene UI. **ESTRICTO para
+  UI** (`design_source.applies===true`): solo `true` con **verificación visual real** vía MCP
+  chrome-devtools (screenshot app vs prototipo). **INCONCLUSO ya NO pasa**: sin MCP queda `false` y el
+  `dod` no cierra (corre el slice donde haya MCP). Mantén **cobertura** (ninguna pantalla del prototipo
+  en alcance sin construir; ninguna pantalla de la app sin HU/EP). Es gate **vivo** de inner loop (no la
+  revisión Krug, que sigue en el Release Gate).
+- [ ] **Sub-slices completos** — si la épica se descompuso (`sub_slices[]` no vacío), **todos** en
+  `status: done` con su `journey_smoke` verde. No se cierra `dod` con sub-slices pendientes.
+- [ ] **`wiring_verified`** — el `wiring-adversarial-verifier` (subagente **independiente**, contexto
+  virgen) intentó **refutar** el slice (stubs, rutas sin cablear, AC sin test, items de
+  `wiring_checklist[]` aún `failing`) y no halló huecos → `gates.wiring_verified: true`. **Prerequisito
+  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).
 - [ ] **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[]`.
 - [ ] **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`).

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

@@ -7,11 +7,17 @@ la épica; lo de abajo aplica a la épica y a **cada HU** que cubre (`hus[]`). L
 - [ ] **HU enumeradas**: la épica tiene ≥1 HU; todas las que entran se listan en `hus[]`.
 - [ ] **Frontmatter completo** en cada `docs/04-historias/HU-XXX.md`: `id, titulo, epica, prioridad, complejidad, estado` y `estado: lista`.
 - [ ] **AC en Given/When/Then** por HU, **proporcional a `complejidad`** (cubre los modos de fallo que *realmente existen*, no una cuota fija): `trivial`/baja → **1–2** (happy + el error/edge crítico si existe); `media` → **3** (happy + error + edge); `alta` → **3–5** (cobertura completa). Regla dura Trycore: si existe una rama de error/edge, **debe** tener su escenario (lo que se elimina es fabricar 3–5 para una HU trivial).
-- [ ] **INVEST** por HU: pasa los 6 criterios (Independent, Negotiable, Valuable, Estimable, Small, Testable). Ante duda, invocar `invest-validator`.
-- [ ] **Dependencias resueltas**: las épicas/HU de las que depende están archivadas (`history[]`) o explícitamente no bloquean.
+- [ ] **INVEST** por HU: pasa los 6 criterios (Independent, Negotiable, Valuable, Estimable, Small, Testable).
+- [ ] **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.
+- [ ] **Tamaño acotado (gate de descomposición)**: si la épica supera el umbral —heurística por defecto **> 3 HU** ó **≥ 3 capas tocadas** (configurable por proyecto)— **no entra como slice único**: se descompone en `sub_slices[]` verificables construidos de a uno, con `journey_smoke` verde entre cada uno. El umbral es proporcional (no cuota rígida): una épica de 1 capa y pocas HU entra directa.
 - [ ] **Cabe en el stack** del PRD §7 (no requiere tecnología fuera de `stack-allowlist.json`).
 - [ ] **Datos de prueba disponibles** o identificables (p.ej. los datos de ejemplo / fixtures sintéticos del dominio del consumidor).
+- [ ] **Fuente de diseño identificada (slices con UI)**: la fuente visual de verdad del slice
+  (el `DESIGN_SOURCE` del dominio) está declarada y confirmada (`design_source.confirmed`), y este
+  slice apunta a la(s) pantalla(s) equivalente(s). No se construye UI fuera de la fuente declarada.
 
 **Si todo ✓** → `dor-dod-gatekeeper` abre `active_slice` en `build-state.json` con `epica`, `hus[]`,
-`phase: dor`, `gates.dor: true` y el resto en `false` (`ux`/`api` en `null` si la épica no toca UI/endpoints).
+`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/integration-check.md

@@ -0,0 +1,27 @@
+# Runner de integración fuera-de-chat (`integration-check`)
+
+Gate determinista que cierra `journey_smoke` **ejecutando**, no por inspección. Lleva el patrón del
+gate fuera-de-chat (como `tools/loop/gateway-check.sh` de un consumidor) al **inner-loop manual**, no
+solo al autónomo. **No crea ningún gate nuevo**: alimenta el `journey_smoke` existente del slice. El
+gate `integration` con dependencias reales sigue siendo del **Release Gate** (outer loop).
+
+## Por qué fuera de chat y en contexto virgen
+- El cableado end-to-end **se ejecuta** (build + suite + journey), no se "razona". Un script lo hace
+  reproducible y barato en contexto.
+- Quien escribió el código **no es buen juez** de su propio cableado: corre el runner en una
+  **sesión/contexto virgen** (o como paso de CI) y entra al **fix-loop** (corre → lee el reporte →
+  arregla → repite) hasta verde.
+
+## Cómo adoptarlo
+1. Copia `templates/integration-check.sh.template` a tu repo (p.ej. `tools/loop/integration-check.sh`)
+   y hazlo ejecutable (`chmod +x`).
+2. **Adapta** los comandos marcados `# ADAPTA` a tu stack (build, suite, e2e). El arnés es agnóstico:
+   el template trae defaults de Node como punto de partida.
+3. Córrelo en la fase `smoke`. Salida **0 = verde** (puedes marcar `journey_smoke: true`), **≠0 = rojo**.
+   El reporte queda en `.claude/state/integration-report.txt`.
+4. Mientras la suite no esté verde y el journey no camine end-to-end, `journey_smoke` queda `false`.
+
+## Relación con el cableado fino
+Cada paso verde del runner es la **evidence** que permite pasar items de `wiring_checklist[]` de
+`failing` a `passing` (ver `state-protocol.md`). El `wiring-adversarial-verifier` (fase `dod`) revisará
+después que esa evidencia sea real.

package/skills/building-a-slice/references/mcp-map.md

@@ -15,6 +15,7 @@ los expone, el gate se cubre con las alternativas CLI/test indicadas.
 | Fase / agente | MCP (ejemplo, si habilitado) | Para qué |
 |---|---|---|
 | `review` · `ux-krug-reviewer` | **chrome-devtools** | `take_snapshot` (árbol accesible), `lighthouse_audit` (Accessibility/Best-Practices), `take_screenshot`, `list_console_messages` para verificar la UI **corriendo**. |
+| `smoke` · `ux-fidelity-reviewer` | **chrome-devtools** *(REQUERIDO para slices con UI)* | `new_page`/`navigate_page`, `take_screenshot`, `take_snapshot` para comparar **composición/paleta/tipografía** del diseño vs la app corriendo. Requiere la app levantada; úsalo en fase `active`. **Excepción a la regla opt-in**: para UI la verificación visual real es obligatoria; sin MCP, `fidelity` queda `false` (INCONCLUSO bloquea) y el `dod` no cierra. Cualquier MCP de devtools de navegador sirve (chrome-devtools es el ejemplo). |
 | `api` · `api-contract-tester` | — (Newman CLI) | Contratos de endpoints. Newman no es MCP; corre vía Bash. |
 | `data` · `data-consistency-checker` | **postgresql** *(solo si el slice usa Postgres)* | `read_query`/`describe_table` para validar consistencia en BD. Con un almacén embebido/cliente (según el stack declarado en el PRD del consumidor) se valida por tests, sin MCP. |
 | perf (opcional, fuera del DoD) | **k6** | `execute_k6_test` para carga/latencia si una HU de la épica lo exige. |

package/skills/building-a-slice/references/state-protocol.md

@@ -11,6 +11,19 @@ python3 -c 'import json;print(json.dumps(json.load(open(".claude/state/build-sta
 - `active_slice == null` → no hay slice; solo `dor` puede abrir uno.
 - Si no es null → identifica el **primer gate en `false`**: ahí se reanuda.
 
+## Refresh de contexto = estado por defecto (handoff en disco)
+Cada iteración nace **headless / contexto virgen** y reconstruye el estado **desde disco** (git history +
+este `build-state.json` + logs de build), **no** desde la conversación viva: alargar una sesión degrada
+el razonamiento (ruido acumulado → deriva). Para retomar sin "creer que ya está":
+- **`wiring_checklist[]`** — un item por escenario AC de cada HU y por **punto de integración entre capas**.
+  Nace `failing`; pasa a `passing` **SOLO tras prueba real ejecutada** (con `evidence`), nunca por inspección.
+  **Mientras quede un item `failing`, el slice NO está cableado** — no cierres `wiring_verified` ni `dod`.
+- **`progress_log[]`** — bitácora append-only (`{at, by, note}`) de qué se hizo / qué falta. Deja una nota
+  por hito para que la siguiente sesión retome el cableado.
+- **`sub_slices[]`** — si la épica superó el gate de tamaño (>3 HU ó ≥3 capas), se trocea aquí; cada
+  sub-slice se construye de a uno con su `journey_smoke` verde antes de pasar al siguiente.
+`load-build-state.sh` inyecta al arrancar los items `failing` y la última bitácora (JIT, solo lo pendiente).
+
 ## Escritura (una transición = una escritura)
 Patrón seguro (lee-modifica-escribe) con timestamp UTC:
 ```bash
@@ -27,16 +40,20 @@ PY
 ```
 
 ## Inner loop vs releases[]
-- **Inner loop (por slice)**: gates `dor`, `tdd`, `journey_smoke`, `coherence_link`, `data`, `api`,
-  `dod` en `active_slice.gates`. Los escribe el flujo de `building-a-slice` / `build-orchestrator`.
+- **Inner loop (por slice)**: gates `dor`, `tdd`, `journey_smoke`, `coherence_link`, `data`, `fidelity`,
+  `api`, `wiring_verified`, `dod` en `active_slice.gates`. Los escribe el flujo de `building-a-slice` /
+  `build-orchestrator`. **`wiring_verified` es prerequisito de `dod`** (lo cierra el verificador
+  adversarial independiente, no el mismo agente que construyó).
 - **Outer loop (por release)**: los gates pesados (`security`, `smell`, `ux`, `coherence`,
   `stack_arch`, `integration`) **no** viven en el slice — viven en una entrada de `releases[]` que
   escribe la skill `releasing-a-version`. Una release = una línea de release del Story Map.
 
 ## Reglas
-1. **No saltes gates**: no cierres `dod` con gates abiertos.
+1. **No saltes gates**: no cierres `dod` con gates abiertos; en particular `dod` exige `wiring_verified: true`.
 2. **Retroceso permitido**: si una revisión posterior falla, pon su gate en `false` y retrocede `phase`.
-3. **`ux`/`api` = `null`** cuando no aplican (no cuentan como abiertos para DoD).
+3. **`fidelity`/`api` = `null`** cuando no aplican (no cuentan como abiertos para DoD). `fidelity` NO puede
+   quedar `null` si el slice toca UI (`design_source.applies===true`): ahí debe llegar a `true` por
+   verificación visual real (MCP). `wiring_verified` aplica siempre (no admite `null`).
 4. **Archivar**: mueve `active_slice` a `history[]` con `phase:"archived"`, deja `active_slice:null`.
 5. **Valida tras escribir**:
    ```bash

package/state/README.md

@@ -24,7 +24,9 @@ Cada gate del pipeline transiciona el estado; el siguiente agente lo lee antes d
    correspondiente, `updated_at` (ISO 8601 UTC) y `updated_by` (su nombre). No tocar otros campos.
 3. **Gates monótonos hacia adelante.** Un gate solo pasa de `false`→`true` cuando su agente lo
    aprueba. Si una revisión posterior falla, se vuelve a `false` y `phase` retrocede.
-4. **`ux`/`api` admiten `null`** cuando el slice no tiene UI o endpoints (N/A, no bloquea DoD).
+4. **`fidelity`/`api` admiten `null`** cuando el slice no tiene UI o endpoints (N/A, no bloquea DoD).
+   `fidelity` **no** puede quedar `null` si el slice toca UI. `wiring_verified` aplica siempre (sin `null`)
+   y es **prerequisito de `dod`**.
 5. **Archivar**: al completar `opsx:archive`, mover el `active_slice` a `history[]` con
    `phase: "archived"` y dejar `active_slice: null`.
 6. **Dos loops**: el slice (inner loop) cierra gates baratos por épica; los gates pesados viven en
@@ -51,6 +53,32 @@ Arranca en `confirmed: false` y **solo** pasa a `true` por **confirmación expl
 restrictiva para abrir cualquier slice: el hook `scaffold-guard.sh` bloquea escribir código de
 slice (fases `red…data`) mientras `confirmed` no sea `true`. El arnés **no genera** el scaffold.
 
+### `design_source` (gate de proyecto, slices con UI)
+
+Espejo de `scaffold` para la UI: `applies` (¿el proyecto tiene UI?), `confirmed` (humano confirmó que
+existe una fuente de diseño declarada), `source` (puntero al prototipo/export). El arnés NO genera el
+prototipo. Lo respalda `design-source-guard.sh`.
+
+### gate `fidelity` (por-slice, inner loop) — ESTRICTO para UI
+
+`true` = FIEL (o desviaciones justificadas, **vía verificación visual real**); `false` = desviaciones
+sin justificar **o** verificación visual no realizada; `null` = slice sin UI. Lo computa
+`ux-fidelity-reviewer` en la fase `smoke` y lo escribe el `build-orchestrator`. Para slices con UI
+(`design_source.applies===true`) solo cierra con **MCP chrome-devtools** (screenshot app vs prototipo):
+INCONCLUSO ya **no** pasa (queda `false` → el `dod` no cierra hasta correrlo donde haya MCP).
+
+### Handoff fino del cableado (`wiring_checklist[]`, `progress_log[]`, `sub_slices[]`) + gate `wiring_verified`
+
+Campos por-slice que hacen el **refresh de contexto el estado por defecto** (una sesión fresca retoma
+desde disco, no desde la conversación):
+- **`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** (con `evidence`).
+- **`progress_log[]`** — bitácora append-only (`{at, by, note}`) que sobrevive al reset.
+- **`sub_slices[]`** — descomposición de una épica que superó el gate de tamaño (>3 HU ó ≥3 capas).
+- **gate `wiring_verified`** — lo cierra el `wiring-adversarial-verifier` (subagente **independiente**,
+  contexto virgen, que intenta **refutar** el slice). `dod` no puede ser `true` sin él. Lo inicializa
+  el `dor-dod-gatekeeper` en `false` durante el DoR.
+
 ### Reflexión post-slice (ciclo autocorrectivo)
 
 Tras archivar un slice, su entrada en `history[]` puede llevar `reflected` / `reflected_at`. El
@@ -67,9 +95,10 @@ El razonamiento vive en el modelo; el hook solo es un recordatorio determinista.
 | `active_slice` (alta) · `gates.dor` · `gates.dod` | `dor-dod-gatekeeper` | slice |
 | `gates.coherence_link` | `change-epic-coherence` | slice |
 | `gates.tdd` | flujo `superpowers:test-driven-development` (vía `build-orchestrator`) | slice |
-| `gates.journey_smoke` · `phase` (transiciones) · `history[]` (archivado) | `build-orchestrator` | slice |
+| `gates.journey_smoke` · `gates.fidelity` · `phase` (transiciones) · `history[]` (archivado) · `wiring_checklist[]` · `progress_log[]` · `sub_slices[]` | `build-orchestrator` (fidelity desde `ux-fidelity-reviewer`) | slice |
 | `gates.api` | `api-contract-tester` | slice |
 | `gates.data` | `data-consistency-checker` | slice |
+| `gates.wiring_verified` | `wiring-adversarial-verifier` (independiente, contexto virgen) | slice (antes de `dod`) |
 | `releases[]` (`security`, `smell`, `ux`, `coherence`, `stack_arch`, `integration`, `status`) | `releasing-a-version` (delega en `security-reviewer`, `simple-design-reviewer`, `ux-krug-reviewer`, `coherence-three-way`, `stack-guardian`) | release |
 | `history[].reflected` · `history[].reflected_at` | `/build:reflect` | post-slice (tras archivar) |
 | `harness_phase` | `load-build-state.sh` (SessionStart) | — |

package/state/build-state.schema.json

@@ -14,6 +14,7 @@
       "description": "Señal INFORMATIVA auto-detectada: authoring = aún no hay package.json; active = scaffold de código presente. El gate de avance es `scaffold.confirmed`, NO esta señal."
     },
     "scaffold": { "$ref": "#/$defs/scaffold" },
+    "design_source": { "$ref": "#/$defs/design_source" },
     "active_slice": {
       "description": "El slice (épica) en construcción. null si no hay ninguno activo.",
       "oneOf": [
@@ -45,6 +46,20 @@
         "notes": { "type": "string", "description": "Evidencia libre (p.ej. 'build/dev arranca vacío sin error')." }
       }
     },
+    "design_source": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Gate de PROYECTO para slices con UI: existe una fuente de diseño declarada (prototipo/export). Espejo de scaffold: confirmed pasa a true SOLO por confirmación humana, nunca por auto-detección. El arnés NO genera el prototipo. applies=false apaga todo el mecanismo (proyecto sin UI).",
+      "required": ["applies", "confirmed"],
+      "properties": {
+        "applies": { "type": "boolean", "description": "¿el proyecto tiene UI / hay diseño que respetar? false → mecanismo N/A." },
+        "confirmed": { "type": "boolean", "description": "true solo tras confirmación humana de que existe una fuente de diseño declarada." },
+        "confirmed_by": { "type": ["string", "null"], "description": "Agente/skill que registró la confirmación." },
+        "confirmed_at": { "type": ["string", "null"], "format": "date-time" },
+        "source": { "type": "string", "description": "Puntero a la fuente: ruta/URL del prototipo o export (el DESIGN_SOURCE del dominio)." },
+        "notes": { "type": "string", "description": "Evidencia libre (p.ej. 'prototipo en docs/… revisado y vigente')." }
+      }
+    },
     "slice": {
       "type": "object",
       "additionalProperties": false,
@@ -67,14 +82,16 @@
         "gates": {
           "type": "object",
           "additionalProperties": false,
-          "description": "Inner loop (por slice): dor, tdd, journey_smoke, data, api(null), coherence_link, dod. Los gates pesados (stack, security, smell, ux, coherence) se cerraron por slice en la era anterior y hoy viven en releases[]; se mantienen como propiedades opcionales para validar historial.",
+          "description": "Inner loop (por slice): dor, tdd, journey_smoke, coherence_link, data, fidelity, api(null), wiring_verified, dod. Los gates pesados (stack, security, smell, ux, coherence) se cerraron por slice en la era anterior y hoy viven en releases[]; se mantienen como propiedades opcionales para validar historial.",
           "required": ["dor", "tdd", "dod"],
           "properties": {
             "dor": { "type": "boolean" },
             "tdd": { "type": "boolean" },
-            "journey_smoke": { "type": "boolean", "description": "El backbone-hasta-aquí camina end-to-end (verificado con la skill verify/run)." },
+            "journey_smoke": { "type": "boolean", "description": "El backbone-hasta-aquí camina end-to-end (verificado con la skill verify/run + runner fuera-de-chat integration-check)." },
             "coherence_link": { "type": "boolean", "description": "Enlace change↔épica válido (change-epic-coherence, barato, por slice)." },
             "data": { "type": "boolean" },
+            "fidelity": { "type": ["boolean", "null"], "description": "Gate VIVO de inner loop, computado en fase smoke por ux-fidelity-reviewer. Aplica cuando el slice toca UI (en un proyecto con design_source.applies===true); si el slice NO toca UI, es null aunque el proyecto tenga UI. ESTRICTO para UI: solo cierra con VERIFICACIÓN VISUAL REAL vía MCP de devtools de navegador (screenshot app vs prototipo). true = FIEL (o DESVIACIONES justificadas, vía MCP); false = DESVIACIONES sin justificar O verificación visual no realizada (INCONCLUSO ya NO pasa para UI); null = N/A (slice sin UI). NO es legado (los legados viven en releases[])." },
+            "wiring_verified": { "type": "boolean", "description": "Gate de cierre del inner loop (A4): un subagente adversarial INDEPENDIENTE de contexto virgen (wiring-adversarial-verifier) intentó refutar el slice (stubs, rutas sin cablear, AC sin test, items de wiring_checklist[] aún failing) y NO encontró huecos. dod NO puede ser true hasta que wiring_verified sea true. Lo inicializa el gatekeeper en false en el DoR." },
             "api": { "type": ["boolean", "null"], "description": "null = N/A (slice sin endpoints)." },
             "ux": { "type": ["boolean", "null"], "description": "null = N/A (slice sin UI). Legado: hoy se audita en releases[]." },
             "stack": { "type": "boolean", "description": "Legado por-slice; deps las cubre el hook stack-guard.sh, la arquitectura se audita en releases[]." },
@@ -88,7 +105,53 @@
         "updated_by": { "type": "string", "description": "Agente o hook que escribió el estado." },
         "notes": { "type": "string", "description": "Nota libre opcional (p.ej. changes/branches adicionales de una épica construida en varios pasos)." },
         "reflected": { "type": "boolean", "description": "True si /build:reflect ya capturó los aprendizajes de este slice archivado (ciclo autocorrectivo). Mientras sea false/ausente, reflect-nudge.sh sugiere reflexionar al cerrar sesión." },
-        "reflected_at": { "type": "string", "format": "date-time", "description": "Cuándo se reflexionó (ISO-8601 UTC). Lo escribe /build:reflect." }
+        "reflected_at": { "type": "string", "format": "date-time", "description": "Cuándo se reflexionó (ISO-8601 UTC). Lo escribe /build:reflect." },
+        "wiring_checklist": {
+          "type": "array",
+          "description": "Handoff FINO del cableado (A1): un item por escenario AC de cada HU y por punto de integración entre capas (SPA↔gateway↔core↔worker↔persistencia). Nace failing; pasa a passing SOLO tras prueba real ejecutada (con evidence), nunca por inspección. Sobrevive al reset de contexto: una sesión fresca lee los failing de disco y NO declara 'hecho' si quedan. El wiring-adversarial-verifier audita estos items antes de cerrar wiring_verified. Ausente/vacío en slices triviales.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["id", "kind", "ref", "status"],
+            "properties": {
+              "id": { "type": "string", "description": "Identificador estable del item (p.ej. HU-003-AC2 o INT-spa-gateway)." },
+              "kind": { "type": "string", "enum": ["hu_ac", "integration_point"], "description": "hu_ac = escenario Given/When/Then de una HU; integration_point = cableado entre dos capas." },
+              "ref": { "type": "string", "description": "A qué apunta: el AC (HU-XXX#escenario) o el par de capas (capaA→capaB)." },
+              "status": { "type": "string", "enum": ["failing", "passing"], "description": "failing al nacer; passing SOLO tras prueba real ejecutada." },
+              "evidence": { "type": "string", "description": "Evidencia de ejecución que justificó passing (test, comando, salida). Vacío mientras failing." }
+            }
+          }
+        },
+        "progress_log": {
+          "type": "array",
+          "description": "Bitácora de progreso que sobrevive al reset de contexto (A1): permite a una sesión fresca/headless retomar el cableado sin 'creer que ya está'. Append-only; complementa a git history y los logs de build.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["at", "by", "note"],
+            "properties": {
+              "at": { "type": "string", "format": "date-time" },
+              "by": { "type": "string", "description": "Agente/sesión que dejó la nota." },
+              "note": { "type": "string", "description": "Qué se hizo / qué falta (hito conciso)." }
+            }
+          }
+        },
+        "sub_slices": {
+          "type": "array",
+          "description": "Descomposición de una épica grande (A3): si supera el umbral del gate de tamaño (>3 HU ó ≥3 capas tocadas), se trocea en sub-slices verificables construidos DE A UNO, con journey_smoke verde entre cada uno. Ausente/vacío = épica atómica (no superó el umbral). Acota además el tamaño de wiring_checklist[] por paso.",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["id", "title", "status"],
+            "properties": {
+              "id": { "type": "string", "description": "Identificador del sub-slice (p.ej. EP-003-a)." },
+              "title": { "type": "string" },
+              "hus": { "type": "array", "items": { "type": "string", "pattern": "^HU-[0-9]{3}$" }, "description": "Subconjunto de hus[] cubierto por este sub-slice." },
+              "status": { "type": "string", "enum": ["pending", "done"], "description": "done SOLO con su journey_smoke verde." },
+              "journey_smoke": { "type": "boolean", "description": "El backbone-hasta-este-sub-slice camina end-to-end." }
+            }
+          }
+        }
       }
     },
     "release": {

package/state/build-state.template.json

@@ -7,6 +7,14 @@
     "confirmed_at": null,
     "notes": ""
   },
+  "design_source": {
+    "applies": false,
+    "confirmed": false,
+    "confirmed_by": null,
+    "confirmed_at": null,
+    "source": "",
+    "notes": ""
+  },
   "active_slice": null,
   "history": [],
   "releases": []