@trycore/spec-build-harness 0.8.4 → 0.10.0

package/commands/build/claim.md

@@ -0,0 +1,46 @@
+---
+name: "BUILD: Claim"
+description: Reclama trabajo al Agent Orchestrator Runtime (POST /tasks/next) sincronizando el contexto antes, reportando los hashes locales de los archivos gobernados y continuando desde el checkpoint si lo hay. Adaptador delgado sobre slice-ops.sh claim; en modo legacy o dual el slice lo decide el fichero local.
+category: Workflow
+tags: [build-harness, runtime, claim, trycore]
+---
+
+# /build:claim — Pedir la siguiente tarea al runtime
+
+**Entrada (opcional):** `EP-XXX` para pedir una épica concreta. Sin argumento, el runtime elige.
+
+## 1. Reclamar
+
+```bash
+bash .claude/hooks/build/slice-ops.sh claim ${1:+--epic "$1"}
+echo "rc=$?"
+```
+
+El comando ya hace, por ti y en este orden: sincroniza el contexto (no se abre trabajo con
+contexto viejo), reporta los `sha256` locales efectivos de los archivos gobernados (el servidor
+detecta drift), reclama por **POST**, refresca la caché de proyección y rinde el slice.
+
+## 2. Ramificar por el código de salida
+
+| rc | Qué significa | Qué haces |
+|---|---|---|
+| 0 | slice reclamado | si la salida trae **CHECKPOINT**, haz checkout de esa rama y **continúa desde ahí, jamás reinicies**; luego `/build:slice` |
+| 3 | modo `legacy`, o `dual` (el fichero decide) | abre/retoma el slice con el protocolo del fichero (`/build:slice`) |
+| 5 | runtime inalcanzable | **sigue trabajando** con lo local; reintenta al reconectar |
+| 6 | rechazo del servidor (409/401/422) | muestra su razón tal cual; **no reintentes** — token, contexto o proyecto a resolver con el ADMIN |
+| 7 | sin trabajo disponible, o carrera perdida | dilo y termina limpio; ofrece `/build:status` |
+
+## 3. Seguir
+
+```bash
+bash .claude/hooks/build/slice-ops.sh next-step
+```
+
+Ejecuta esa acción, o entra al pipeline con `/build:slice`.
+
+## Guardrails
+
+- **No** armes peticiones al runtime a mano: todo pasa por `slice-ops.sh`.
+- **Un solo slice activo**: reclamar con lease vigente devuelve el mismo slice (idempotente).
+- **Nunca reinicies** un slice que trae checkpoint: es trabajo de otro agente que cayó.
+- Si algo contradice `METODOLOGIA.md`, **gana la metodología**.

package/commands/build/escalate.md

@@ -0,0 +1,36 @@
+---
+name: "BUILD: Escalate"
+description: Registra un bloqueo del slice en el runtime (evento escalation_raised) y devuelve la decisión al humano — recortar, diferir o desbloquear nunca lo decide el modelo. Adaptador delgado sobre slice-ops.sh escalate.
+category: Workflow
+tags: [build-harness, runtime, escalada, gobierno, trycore]
+---
+
+# /build:escalate — Bloqueo que decide una persona
+
+**Entrada:** la razón del bloqueo (una frase concreta y verificable). Opcional: el gate afectado.
+
+## 1. Registrar
+
+```bash
+bash .claude/hooks/build/slice-ops.sh escalate "<razón>" --gate <gate opcional>
+```
+
+Deja el rastro tipado en el runtime (ámbito slice si hay slice reclamado; de proyecto si no).
+Para razones largas, escríbelas en un fichero y usa `--file`.
+
+## 2. Devolver la decisión al humano
+
+Presenta al usuario, en tres líneas: **qué está bloqueado**, **qué evidencia lo demuestra** y
+**las opciones reales** (con su coste). No elijas por él.
+
+> **Regla dura del arnés:** *Producto completo, no MVP.* Recortar o diferir alcance es un
+> **bloqueante explícito** que requiere acuerdo del equipo — jamás una decisión del modelo. Escalar
+> no es rendirse: es negarse a degradar el alcance en silencio.
+
+## Guardrails
+
+- **No** cierres gates «para avanzar» mientras el bloqueo esté vivo.
+- **No** inventes alternativas fuera del alcance acordado.
+- Si el bloqueo es de contexto gobernado (allowlist, política, reglas), la salida es una
+  **propuesta** en el hub que publica un ADMIN, no una edición local del fichero sincronizado.
+- Si algo contradice `METODOLOGIA.md`, **gana la metodología**.

