@trycore/spec-build-harness 0.8.0 → 0.8.1

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "trycore-spec-build-harness",
   "displayName": "Trycore — Spec & Build Harness",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Arnés de construcción de dos loops (slice por épica + release gate) para Claude Code, con gates de calidad, estado compartido y OpenSpec. Compañero de @trycore/spec-product-flow. Agnóstico al proyecto.",
   "author": {
     "name": "Trycore",

package/README.md

@@ -180,7 +180,8 @@ El core no menciona ningún dominio de cliente. Toda parametrización entra por
 - ✅ **v0.5.0** — seguro de fuente de diseño (`design_source` + `design-source-guard.sh`) + agente `ux-fidelity-reviewer` (gate `fidelity`, inner loop). Total: **11 agentes**, **9 hooks**.
 - ✅ **v0.6.0** — **calidad de cierre contra horizonte largo** (feedback exodocs): handoff fino en disco (`wiring_checklist[]` + `progress_log[]` + `sub_slices[]`), gate `wiring_verified` por nuevo agente **`wiring-adversarial-verifier`** (verificación adversarial independiente, contexto virgen), cimiento pre-construido + tag `layer` y gate de tamaño en el DoR, runner fuera-de-chat `integration-check`, y **fidelidad estricta por verificación visual real** (MCP requerido para UI). Convenciones anti-deriva (producto completo, no MVP) upstreadas al bloque del arnés. Total: **12 agentes**, **9 hooks**.
 - ✅ **v0.7.0** — **orquestación con workflows dinámicos + hardening** (de una evaluación adversarial del propio arnés): **3 plantillas `*.workflow.js`** opt-in y read-only (`explore-fanout`, `wiring-verify`, `release-gate`) que entran **solo donde aportan valor** y nunca en el camino caliente del inner loop; **3 comandos nuevos** `/build:slice` (entrada del inner loop), `/build:release` (outer loop) y `/build:work` (router *classify-and-act*); hook **`release-gate-nudge.sh`** (Stop, determinista: solo sugiere el Release Gate). Rename de los gates de los 5 reviewers pesados → `releases[].gates.{security,smell,ux,coherence,stack_arch}` (`stack`→`stack_arch`; separación `coherence` (release) / `coherence_link` (inner)). Hardening: degradación segura en 8 agentes, escritura atómica del estado, cierre del bypass de specs no-semver, `wiring` exige evidencia ejecutada y `check-agnostic` barre `*.js`. Total: **12 agentes**, **10 hooks**, **5 comandos `/build:*`**.
-- ✅ **v0.8.0 (actual)** — **motor de contexto + estado anclado a disco + front paralelo inter-épica**: hooks **`statusline-bridge.sh`** (canal CLI) + **`context-monitor.sh`** (umbrales `context.warning_pct`/`context.critical_pct` configurables, 35%/25% por defecto) con **auto-handoff** a `session_continuity` en critical/`PreCompact` y comando **`/build:resume`** para rehidratar desde disco; config **`context.auto_checkpoint`** (opt-in). Reconciliador **`reconcile-build-state.py`** (`SessionStart`): deriva de git + evidencia de tests, degrada `wiring_checklist` sin evidencia, anota *branch drift*, ratchet de gates, fail-open. **Front paralelo** (`parallel_front` en el estado): comando **`/build:front`** + skill **`managing-parallel-front`** + `scripts/lib/front-plan.py` (disjunción por `files_scope`, foundational-first). Schema nuevo: `slice.layer`, `slice.files_scope`, `slice.branch_drift`, `slice.session_continuity`. **Caveat:** `statusLine` es solo canal CLI; en plugin-only el motor de contexto degrada fail-open. Total: **12 agentes**, **13 hooks**, **7 comandos `/build:*`**, **14 skills**.
+- ✅ **v0.8.0** — **motor de contexto + estado anclado a disco + front paralelo inter-épica**: hooks **`statusline-bridge.sh`** (canal CLI) + **`context-monitor.sh`** (umbrales `context.warning_pct`/`context.critical_pct` configurables, 35%/25% por defecto) con **auto-handoff** a `session_continuity` en critical/`PreCompact` y comando **`/build:resume`** para rehidratar desde disco; config **`context.auto_checkpoint`** (opt-in). Reconciliador **`reconcile-build-state.py`** (`SessionStart`): deriva de git + evidencia de tests, degrada `wiring_checklist` sin evidencia, anota *branch drift*, ratchet de gates, fail-open. **Front paralelo** (`parallel_front` en el estado): comando **`/build:front`** + skill **`managing-parallel-front`** + `scripts/lib/front-plan.py` (disjunción por `files_scope`, foundational-first). Schema nuevo: `slice.layer`, `slice.files_scope`, `slice.branch_drift`, `slice.session_continuity`. **Caveat:** `statusLine` es solo canal CLI; en plugin-only el motor de contexto degrada fail-open. Total: **12 agentes**, **13 hooks**, **7 comandos `/build:*`**, **14 skills**.
+- ✅ **v0.8.1 (actual)** — **hotfix del motor de contexto**: `context-monitor.sh` re-inyectaba `additionalContext` en cada evento `Stop`, lo que re-lanzaba el turno en bucle hasta el tope `CLAUDE_CODE_STOP_HOOK_BLOCK_CAP` (9→override). Ahora en `Stop` re-lanza como mucho una vez por sesión (solo la transición a crítico que graba el handoff) y `warning` nunca inyecta en `Stop`. Cubierto por `test-context-monitor.sh`.
 
 ## Licencia
 

package/VERSION

@@ -1 +1 @@
-0.8.0
+0.8.1

package/hooks/build/context-monitor.sh

@@ -70,5 +70,11 @@ else:
           " Avisa al usuario para reiniciar en un punto natural.")
     msg=(f"🛑 Contexto CRÍTICO al {rem}% restante.{tail} El estado ya vive en build-state.json;"
          f" no reescribas handoff manual.{cont}")