package/commands/build/front.md

@@ -1,6 +1,6 @@
 ---
 name: "BUILD: Front"
-description: Abre y coordina un front paralelo de épicas NO fundacionales y disjuntas en archivos, cada una en su worktree/rama/PR. Delega en la skill managing-parallel-front (selección disjunta vía scripts/lib/front-plan.py, worktrees, merge en orden con re-smoke).
+description: Prepara y coordina un front paralelo de épicas NO fundacionales y disjuntas en archivos, cada una en su worktree/rama/PR con su propio agente registrado. Delega en la skill managing-parallel-front (selección disjunta local vía scripts/lib/front-plan.py, worktrees, merge en orden con re-smoke reportado por cada worktree). Planificar, abrir, drenar y cerrar el front son actos humanos en la consola.
 category: Workflow
 tags: [build-harness, outer-loop, front-paralelo, trycore]
 ---
@@ -8,8 +8,14 @@ tags: [build-harness, outer-loop, front-paralelo, trycore]
 # /build:front — Front paralelo inter-épica
 
 Delega en la skill **managing-parallel-front**. Resumen:
-1. Verifica precondiciones (scaffold confirmado; sin épica foundational abierta).
+1. Verifica precondiciones (scaffold confirmado; sin épica foundational abierta) con
+   `bash .claude/hooks/build/slice-ops.sh status`.
 2. Reúne candidatas no fundacionales listas (DoR pasado) con `layer` y `files_scope`.
-3. Selecciona el conjunto disjunto (`scripts/lib/front-plan.py`), abre worktrees, construye y mergea en orden con re-smoke.
+3. Propón el conjunto disjunto y el `merge_order` (`scripts/lib/front-plan.py`, local) y
+   **preséntaselo a una persona**: abrir el front es acto de gobierno, en la consola del hub.
+4. Un worktree por épica aprobada, cada uno registrado como **agente propio**
+   (`trycore-build init` con el mismo token de proyecto); construye con `/build:slice`.
+5. Tras cada merge, re-smoke y reporte desde el worktree:
+   `bash .claude/hooks/build/release-ops.sh front-integration <front_id> --merge-status … --resmoke …`.
 
 Úsalo solo cuando haya ≥2 épicas no fundacionales disjuntas listas. Para una sola épica, usa `/build:slice`.

package/commands/build/onboard.md

@@ -66,20 +66,23 @@ Voy a leer tu PRD/openspec para proponer valores y confirmar contigo:
    - **Decisiones de alto impacto** (`HIGH_STAKES_DECISIONS`): decisiones que exigen explicabilidad/justificación en la UI.
    - **Fuente de diseño** (`DESIGN_SOURCE`): ¿el producto tiene UI? Si sí, ruta/URL de la fuente
      visual de verdad (prototipo, export de diseño o mockups) y cómo localizar cada pantalla; si no,
-     "N/A". (La escritura del estado `design_source` en `build-state.json` se hace en la Fase 3c.)
+     "N/A". Si hay UI pero **no existe** fuente aún, indica que `/build:prototype` puede generarla
+     tras el onboarding (prototipo HTML de referencia en `docs/05-prototipo/`; la confirmación
+     sigue siendo humana). (El reporte del hecho `design_source` se hace en la Fase 3c.)
 3. Si un punto no aplica al proyecto, registra explícitamente "no aplica" (no lo dejes como `{{...}}`).
 
 ---
 
 ## Fase 2b: Clasificar la capa de las épicas (cimiento vs negocio)
 
-**Primero, resuelve `project_kind`** (lee `.claude/state/build-state.json`):
+**Primero, resuelve `project_kind`** (léelo de `bash .claude/hooks/build/slice-ops.sh status`):
 - `"brownfield"` → el mecanismo del caparazón es **N/A**: no preguntes ni exijas nada de la
   Fase 2c; clasifica capas como siempre y sigue.
 - `null` / ausente (detección ambigua del CLI) → pregunta **una sola vez** vía AskUserQuestion:
   *"¿Este proyecto es una app nueva (greenfield: el caparazón — menús, layout, homepage, login,
-  redirecciones — aún no existe) o ya construida (brownfield)?"*. Escribe `project_kind` y
-  `project_kind_source: "human"` en el estado (valida contra el schema tras escribir).
+  redirecciones — aún no existe) o ya construida (brownfield)?"*. Repórtalo:
+  `bash .claude/hooks/build/slice-ops.sh fact project-kind <greenfield|brownfield> --source human`
+  (rc 3 = modo legacy: escríbelo en el fichero con su protocolo).
 - `"greenfield"` → tras clasificar capas (abajo), continúa a la **Fase 2c**.
 
 El factor que más reduce el consumo de contexto por slice es que el **cimiento** ya esté construido y
@@ -121,11 +124,16 @@ Si `project_kind !== "greenfield"`, salta esta fase (N/A total).
      - **Rechaza** → **STOP** de la fase: deja `foundation.epic: null`, instruye crearla en
        discovery (`/trycore:*`) con la checklist como alcance. El gate del DoR bloqueará las
        épicas de negocio igual hasta que exista y se archive.
-3. **Persistir en el estado**: escribe `foundation.required: true`, `foundation.checklist[]`
-   (todos los ítems con su `applies`, `evidence: ""`), `foundation.epic` (o `null`). Escribe
-   **solo** los campos del schema (`foundation` es `additionalProperties: false`) y **valida
-   contra `build-state.schema.json` tras escribir** (aborta si no valida). Una transición = una
-   escritura.
+3. **Reportar el hecho**: escribe la checklist podada en un fichero temporal
+   (`[{"id","applies","evidence":""}, …]`) y repórtala en una sola transición:
+
+   ```bash
+   bash .claude/hooks/build/slice-ops.sh fact foundation \
+     --required true --epic EP-XXX --checklist-file /tmp/foundation-checklist.json
+   ```
+
+   `--required false` cuando el humano podó todos los ítems (no hay caparazón exigible).
+   En modo legacy (rc 3) se escribe en el fichero con su protocolo.
 
 ---
 
@@ -164,15 +172,22 @@ Si el usuario lo desea y existe `package.json` en el proyecto:
 
 ## Fase 3c: (Si hay UI) Confirmar la fuente de diseño en el estado
 
-Espejo de la confirmación de scaffold, para `design_source` en `build-state.json`:
+Espejo de la confirmación de scaffold, para el hecho `design_source`:
 - Si el producto **tiene UI**: setea `design_source.applies=true`, `source` (el puntero confirmado) y
   `confirmed=true` **solo si** el usuario confirma que la fuente de diseño existe (con `confirmed_by`,
-  `confirmed_at`). El arnés **no genera** el prototipo.
+  `confirmed_at`). El prototipo puede generarse con `/build:prototype` (skill `prototyping-screens`);
+  `confirmed` sigue siendo exclusivamente humano.
 - 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.
+Repórtalo en una sola transición:
+
+```bash
+bash .claude/hooks/build/slice-ops.sh fact design-source \
+  --applies true --source "<ruta/URL confirmada>" --confirmed true --by "<quién confirmó>"
+```
+
+Sin UI: `--applies false` (el mecanismo de fidelidad queda N/A). Guardarraíl: **una transición =
+una llamada**; `--confirmed true` exige `--by`: confirmar es acto humano.
 
 ---
 
@@ -221,6 +236,40 @@ CLAUDE.md actualizado. Auto-memory escrita. Los agentes de calidad ya leen tu do
 
 ---
 