+# En 'Stop', inyectar additionalContext RE-LANZA el turno (re-prompt): repetirlo en cada
+# intento de cierre entra en bucle hasta el tope CLAUDE_CODE_STOP_HOOK_BLOCK_CAP (=9→override).
+# Por eso en 'Stop' re-lanzamos como MUCHO una vez por sesión y solo en la TRANSICIÓN a crítico
+# (recorded=True, el instante en que se graba el handoff). 'warning' nunca inyecta en 'Stop'
+# (el nudge solo sirve mientras se trabaja). Fuera de 'Stop' se inyecta con normalidad.
+if evt=="Stop" and not (sev=="critical" and recorded): sys.exit(0)
 print(json.dumps({"hookSpecificOutput":{"hookEventName":evt,"additionalContext":msg}}))
 PY

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycore/spec-build-harness",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "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/scripts/tests/test-context-monitor.sh

@@ -31,6 +31,42 @@ echo "$out" | grep -q 'additionalContext' && echo "OK monitor inyecta aviso" ||
 sc="$(python3 -c "import json;print(json.load(open('$TMP/proj/.claude/state/build-state.json'))['active_slice'].get('session_continuity',{}).get('critical_recorded'))" 2>/dev/null)"
 [ "$sc" = True ] && echo "OK monitor handoff" || { echo "FAIL monitor handoff ($sc)"; fail=1; }
 