+## Fase 5: (Con runtime) Preparar el bundle de grafo para el ADMIN
+
+El grafo del backlog (épicas, capas, `files_scope`, dependencias, historias, líneas de release) vive
+en el runtime. **Importarlo es un acto de gobierno**: la superficie exige sesión de ADMIN y rechaza
+el token de agente. El arnés **prepara y valida**; una persona sube.
+
+1. Extrae el grafo de los artefactos de discovery ya leídos (`docs/03-backlog/epicas.md`,
+   `docs/02-user-story-map/`, `docs/04-historias/`) a un JSON:
+
+   ```json
+   {"project_ref": "<nombre del proyecto>",
+    "epics": [{"code": "EP-001", "title": "…", "layer": "foundational",
+               "files_scope": ["src/core/**"], "depends_on": [],
+               "stories": [{"id": "HU-001", "title": "…"}]}],
+    "release_lines": [{"id": "R1-mvp", "epics": ["EP-001"]}]}
+   ```
+
+2. Normalízalo y valídalo (determinista, nunca sube nada):
+
+   ```bash
+   python3 .claude/scripts/lib/graph-bundle.py < /tmp/epics.json > /tmp/graph-bundle.json
+   ```
+
+3. **Lee los avisos** (`warnings` del bundle y stderr): capa ausente, dependencia inexistente,
+   ciclo, línea de release que referencia una épica desconocida. Corrígelos en discovery — el arnés
+   **no inventa** el grafo ni edita `epicas.md` (salvo el carve-out de la épica caparazón, Fase 2c).
+
+4. **Entrega el fichero a un ADMIN** con esta instrucción literal: *«súbelo en la consola del hub,
+   pantalla de import del proyecto»*. El import es idempotente y **reanuda** si falló a medias.
+
+5. Modo `legacy` o sin credenciales: salta esta fase; el grafo sigue viviendo en los documentos.
+
+---
+
 ## Guardrails
 
 - No avances sin confirmar los 7 puntos. Si el usuario omite alguno, repregunta o marca "no aplica".

package/commands/build/prototype.md

@@ -0,0 +1,23 @@
+---
+name: "BUILD: Prototype"
+description: Genera o amplía el prototipo HTML de referencia (la fuente de diseño / DESIGN_SOURCE) en docs/05-prototipo/. Dos modos — greenfield (prototipo inicial desde los docs de discovery + dirección estética elegida por el humano) y feature (pantallas de una épica nueva extraídas en vivo del UI ya implementado). Delega en la skill prototyping-screens. La confirmación de design_source sigue siendo humana.
+category: Workflow
+tags: [build-harness, outer-loop, prototipo, design-source, trycore]
+---
+
+# /build:prototype — Prototipo HTML de referencia
+
+Delega en la skill **prototyping-screens**. Uso:
+
+- `/build:prototype` — modo **greenfield** (o detección automática): prototipo inicial completo.
+  Inventario de pantallas desde PRD/mapa/historias → confirmación humana → dirección estética
+  (manual de marca o 2-3 variantes a elección humana) → generación por lotes con auto-verificación.
+- `/build:prototype <épica>` — modo **feature**: pantallas nuevas de esa épica, coherentes con el
+  UX/UI ya implementado. **Precondición dura**: app corriendo + MCP de inspección de UI (p.ej.
+  chrome-devtools); sin ellos hace STOP (la extracción viva de CSS computado no se degrada).
+
+Es **outer-loop**: córrelo antes de abrir slices (como `/build:architect`). Produce
+`docs/05-prototipo/` (DESIGN.md, tokens.css, manifest.json, pantallas/) y, en greenfield con
+aprobación humana, reporta el hecho `design_source` al runtime
+(`slice-ops.sh fact design-source …`). **La skill genera; el humano aprueba**: la confirmación de la
+fuente de diseño y el `estado: "aprobada"` del manifest nunca se auto-marcan.

package/commands/build/reflect.md

@@ -33,12 +33,41 @@ Stop aquí si no está instalado o si falta `python3`.
 
 ## Fase 1: Identificar slices sin reflexionar
 
-Lee `.claude/state/build-state.json` y filtra las entradas de `history[]` con `reflected != true`:
+El origen del dato depende del **modo** (igual que consume `reflect-nudge.sh`): en `runtime` puro el
+fichero local NO se lee — puede faltar o quedar fósil (`runtime-protocol.md`) — y el cómputo lo hace el
+servidor sobre **todo el proyecto**; en `legacy`/`dual` el fichero sigue siendo primario.
 
 ```bash
-python3 - <<'PY'
+MODE="$(bash .claude/hooks/build/slice-ops.sh mode)"
+if [ "$MODE" = "runtime" ]; then
+  # runtime: NO se lee el fichero legacy (fósil/ausente). El servidor ya agregó el nudge
+  # "reflect" sobre todo el proyecto; lo leemos de la línea `nudges:` de `status`, el mismo
+  # dato que consume reflect-nudge.sh.
+  bash .claude/hooks/build/slice-ops.sh status | python3 - <<'PY'
+import json, sys
+nudges = []
+for line in sys.stdin:
+    if line.startswith("nudges:"):
+        try:
+            nudges = json.loads(line.split(":", 1)[1].strip())
+        except Exception:
+            nudges = []
+        break
+pend = [n.get("message") for n in nudges
+        if isinstance(n, dict) and n.get("kind") == "reflect" and n.get("message")]
+if pend:
+    for m in pend:
+        print(m)
+    print("TOTAL_RUNTIME", len(pend))
+else:
+    print("TOTAL 0")
+PY
+else
+  # legacy o dual: el fichero es primario en ambos modos (en dual, reconcile-build-state.py
+  # lo mantiene sincronizado — runtime-protocol.md); filtra `history[]` con `reflected != true`.
+  python3 - <<'PY'
 import json, os, sys
-p = ".claude/state/build-state.json"
+p = ".claude/state/build-state.json"  # legacy: ruta local, no runtime
 if not os.path.exists(p):
     print("NO_STATE"); sys.exit(0)             # estado ausente → nada que reflexionar, salir
 try:
@@ -50,13 +79,21 @@ 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
+fi
 ```
 
-**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 `NO_STATE`** (solo aplica en `legacy`/`dual`): 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.
+
+**En `runtime`** el servidor solo entrega el **conteo agregado** (`TOTAL_RUNTIME`), sin `epica`/
+`openspec_change`/`branch` por slice (el cliente no puede enumerarlos hoy). Si `TOTAL_RUNTIME > 0`,
+dile al humano cuántos hay pendientes según el runtime y **pregúntale con AskUserQuestion** qué slice
+(`EP-XXX` + `openspec_change`) reflexionar primero; no adivines ni asumas "el más reciente" sin ese dato.
 
-Si hay varios, procésalos **de uno en uno** (el más reciente primero), o pregunta al usuario cuál.
+Si tienes el detalle por slice (`legacy`/`dual`) y hay varios, procésalos **de uno en uno** (el más
+reciente primero), o pregunta al usuario cuál.
 
 ---
 
@@ -119,42 +156,25 @@ Para las viñetas aprobadas, **inserta** (no reemplaces) dentro del bloque marca
 
 ## Fase 5: Estampar el slice como reflexionado
 
-Marca el/los slice(s) procesado(s) en `history[]` para que el nudge calle. Usa la hora UTC real:
+El estampado es una transición de dominio más: la hace el ejecutable, no un `json.dump` a mano.
 
 ```bash
-NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-python3 - "$NOW" "<openspec_change>" <<'PY'
-import json, sys, os, tempfile
-now, change = sys.argv[1], sys.argv[2]
-p = ".claude/state/build-state.json"
-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 isinstance(h, dict) and h.get("openspec_change") == change:
-        h["reflected"] = True
-        h["reflected_at"] = now
-# 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
+MODE="$(bash .claude/hooks/build/slice-ops.sh mode)"
+if [ "$MODE" = "legacy" ]; then
+  # Modo legacy (v0.8.5): se estampa `reflected`/`reflected_at` en la entrada de history[]
+  # del fichero, con escritura atómica y validación contra el schema local. Protocolo en
+  # skills/building-a-slice/references/state-protocol.md.
+  echo "legacy: estampa reflected=true en la entrada de history[] del fichero"
+else
+  bash .claude/hooks/build/slice-ops.sh progress \
+    "reflexión completada de <EP-XXX> (<openspec_change>): <N> aprendizajes aplicados"
+  bash .claude/hooks/build/slice-ops.sh fact harness-phase building >/dev/null 2>&1 || true
+fi
 ```
 