+# ── Stop: no debe re-lanzar el turno en bucle (regresión CLAUDE_CODE_STOP_HOOK_BLOCK_CAP) ──
+# En 'Stop' inyectar additionalContext = re-prompt (bloquea el cierre). El warning es solo un
+# nudge mientras se trabaja → en 'Stop' NO debe inyectar (si no, bucle hasta el tope de 9).
+sidW="sessW"; echo "{\"remaining_pct\":30,\"used_pct\":70,\"ts\":$(date +%s)}" > "$TMP/claude-ctx-$sidW.json"
+PW="$TMP/proj-warn-stop"; mkdir -p "$PW/.claude/state" "$PW/.claude/config"
+cp "$TMP/proj/.claude/state/build-state.json" "$PW/.claude/state/build-state.json"
+echo '{"context":{"critical_pct":25,"warning_pct":35,"auto_checkpoint":false}}' > "$PW/.claude/config/build-config.json"
+outW="$(echo "{\"session_id\":\"$sidW\",\"hook_event_name\":\"Stop\"}" \
+  | CLAUDE_PROJECT_DIR="$PW" bash "$ROOT/hooks/build/context-monitor.sh")"
+echo "$outW" | grep -q 'additionalContext' \
+  && { echo "FAIL warning+Stop inyecta (re-prompt → bucle)"; fail=1; } \
+  || echo "OK warning+Stop no inyecta"
+# warning en PostToolUse (trabajando) SÍ debe seguir avisando (regresión: no romper el nudge útil).
+outWP="$(echo "{\"session_id\":\"$sidW\",\"hook_event_name\":\"PostToolUse\"}" \
+  | CLAUDE_PROJECT_DIR="$PW" bash "$ROOT/hooks/build/context-monitor.sh")"
+echo "$outWP" | grep -q 'additionalContext' \
+  && echo "OK warning+PostToolUse sigue avisando" \
+  || { echo "FAIL warning+PostToolUse dejó de avisar"; fail=1; }
+
+# critical en 'Stop': inyecta como MUCHO una vez (la transición que graba el handoff), luego calla.
+sidC="sessC"; echo "{\"remaining_pct\":20,\"used_pct\":80,\"ts\":$(date +%s)}" > "$TMP/claude-ctx-$sidC.json"
+PC="$TMP/proj-crit-stop"; mkdir -p "$PC/.claude/state" "$PC/.claude/config"
+cp "$TMP/proj/.claude/state/build-state.json" "$PC/.claude/state/build-state.json"
+python3 -c "import json;p='$PC/.claude/state/build-state.json';d=json.load(open(p));d['active_slice'].pop('session_continuity',None);json.dump(d,open(p,'w'))"
+echo '{"context":{"critical_pct":25,"warning_pct":35,"auto_checkpoint":false}}' > "$PC/.claude/config/build-config.json"
+outC1="$(echo "{\"session_id\":\"$sidC\",\"hook_event_name\":\"Stop\"}" \
+  | CLAUDE_PROJECT_DIR="$PC" bash "$ROOT/hooks/build/context-monitor.sh")"
+echo "$outC1" | grep -q 'additionalContext' \
+  && echo "OK critical+Stop inyecta la transición (1ª vez)" \
+  || { echo "FAIL critical+Stop no inyecta la transición"; fail=1; }
+outC2="$(echo "{\"session_id\":\"$sidC\",\"hook_event_name\":\"Stop\"}" \
+  | CLAUDE_PROJECT_DIR="$PC" bash "$ROOT/hooks/build/context-monitor.sh")"
+echo "$outC2" | grep -q 'additionalContext' \
+  && { echo "FAIL critical+Stop re-inyecta (bucle)"; fail=1; } \
+  || echo "OK critical+Stop NO re-inyecta (bucle roto)"
+
 # load-build-state (SessionStart): reset once-per-SESSION del guard critical_recorded.
 # Sesión NUEVA (last_session distinto del session_id del payload) -> reabre el guard y
 # persiste el session_id actual.

package/docs/flujo-harness-funcional.md

@@ -1,42 +0,0 @@
-# Cómo trabaja el arnés — flujo funcional
-
-Vista única y sencilla del flujo de trabajo, para explicar a los devs **qué pasa con cada cambio**.
-(Versión detallada/técnica en [flujo-harness.md](./flujo-harness.md).)
-
-```mermaid
-flowchart TD
-    A([Llega un trabajo]) --> B{"¿Qué tipo de cambio es?"}
-
-    B -->|"Arreglo pequeño<br/>(typo, copy, config)"| C["Carril rápido:<br/>rama → cambio → PR"]
-    C --> Z([PR listo para mergear])
-
-    B -->|"Funcionalidad nueva<br/>(una épica)"| D{"¿Está lista para construir?<br/>historias claras, criterios definidos,<br/>base ya construida"}
-    D -->|"No"| E["Vuelve a discovery<br/>a completar la historia"]
-    D -->|"Sí"| F["Construir con pruebas<br/>(escribo el test, luego el código)"]
-
-    F --> G{"¿La app funciona<br/>de punta a punta?"}
-    G -->|"No"| F
-    G -->|"Sí"| H["Revisión final del cambio<br/>+ pantallas iguales al diseño (si hay UI)"]
-
-    H --> I["Abrir PR y dejar todo enlazado<br/>(historia ↔ cambio ↔ código)"]
-    I --> J{"¿Esta épica cierra<br/>una entrega/release?"}
-
-    J -->|"No, sigue otra épica"| A
-    J -->|"Sí"| K["Revisión profunda de la entrega:<br/>seguridad · calidad · UX ·<br/>coherencia · arquitectura"]
-
-    K --> L{"¿Todo el journey completo<br/>funciona con dependencias reales?"}
-    L -->|"No, hay hallazgos"| M["Corregir como un cambio normal"]
-    M --> K
-    L -->|"Sí"| N([Release lista ✅])
-
-    classDef q fill:#fff3cd,stroke:#d39e00,color:#000;
-    classDef ok fill:#d4edda,stroke:#155724,color:#000;
-    class B,D,G,J,L q;
-    class N,Z ok;
-```
-
-## La idea en una frase
-
-- **Cambios chicos** van por un carril rápido.
-- **Cada funcionalidad nueva** se construye completa, con pruebas, verificando que la app **funcione de punta a punta** antes de cerrarla.
-- **De vez en cuando** (al cerrar una entrega) se hace una **revisión profunda** de todo lo acumulado antes de liberar.