-Estampa **aunque no haya habido aprendizajes** (reflexionar y no encontrar nada también cierra el
-ciclo). Repite por cada slice procesado.
+En `dual`/`runtime` el hecho «este slice ya se reflexionó» vive en el event stream del runtime:
+el nudge de `reflect-nudge.sh` lo computa el servidor sobre **todo** el proyecto, no sobre este
+clon (por eso el nudge dejó de mentir con 31/33 slices sin estampar).
 
 ---
 
@@ -165,7 +185,7 @@ ciclo). Repite por cada slice procesado.
 
 Slice:        <EP-XXX> (<openspec_change>)
 Aprendizajes: <N agregados a CLAUDE.md> · <M a auto-memory> · <0 si solo se estampó>
-Estampado:    reflected=true
+Estampado:    reportado al runtime (o reflected=true en modo legacy)
 
 Pendientes de reflexión restantes: <K>
 ```

package/commands/build/release.md

@@ -27,9 +27,9 @@ 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[]`).
+Consulta el estado con `bash .claude/hooks/build/slice-ops.sh status` y cruza con
+`docs/02-user-story-map/` para resolver qué épicas componen la release. No hay entrada que crear: los
+veredictos que reporte `releasing-a-version` pueblan la línea de release en el runtime.
 
 ---
 
@@ -67,10 +67,12 @@ 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**
+- Reporta **cada** gate medido con
+  `bash .claude/hooks/build/release-ops.sh verdict <line> <gate> <pass|fail|na> --evidence-file f`
+  (`na` cuando no aplica). El **agregado** lo hace el runtime: **parciales no promueven a `passed`**.
+- Con los seis reportados y en verde, recuérdale al humano que **el cierre es suyo**
+  (`release-ops.sh close-hint <line>`): el agente no cierra releases.
+- Algo ✗ → los hallazgos bloqueantes se corrigen **como un slice normal**
   (`/build:slice` / `building-a-slice`) y se **re-corre** el Release Gate.
 
 ---
@@ -81,4 +83,5 @@ reviewer. Es el gate **no negociable**: sin él, no hay release.
   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.
+- **El agente reporta, el humano cierra** (spec §2): ninguna llamada de cierre con token de agente.
 - Delega en `releasing-a-version`; **no** la reimplementa. Si algo contradice `METODOLOGIA.md`, gana la metodología.

package/commands/build/resume.md

@@ -1,29 +1,49 @@
 ---
 name: "BUILD: Resume"
-description: Rehidrata el slice activo desde disco tras un reinicio de contexto (reconcilia estado, muestra continuidad y la siguiente acción).
+description: Rehidrata el slice activo tras un reinicio de contexto — refresca la proyección desde el runtime (o reconcilia el fichero en modo legacy), muestra la continuidad y la siguiente acción determinista.
 category: Workflow
 tags: [build-harness, resume, rehydrate, trycore]
 ---
 
 # /build:resume — Retomar sin pérdida
 
-Objetivo: reconstruir el contexto de construcción **desde disco**, no desde la conversación.
+Objetivo: reconstruir el contexto de construcción **desde fuera de la conversación** — del
+runtime en `dual`/`runtime`, del disco en `legacy`.
 
 ## Pasos
 
-1. **Reconciliar**: `python3 .claude/hooks/build/reconcile-build-state.py .claude/state/build-state.json`
-   (degrada wiring sin evidencia; anota branch drift; fail-open).
+1. **Averigua el modo y refresca**:
 
-2. **Leer estado**: `.claude/state/build-state.json`. Extraer `active_slice`, sus `gates`, `wiring_checklist`, `progress_log`, `session_continuity`, y `parallel_front` si existe.
+   ```bash
+   MODE="$(bash .claude/hooks/build/slice-ops.sh mode)"
+   bash .claude/hooks/build/slice-ops.sh status
+   ```
 
-3. **Determinar la siguiente acción por prioridad** (la primera que aplique):
-   1. `session_continuity.resume_hint` presente → ejecutarla.
-   2. Items de `wiring_checklist` en `failing` → cablear el primero (con prueba real; no marcar passing sin evidencia).
-   3. `sub_slices` con `status!=done` → construir el siguiente.
-   4. Según `active_slice.phase` → continuar el pipeline (delegar en la skill `building-a-slice`).
+   - `legacy` → reconcilia el fichero como en v0.8.5: `python3 .claude/hooks/build/reconcile-build-state.py .claude/state/build-state.json`
+     (degrada wiring sin evidencia; anota branch drift; fail-open) y sigue
+     `building-a-slice/references/state-protocol.md`.
+   - `dual|runtime` → `status` ya trae slice, fase, gates, wiring `failing`, contexto, lease y
+     cola pendiente.
 
-4. **Si hay `parallel_front`**: delegar en la skill `managing-parallel-front` (Task 12+).
+2. **Determina la siguiente acción**:
 
-5. Registrar un hito en `progress_log[]` (`by: /build:resume`).
+   ```bash
+   bash .claude/hooks/build/slice-ops.sh next-step
+   ```
 
-**Regla dura:** mientras quede un item `failing`, el slice NO está terminado. Nunca marques `passing` sin evidencia de ejecución real.
+   La prioridad es determinista y la calcula el cliente: `resume_hint` → items de wiring en
+   `failing` → sub-slice pendiente → primer gate abierto por fase. **Ejecútala.**
+
+3. **Si el `status` muestra `⚠ lease` (lease perdido)**: haz `slice-ops.sh checkpoint --note …`,
+   **detén** el trabajo y vuelve a reclamar (`slice-ops.sh claim`) antes de cerrar nada más.
+
+4. **Si el `status` muestra la proyección `⚠ stale`** (sin refrescar) y el runtime no responde:
+   sigue trabajando con lo que hay — offline nunca bloquea — y no cierres gates a ciegas.
+
+5. **Front paralelo**: si este worktree pertenece a un front, delega en la skill
+   `managing-parallel-front`.
+
+6. Deja el hito: `bash .claude/hooks/build/slice-ops.sh progress "retomado por /build:resume: <qué sigue>"`.
+
+**Regla dura:** mientras quede un item `failing`, el slice NO está terminado. Nunca marques
+`passing` sin evidencia de ejecución real (`--evidence-file`).

package/commands/build/slice.md

@@ -29,25 +29,20 @@ 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
+MODE="$(bash .claude/hooks/build/slice-ops.sh mode)"
+bash .claude/hooks/build/slice-ops.sh status
 ```
 
-- `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
+- `MODE=legacy` → el fichero es primario: sigue `building-a-slice/references/state-protocol.md`
+  (comportamiento v0.8.5 exacto, sin red).
+- `MODE=dual|runtime` → el estado vive en el runtime
+  (`building-a-slice/references/runtime-protocol.md`).
+- **Sin slice activo** (`slice: ninguno reclamado`): en `runtime`, recláma­lo con
+  `bash .claude/hooks/build/slice-ops.sh claim --epic EP-XXX` — `rc 7` = sin trabajo disponible,
+  `rc 6` = rechazo del servidor (muestra su razón, no reintentes). En `legacy|dual` (rc 3) abre el
+  slice por **dor** con el protocolo del fichero.
+- **Con slice activo** → **reanuda donde toca**:
+  `bash .claude/hooks/build/slice-ops.sh next-step` (no abras otro: el modelo es
   secuencial, un solo slice activo).
 
 ---
@@ -56,14 +51,19 @@ PY
 
 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.