package/docs/flujo-harness.md

@@ -1,192 +0,0 @@
-# Flujo del arnés de construcción — `@trycore/spec-build-harness`
-
-Diagrama de flujo end-to-end del harness, modelado al estilo BPMN:
-
-- **◆ XOR** (rombo) = compuerta **exclusiva** (un solo camino).
-- **⬡ AND** (hexágono) = compuerta **paralela** (fork: todos los caminos; join: convergencia/barrera).
-- **▭ Tarea** con su **gate** entre `[ ]`.
-- Aristas punteadas `-.->` = retroceso (gate monótono que vuelve a `false`).
-
-Fuente de verdad: [METODOLOGIA.md](../METODOLOGIA.md). Si algo contradice ese documento, gana la metodología.
-
----
-
-## 1. Vista global (router → inner loop → outer loop)
-
-```mermaid
-flowchart TD
-    START([Trabajo entrante]) --> PRE{{"⬡ Preflight<br/>¿instalado?"}}
-    PRE -->|NOT_INSTALLED| INIT[trycore-build init] --> ROUTER
-    PRE -->|ok| ROUTER
-
-    ROUTER[/"/build:work — Router (classify-and-act)<br/>solo ruteo: no toca estado ni ramas"/]
-    ROUTER --> GW1{"◆ XOR — Decision gate<br/>¿qué carril?"}
-
-    %% --- Rama 1: micro-change ---
-    GW1 -->|"mantenimiento<br/>sin capacidad nueva"| HARD{"◆ XOR — ¿cruza límite duro?<br/>dep nueva / API nueva / dominio·datos"}
-    HARD -->|"sí → escala"| INNER
-    HARD -->|no| MICRO["building-a-micro-change<br/>fix/* | chore/* → cambio → PR<br/>(sin abrir active_slice)"]
-    MICRO --> ENDM([PR mergeado])
-
-    %% --- Rama 2: épica / producto nuevo ---
-    GW1 -->|"capacidad nueva<br/>o límite duro"| INNER[["INNER LOOP<br/>building-a-slice<br/>(ver §2)"]]
-
-    %% --- Rama 3: release gate ---
-    GW1 -->|"cierra línea de release<br/>o ≥2 épicas archivadas"| OUTER[["OUTER LOOP<br/>releasing-a-version<br/>(ver §3)"]]
-
-    INNER --> DEC{"◆ XOR — fase 8<br/>¿correr Release Gate ahora?<br/>(default computado, decide humano)"}
-    DEC -->|"sí (cierra release<br/>o nudge ≥2)"| OUTER
-    DEC -->|no| NEXT([Siguiente épica]) -.-> INNER
-
-    OUTER --> OUTGW{"◆ XOR — ¿todos los gates ✓?"}
-    OUTGW -->|"passed"| REL([Release lista])
-    OUTGW -->|"failed (hallazgos)"| FIX["Fix como slice normal<br/>(building-a-slice)"] -.->|re-corre| OUTER
-
-    classDef xor fill:#fff3cd,stroke:#d39e00,color:#000;
-    classDef andg fill:#d1ecf1,stroke:#0c5460,color:#000;
-    classDef loop fill:#e2e3f3,stroke:#383d6b,color:#000;
-    class GW1,HARD,DEC,OUTGW xor;
-    class PRE andg;
-    class INNER,OUTER loop;
-```
-
----
-
-## 2. Inner loop — `building-a-slice` (pipeline secuencial por épica)
-
-Precondición dura: **scaffold confirmado** (`scaffold.confirmed`) antes de abrir cualquier slice.
-Secuencial (un `active_slice` a la vez), divulgación progresiva, ningún gate se salta.
-
-```mermaid
-flowchart TD
-    S0([Épica EP-XXX entrante]) --> SCAF{"◆ XOR — gate proyecto<br/>scaffold.confirmed?"}
-    SCAF -->|"false"| STOPS["STOP — exige scaffold runnable<br/>(scaffold-guard.sh)"]
-    SCAF -->|"true"| F1
-
-    %% Fase 1: DoR
-    F1["F1 · dor — Definition of Ready<br/>delega: dor-dod-gatekeeper"]
-    F1 --> DORGW{"◆ XOR — ¿DoR ✓?<br/>épica+HU, AC G/W/T, INVEST,<br/>cimiento, tamaño, stack, fixtures"}
-    DORGW -->|"✗"| BACKDISC["Vuelve a discovery<br/>(/trycore:*) — no se abre slice"]
-    DORGW -->|"✓ [gate: dor]"| SIZE{"◆ XOR — gate tamaño<br/>>3 HU ó ≥3 capas?"}
-
-    SIZE -->|"sí"| SUB["Descompone en sub_slices[]<br/>se construyen de a uno<br/>(journey_smoke verde entre cada uno)"]
-    SIZE -->|"no (atómica)"| F2
-    SUB --> F2
-
-    %% Fase 2: change
-    F2["F2 · change — opsx:new + ## Trazabilidad<br/>delega: change-epic-coherence"]
-    F2 --> F2GW{"◆ XOR — ¿enlace change↔épica ✓?"}
-    F2GW -->|"✓ [gate: coherence_link]"| F3
-    F2GW -.->|"✗ retroceso"| F2
-
-    %% Fase 3: TDD
-    F3["F3 · red→green→refactor<br/>TDD por cada escenario AC de cada HU<br/>delega: superpowers:test-driven-development"]
-    F3 --> F3GW{"◆ XOR — ¿suite verde?"}
-    F3GW -.->|"✗ retroceso"| F3
-    F3GW -->|"✓ [gate: tdd]"| F4
-
-    %% Fase 4: smoke + fidelity (UI)
-    F4["F4 · smoke — journey-hasta-aquí end-to-end<br/>runner determinista fuera-de-chat (sesión virgen)"]
-    F4 --> UIGW{"◆ XOR — ¿la épica toca UI?"}
-    UIGW -->|"no"| F4OUT["fidelity = null"]
-    UIGW -->|"sí"| FID["Verificación visual real (MCP chrome-devtools)<br/>screenshot app vs prototipo<br/>delega: ux-fidelity-reviewer"]
-    FID --> FIDGW{"◆ XOR — ¿fidelidad ESTRICTA ✓?<br/>INCONCLUSO = false"}
-    FIDGW -.->|"✗ → false"| FID
-    FIDGW -->|"✓ [gate: fidelity]"| F4OUT
-    F4OUT -->|"[gate: journey_smoke]"| F5FORK
-
-    %% Fase 5: api / data en paralelo (condicional/null)
-    F5FORK{{"⬡ AND — fork (fase api/data)"}}
-    F5FORK --> APIB["api — contratos endpoints<br/>Newman 100% (delega: api-contract-tester)<br/>null si no hay endpoints"]
-    F5FORK --> DATAB["data — invariantes de datos<br/>(delega: data-consistency-checker)<br/>N/A si no toca datos"]
-    APIB --> F5JOIN
-    DATAB --> F5JOIN
-    F5JOIN{{"⬡ AND — join (convergencia)<br/>[gates: api, data]"}}
-
-    %% Fase 6: dod — adversarial THEN dod
-    F5JOIN --> WIRE["F6a · Verificación ADVERSARIAL independiente<br/>(subagente contexto virgen)<br/>asume slice incompleto e intenta refutarlo<br/>delega: wiring-adversarial-verifier"]
-    WIRE --> WIREGW{"◆ XOR — ¿wiring_checklist[] sin items failing?"}
-    WIREGW -.->|"✗ huecos (stub/ruta/AC sin test)"| F3
-    WIREGW -->|"✓ [gate: wiring_verified]"| DOD["F6b · DoD reducido<br/>delega: dor-dod-gatekeeper<br/>(piso declarativo, no el arreglo)"]
-    DOD --> DODGW{"◆ XOR — ¿DoD ✓?<br/>tdd·journey_smoke·coherence_link·<br/>data·api·fidelity·wiring_verified·hooks"}
-    DODGW -.->|"✗ retroceso"| F3
-    DODGW -->|"✓ [gate: dod]"| F7
-
-    %% Fase 7: PR + archive
-    F7["F7 · pr — abrir PR + archivar change EN EL MISMO PR<br/>opsx:archive + opsx:sync<br/>back-reference en épica y HU"]
-    F7 --> ARCH["active_slice → history[] (phase: archived)<br/>active_slice = null"]
-    ARCH --> F8([F8 · decisión Release Gate → §1])
-
-    classDef xor fill:#fff3cd,stroke:#d39e00,color:#000;
-    classDef andg fill:#d1ecf1,stroke:#0c5460,color:#000;
-    classDef stop fill:#f8d7da,stroke:#842029,color:#000;
-    class SCAF,DORGW,SIZE,F2GW,F3GW,UIGW,FIDGW,WIREGW,DODGW xor;
-    class F5FORK,F5JOIN andg;
-    class STOPS,BACKDISC stop;
-```
-
-> **Disciplina de horizonte largo:** cada iteración nace headless / contexto virgen y reconstruye estado
-> desde disco (`build-state.json` + git + logs). `wiring_checklist[]` (1 item por escenario AC y por punto
-> de integración entre capas) nace `failing` y solo pasa a `passing` **tras prueba real ejecutada**.
-> Mientras quede un item `failing`, el cableado NO está hecho.
-
----
-
-## 3. Outer loop — `releasing-a-version` (Release Gate)
-
-Alcance = **diff acumulado** de todas las épicas de la release (merge anterior → `main`).
-Los reviewers se disparan **en paralelo** y devuelven síntesis (protegen el contexto).
-
-```mermaid
-flowchart TD
-    R0([Línea de release identificada]) --> R1["Crear/actualizar releases[] (status: pending)<br/>cruzar con docs/02-user-story-map/"]
-    R1 --> FORK{{"⬡ AND — fork (reviewers en paralelo<br/>sobre el diff acumulado)"}}
-
-    FORK --> SEC["security — sin CRÍTICO/ALTO;<br/>claves server-side; PII no cruda;<br/>salida IA = input no confiable<br/>(security-reviewer)"]
-    FORK --> SME["smell — 4 reglas de Beck<br/>+ code smells sin bloqueantes<br/>(simple-design-reviewer)"]
-    FORK --> UX["ux — Krug + Lighthouse<br/>(null si sin UI)<br/>(ux-krug-reviewer)"]
-    FORK --> COH["coherence — trazabilidad triple<br/>AC↔change↔código, sin huérfanos<br/>(coherence-three-way · opus)"]
-    FORK --> ARCH["stack_arch — arquitectura PRD:<br/>capa IA en frontera server-side;<br/>decisión determinista sin IA<br/>(stack-guardian)"]
-
-    SEC --> JOIN
-    SME --> JOIN
-    UX --> JOIN
-    COH --> JOIN
-    ARCH --> JOIN
-
-    JOIN{{"⬡ AND — join (convergencia de reviewers)"}}
-    JOIN --> INTEG["integration — journey COMPLETO end-to-end<br/>con DEPENDENCIAS REALES (no stubs)<br/>skill verify/run + MCP chrome-devtools"]
-
-    INTEG --> RGW{"◆ XOR — ¿todos los gates ✓ (o null N/A)?"}
-    RGW -->|"✓"| PASS["status: passed<br/>escribir gates + updated_by: releasing-a-version"]
-    RGW -->|"✗ hallazgos bloqueantes"| FAIL["status: failed"]
-    PASS --> RELOK([Release ✅])
-    FAIL --> FIXLOOP["Humano corrige como slice normal<br/>(building-a-slice)"]
-    FIXLOOP -.->|"re-corre Release Gate"| R1
-
-    classDef xor fill:#fff3cd,stroke:#d39e00,color:#000;
-    classDef andg fill:#d1ecf1,stroke:#0c5460,color:#000;
-    classDef gate fill:#d4edda,stroke:#155724,color:#000;
-    class RGW xor;
-    class FORK,JOIN andg;
-    class INTEG gate;
-```
-
-> **`integration` es el gate no negociable.** Sin journey completo con dependencias reales **no hay release**.
-> No se acepta con todo stubbeado.
-
----
-
-## 4. Leyenda de loops y gates
-
-| | Inner loop | Outer loop |
-|---|---|---|
-| Skill | `building-a-slice` | `releasing-a-version` |
-| Unidad | una épica `EP-XXX` | una línea de release |
-| Cadencia | muchas (1 por épica) | pocas (1 por release) |
-| Costo | barato (≤ ~20 min/épica) | pesado (subagentes profundos) |
-| Gates | dor · coherence_link · tdd · journey_smoke · fidelity · api · data · wiring_verified · dod | security · smell · ux · coherence · stack_arch · integration |
-| Estado | `active_slice` + `history[]` | `releases[]` |
-
-**Regla de no duplicación:** cada gate vive en exactamente un loop. El outer no hace TDD ni gates por slice;
-el inner no dispara reviewers pesados.