-- **Caparazón (solo greenfield)**: si `project_kind === "greenfield"` y `foundation.required === true`
-  y la épica objetivo es `layer: business` mientras `foundation.completed_at` no esté estampado (la
-  caparazón `foundation.epic` archivada con evidencia) → **STOP**: solo la épica caparazón
-  (`foundation.epic`) u otra fundacional puede abrir. Lo valida en detalle el `dor-dod-gatekeeper`
-  (criterio 7-bis). Brownfield → N/A, no preguntes.
+Los tres hechos salen de la línea `hechos:` que imprime `slice-ops.sh status` (`scaffold_confirmed`,
+`design_source_confirmed`, `project_kind`, `foundation_done` — del runtime en `dual`/`runtime`; del
+fichero en `legacy`):
+
+- **scaffold** confirmado (`scaffold_confirmed`). Si no → **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, **fuente de diseño** confirmada (`design_source_confirmed`, Fase 0-bis). Si
+  no → **STOP** igual.
+- **Caparazón (solo greenfield)**: si `project_kind` es `greenfield` y `foundation_done` es `false`, y
+  la épica objetivo es `layer: business` → **STOP**: solo la épica caparazón u otra fundacional puede
+  abrir. `status` no identifica **cuál** es la épica caparazón (eso vive hoy en el fichero legacy,
+  leído directo por `dor-dod-gatekeeper`); pregunta o consúltalo ahí. Lo valida en detalle el
+  `dor-dod-gatekeeper` (criterio 7-bis). Brownfield → N/A, no preguntes.
 
 El hook `scaffold-guard.sh` respalda esto en tiempo real.
 
@@ -91,8 +91,13 @@ 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`.
+- **Un solo slice activo** (secuencial). No abras un segundo mientras haya uno reclamado; en
+  `runtime` el propio claim es idempotente y devuelve el mismo slice con el lease vigente.
+- **Todo acto de dominio pasa por `slice-ops.sh`**; en modo `runtime` no se escribe el fichero local.
+- **Orden estricto de gates**; un gate no se salta. `dod` exige `wiring_verified: true`. El bucle
+  adversarial tiene condición de parada: **máximo 2 pasadas completas por slice** (pasadas 2+
+  incrementales por `verified_at_sha`; lo diferido se declara en el PR y lo custodia el Release
+  Gate — ver METODOLOGIA §1-bis).
 - **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/status.md

@@ -0,0 +1,35 @@
+---
+name: "BUILD: Status"
+description: Informe del agente y su trabajo — modo, proyecto, slice activo, gates, wiring failing, versión de contexto, lease y cola de eventos pendientes. Solo lectura, nunca bloquea. Adaptador delgado sobre slice-ops.sh status.
+category: Workflow
+tags: [build-harness, runtime, status, trycore]
+---
+
+# /build:status — ¿Dónde estamos?
+
+## 1. Informe
+
+```bash
+bash .claude/hooks/build/slice-ops.sh status
+```
+
+Refresca la proyección desde `/agent/context` y muestra: **modo**, proyecto y agente, slice activo
+con fase/gates/wiring, rama y change, versión de contexto (`✓ vN` o `⚠ stale`), lease y número de
+eventos pendientes en la cola. En modo `legacy` dice que la fuente de verdad es el fichero local y
+no consulta nada.
+
+Con `--no-refresh` no toca la red (útil sin conexión).
+
+## 2. Leer las señales
+
+- `⚠ stale` → la proyección no se pudo refrescar: los guards siguen operando con lo último
+  sincronizado. **No cierres gates a ciegas**; reintenta cuando vuelva el runtime.
+- `⚠ lease perdido` → haz `slice-ops.sh checkpoint --note …`, detén el trabajo y vuelve a reclamar.
+- `cola: N evento(s)` con N creciendo y sin bajar → el daemon no está despachando; revisa
+  `.claude/state/heartbeat-status.json` (y, en el sub-slice D, `trycore-build doctor`).
+
+## Guardrails
+
+- **Solo lectura**: este comando no transiciona nada.
+- El estado de **la flota** (otros agentes, otros slices, releases y fronts del proyecto) vive en la
+  consola del hub: es superficie humana, no de agente.