@trycore/spec-build-harness 0.8.5 → 0.11.0

package/hooks/build/lib/runtime-ops.sh

@@ -0,0 +1,227 @@
+#!/usr/bin/env bash
+# runtime-ops.sh — base común de las OPERACIONES DE DOMINIO que conducen las skills
+# [EP-OR-08-C]. Los hooks (sub-slice B) observan; esto transiciona: claim, veredictos,
+# checkpoints, submit, archive y hechos de proyecto. Lo usan hooks/build/slice-ops.sh y
+# hooks/build/release-ops.sh, que son INVOCADOS por las skills (no hooks registrados).
+#
+# Aquí vive el ÚNICO sitio del cliente bash donde se escriben rutas del runtime: si el
+# re-volcado de OpenAPI (EP-OR-13) mueve un endpoint, se toca este fichero y nada más.
+#
+# Diseño fail-open, igual que runtime-client.sh: ninguna función lanza; ante red caída,
+# python3 ausente o JSON corrupto se degrada a un valor seguro o a un rc distinguible.
+
+source "$(dirname "${BASH_SOURCE[0]}")/projection.sh"
+source "$(dirname "${BASH_SOURCE[0]}")/agent-context.sh"
+
+# ── Códigos de salida (contrato con las skills; la prosa ramifica sobre estos números) ──
+OPS_RC_OK=0
+OPS_RC_USAGE=2
+OPS_RC_LEGACY=3
+OPS_RC_NO_SLICE=4
+OPS_RC_OFFLINE=5
+OPS_RC_REJECTED=6
+OPS_RC_NO_WORK=7
+
+# Tope de texto libre que el cliente manda al servidor (evidencias, notas): el protocolo §8
+# dice que el servidor rechaza payloads sobredimensionados; se trunca aquí, marcándolo.
+# [#44] El límite real del hub es 2000 (event_catalog._MAX_NOTE y VerdictIn.evidence):
+# 1970 + los 27 caracteres del marcador de truncado de ops_json_str_file queda por debajo.
+# El 4000 anterior producía rechazos en evidencias largas.
+OPS_MAX_TEXT=1970
+
+# Gates canónicos (se validan en el cliente: un nombre inventado por el modelo no llega
+# a la red — compuerta mecánica barata, sin round-trip).
+OPS_SLICE_GATES="dor coherence_link tdd journey_smoke fidelity api data wiring_verified dod"
+OPS_RELEASE_GATES="security smell ux coherence stack_arch integration"
+
+# ── Tabla de rutas ──
+OPS_PATH_CLAIM="/tasks/next"
+OPS_PATH_CHECKPOINTS="/checkpoints"
+ops_path_verdicts() { echo "/slices/$1/verdicts"; }
+ops_path_submit() { echo "/slices/$1/submit"; }
+ops_path_release_verdicts() { echo "/releases/$1/verdicts"; }
+ops_path_front_integration() { echo "/fronts/$1/members/$2/integration"; }
+ops_path_mirror() { echo "/projects/$1/mirror/transitions"; }
+ops_path_proposals() { echo "/projects/$1/context/agent-proposals"; }
+
+ops_mode() { runtime_mode; }
+
+# ops_slice_id — id del slice activo según la caché de proyección ("" si no hay).
+ops_slice_id() { projection_get active_slice.slice_id ""; }
+
+# ops_urlenc <texto> — percent-encoding para segmentos de ruta (una línea de release puede
+# llevar espacios o barras). Sin python3 devuelve el texto tal cual: peor URL, nunca excepción.
+ops_urlenc() {
+  command -v python3 >/dev/null 2>&1 || { printf '%s' "$1"; return; }
+  printf '%s' "$1" | python3 -c 'import sys,urllib.parse; sys.stdout.write(urllib.parse.quote(sys.stdin.read(), safe=""))' 2>/dev/null || printf '%s' "$1"
+}
+
+# ops_json_str <texto> — imprime el texto como cadena JSON (comillas incluidas). El texto
+# viaja por STDIN, nunca por argv: así ni ARG_MAX ni el quoting de bash lo limitan.
+ops_json_str() {
+  command -v python3 >/dev/null 2>&1 || { printf '""'; return; }
+  printf '%s' "$1" | python3 -c 'import json,sys; sys.stdout.write(json.dumps(sys.stdin.read(), ensure_ascii=False))' 2>/dev/null || printf '""'
+}
+
+# ops_json_str_file <fichero> [max=OPS_MAX_TEXT] — igual, leyendo de un fichero y truncando
+# al tope (marcado en el propio texto para que el servidor y el humano lo vean).
+ops_json_str_file() {
+  local f="$1" max="${2:-$OPS_MAX_TEXT}"
+  [ -f "$f" ] || { printf '""'; return; }
+  command -v python3 >/dev/null 2>&1 || { printf '""'; return; }
+  python3 - "$f" "$max" <<'PY' 2>/dev/null || printf '""'
+import json,sys
+try:
+    t=open(sys.argv[1], encoding="utf-8", errors="replace").read()
+except Exception:
+    t=""
+m=int(sys.argv[2])
+if len(t) > m:
+    t = t[:m] + "\n…[truncado por el cliente]"
+sys.stdout.write(json.dumps(t, ensure_ascii=False))
+PY
+}
+
+# ops_tmpjson <json> — materializa un JSON en un fichero temporal e imprime su ruta.
+# Los payloads viajan a python3 y a curl POR FICHERO (regla dura del repo: nunca por argv).
+ops_tmpjson() {
+  local f
+  f="$(mktemp)" || return 1
+  printf '%s' "$1" > "$f"
+  echo "$f"
+}
+
+# ops_context_hashes — sha256 EFECTIVO local de cada archivo gobernado del lock
+# (protocolo §3 regla 3: el servidor detecta drift/manipulación local comparándolos con los
+# suyos). Se hashea el fichero real, NUNCA se repite el sha del lock: repetirlo convertiría
+# el reporte en un espejo del servidor y el drift sería indetectable.
+# Forma del reporte [#36]: el hub (`TasksNextIn.context_hashes: dict[str, str] | None`)
+# exige un DICT {path: sha} — la lista [{"path":…,"sha256":…}] era 422 dict_type en TODO
+# claim. Fallback {} (nunca []); fichero ilegible => "" (el dict no admite null en valores).
+ops_context_hashes() {
+  local lock root
+  lock="$(runtime_lock_path)"
+  root="$(config_root)"
+  command -v python3 >/dev/null 2>&1 || { echo "{}"; return; }
+  python3 - "$lock" "$root" <<'PY' 2>/dev/null || echo "{}"
+import json,sys,os,hashlib
+lock,root=sys.argv[1],sys.argv[2]
+try:
+    files=json.load(open(lock)).get("files") or []
+except Exception:
+    files=[]
+out={}
+for f in files:
+    if not isinstance(f,dict):
+        continue
+    p=f.get("path")
+    if not isinstance(p,str) or not p:
+        continue
+    full=os.path.join(root,".claude",p)
+    sha=""
+    try:
+        h=hashlib.sha256()
+        with open(full,"rb") as fh:
+            for chunk in iter(lambda: fh.read(65536), b""):
+                h.update(chunk)
+        sha=h.hexdigest()
+    except Exception:
+        sha=""
+    out[p]=sha
+print(json.dumps(out,ensure_ascii=False))
+PY
+}
+
+# ops_local_slice_ref — identidad del slice según el FICHERO local. Solo tiene sentido en
+# modo `dual`, donde el fichero es primario y el runtime crea la identidad por el mismo
+# camino que el import (spec §4.1-D). En `runtime` no se usa: allí manda la caché.
+# Imprime {} si no hay fichero, no hay python3 o no hay slice activo — nunca lanza.
+ops_local_slice_ref() {
+  local p
+  p="$(config_root)/.claude/state/build-state.json"
+  [ -f "$p" ] || { echo "{}"; return; }
+  command -v python3 >/dev/null 2>&1 || { echo "{}"; return; }
+  python3 - "$p" <<'PY' 2>/dev/null || echo "{}"
+import json,sys
+try:
+    d=json.load(open(sys.argv[1]))
+    s=d.get("active_slice") or {}
+except Exception:
+    s={}
+print(json.dumps({"epic_code": s.get("epica"),
+                  "openspec_change": s.get("openspec_change"),
+                  "branch": s.get("branch"),
+                  "phase": s.get("phase")}, ensure_ascii=False))
+PY
+}
+
+# ops_enqueue_from_file <type> <payload_file> [slice_id] — encola un evento cuyo payload
+# puede ser grande (checklist de wiring, evidencia, contenido propuesto): el payload se lee
+# del FICHERO dentro de python3, así que no pasa por argv (a diferencia de
+# runtime_enqueue_event, que sigue sirviendo para payloads pequeños).
+ops_enqueue_from_file() {
+  local type="$1" pfile="$2" slice_id="${3:-}" dir
+  dir="$(runtime_outbox_dir)"
+  mkdir -p "$dir"
+  command -v python3 >/dev/null 2>&1 || return 1
+  python3 - "$dir" "$type" "$pfile" "$slice_id" <<'PY' 2>/dev/null || return 1
+import json,sys,os,tempfile,uuid,datetime
+dir_,typ,pfile,slice_id=sys.argv[1],sys.argv[2],sys.argv[3],sys.argv[4]
+try:
+    payload=json.load(open(pfile))
+except Exception:
+    payload={}
+cid=str(uuid.uuid4())
+ts=datetime.datetime.now(datetime.timezone.utc)
+d={"client_event_id":cid,"type":typ,"payload":payload,
+   "enqueued_at":ts.strftime("%Y-%m-%dT%H:%M:%S.%fZ")}
+if slice_id:
+    d["slice_id"]=slice_id
+fname=os.path.join(dir_, ts.strftime("%Y%m%d%H%M%S%f")+"-"+cid+".json")
+fd,tmp=tempfile.mkstemp(dir=dir_,prefix=".outbox.",suffix=".tmp")
+try:
+    with os.fdopen(fd,"w") as out:
+        json.dump(d,out,indent=2,ensure_ascii=False); out.flush(); os.fsync(out.fileno())
+    os.replace(tmp,fname)
+except Exception:
+    try: os.unlink(tmp)
+    except OSError: pass
+    raise
+PY
+  runtime_outbox_enforce_cap >/dev/null
+}
+
+# ops_mirror <kind> <payload_file> — ingesta espejo del modo `dual` (spec §4.1-D). El
+# fichero local sigue siendo primario: un rechazo del reducer NO bloquea el trabajo, queda
+# como discrepancia del comparador. rc 0 aceptado · 5 no se pudo (red) · 6 rechazado.
+ops_mirror() {
+  local kind="$1" pfile="$2" pid body resp status tmp
+  pid="$(runtime_field project_id)"
+  [ -n "$pid" ] || return 5
+  command -v python3 >/dev/null 2>&1 || return 5
+  tmp="$(mktemp)" || return 5
+  python3 - "$kind" "$pfile" > "$tmp" <<'PY' 2>/dev/null
+import json,sys,datetime
+kind,pfile=sys.argv[1],sys.argv[2]
+try:
+    payload=json.load(open(pfile))
+except Exception:
+    payload={}
+print(json.dumps({"kind":kind,"payload":payload,"origin":"mirror",
+                  "occurred_at":datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")},
+                 ensure_ascii=False))
+PY
+  body="$(cat "$tmp" 2>/dev/null)"
+  rm -f "$tmp"
+  [ -n "$body" ] || return 5
+  resp="$(runtime_post "$(ops_path_mirror "$pid")" "$body")"
+  status="$(runtime_http_status)"
+  case "$status" in
+    200|201|202) return 0 ;;
+    409|422)
+      echo "⚠ el espejo rechazó «${kind}»: $resp" >&2
+      echo "  (queda como discrepancia del comparador dual; el trabajo local NO se bloquea)" >&2
+      return 6 ;;
+    *) return 5 ;;
+  esac
+}

package/hooks/build/lib/state-io.sh

@@ -1,7 +1,11 @@
 #!/usr/bin/env bash
-# state-io.sh — helpers compartidos: rutas, lectura de config y patch atómico del estado.
+# state-io.sh — helpers compartidos: rutas y patch atómico del estado.
+# config_get vive en lib/config.sh [EP-OR-08-A] — se re-exporta sourceándolo aquí para
+# que los llamadores existentes sigan funcionando sin cambios.
 # Diseño: fail-open. Nunca lanza; ante fallo deja el archivo intacto.
 
+source "$(dirname "${BASH_SOURCE[0]}")/config.sh"
+
 state_path() {
   # CLAUDE_PROJECT_DIR es la señal autoritativa que Claude Code fija en los hooks;
   # git rev-parse solo aplica como fallback para invocación manual/dev (sin ese env).
@@ -9,23 +13,6 @@ state_path() {
   echo "$root/.claude/state/build-state.json"
 }
 
-# config_get <clave.punteada> <default>
-config_get() {
-  local key="$1" def="$2" file
-  file="${BUILD_CONFIG_FILE:-$(dirname "$(state_path)")/../config/build-config.json}"
-  command -v python3 >/dev/null 2>&1 || { echo "$def"; return; }
-  python3 - "$file" "$key" "$def" <<'PY' 2>/dev/null || echo "$def"
-import json,sys
-file,key,default=sys.argv[1],sys.argv[2],sys.argv[3]
-try:
-    d=json.load(open(file))
-    for part in key.split("."): d=d[part]
-    print(d if not isinstance(d,bool) else str(d).lower())
-except Exception:
-    print(default)
-PY
-}
-
 # state_atomic_patch <state-file> <expr-python-que-muta-`d`>
 # Ejecuta la expresión con `d` = dict del estado; escribe atómico solo si válido.
 state_atomic_patch() {

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

@@ -1,9 +1,71 @@
 #!/usr/bin/env bash
 # load-build-state.sh — SessionStart
 # Inyecta al contexto: rama actual, harness_phase, slice activo y gates abiertos.
-# Además sincroniza harness_phase (authoring -> active) según exista package.json.
+# [EP-OR-08-B] Dos caminos según runtime_mode():
+#   - legacy|dual: comportamiento v0.8.5 exacto (el fichero es primario; además sincroniza
+#     harness_phase y resetea el guard de handoff por sesión).
+#   - runtime: render desde la caché de proyección; NO se sourcea state-io.sh ni se invoca
+#     el reconciliador (la maquinaria legacy no se carga en runtime, spec §4.2-E).
 set -uo pipefail
-source "$(dirname "${BASH_SOURCE[0]}")/lib/state-io.sh"
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/runtime-client.sh"
+source "$HERE/lib/projection.sh"
+
+# render_runtime — pinta el mismo bloque de contexto que el camino legacy, pero con los
+# hechos del runtime. Todo lo que falte degrada a un texto neutro: jamás rompe el arranque.
+render_runtime() {
+  local root branch slice gates wiring subs hint ver age
+  root="$(config_root)"
+  branch="$(git -C "$root" rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'desconocida')"
+  echo "🏗️  Arnés de construcción · modo runtime"
+  echo "   Rama: $branch | Fase del arnés: $(projection_get project.harness_phase desconocida)"
+  ver="$(projection_get context.version "")"
+  [ -n "$ver" ] && echo "   Contexto sincronizado: v$ver"
+  if projection_is_stale; then
+    age="$(projection_age_seconds)"
+    echo "   ⚠ Proyección local sin refrescar (${age}s): el runtime no respondió. Los guards siguen operando con esta caché."
+  fi
+  if [ "$(cat "$root/.claude/state/heartbeat-status.json" 2>/dev/null | grep -c '"lease_lost": true')" != "0" ]; then
+    echo "   ⚠ Lease perdido: otro agente pudo tomar el slice. Haz checkpoint y vuelve a reclamar (/build:claim)."
+  fi
+  slice="$(projection_get active_slice.slice_id "")"
+  if [ -z "$slice" ]; then
+    echo "   Slice activo: ninguno. Reclama el siguiente con /build:claim (skill building-a-slice)."
+    return 0
+  fi
+  echo "   Slice activo: $(projection_get active_slice.epic_code '?') [$(projection_get active_slice.hus '[]' | tr -d '[]"')] · change=$(projection_get active_slice.openspec_change '—') · fase=$(projection_get active_slice.phase '—')"
+  gates="$(projection_get active_slice.gates '{}' | python3 -c 'import json,sys
+try: g=json.load(sys.stdin)
+except Exception: g={}
+abiertos=[k for k,v in g.items() if v is False]
+print(", ".join(abiertos) if abiertos else "ninguno ✅")' 2>/dev/null)"
+  echo "   Gates pendientes: ${gates:-desconocidos}"
+  wiring="$(projection_get active_slice.wiring_failing '[]' | python3 -c 'import json,sys
+try: w=json.load(sys.stdin)
+except Exception: w=[]
+if w:
+    muestra="; ".join("%s(%s)" % (i.get("item_id"), i.get("kind")) for i in w[:8])
+    extra=" (+%d más)" % (len(w)-8) if len(w)>8 else ""
+    print("%d|%s%s" % (len(w), muestra, extra))' 2>/dev/null)"
+  if [ -n "$wiring" ]; then
+    echo "   ⚠️  Cableado pendiente (${wiring%%|*} item/s failing): ${wiring#*|}"
+    echo "       NO declares el slice terminado mientras queden items failing (verifica con prueba real)."
+  fi
+  subs="$(projection_get active_slice.sub_slices_pending '[]' | tr -d '[]"')"
+  [ -n "$subs" ] && echo "   ⚠️  Sub-slices pendientes: $subs"
+  hint="$(projection_get active_slice.resume_hint "")"
+  [ -n "$hint" ] && echo "   ▶️  Retomar: $hint"
+  return 0
+}
+
+if [ "$(runtime_mode)" = "runtime" ]; then
+  cat >/dev/null 2>&1   # consumir el payload del hook (protocolo)
+  render_runtime
+  exit 0
+fi
+
+# ── A partir de aquí, camino legacy|dual: v0.8.5 exacto ──
+source "$HERE/lib/state-io.sh"
 
 # Lee el payload de SessionStart (JSON en stdin) para extraer session_id. Fail-open:
 # si no hay stdin o no trae session_id, seguimos sin tocar session_continuity.

package/hooks/build/reflect-nudge.sh

@@ -4,6 +4,21 @@
 # Sugiere /build:reflect SOLO si hay slice(s) archivado(s) sin reflexionar (reflected != true).
 # Determinista y barato: el razonamiento (qué se aprendió) lo hace el MODELO en /build:reflect.
 set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/projection.sh"
+
+# [EP-OR-08-B] En runtime el cómputo («qué slices quedaron sin reflexionar») lo hace el
+# servidor sobre TODO el proyecto, no este clon: aquí solo se renderiza su nudge.
+if [ "$(runtime_mode)" = "runtime" ]; then
+  projection_get nudges '[]' | python3 -c 'import json,sys
+try: ns=json.load(sys.stdin)
+except Exception: ns=[]
+for n in ns:
+    if isinstance(n,dict) and n.get("kind")=="reflect" and n.get("message"):
+        print("💡 "+n["message"])
+        print("   Ejecuta /build:reflect para proponer convenciones aprendidas a CLAUDE.md (se aplican tras tu aprobación).")' 2>/dev/null
+  exit 0
+fi
 
 ROOT="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
 STATE="$ROOT/.claude/state/build-state.json"

package/hooks/build/release-gate-nudge.sh

@@ -7,6 +7,21 @@
 # El criterio "cierra una línea de release" vive en docs/02-user-story-map/ y NO se intenta aquí
 # (lo computa la skill building-a-slice en la fase 8).
 set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/projection.sh"
+
+# [EP-OR-08-B] Igual que reflect-nudge: la aritmética de conjuntos (archivadas − cubiertas)
+# es del servidor; este hook renderiza el nudge tipado y jamás bloquea el cierre.
+if [ "$(runtime_mode)" = "runtime" ]; then
+  projection_get nudges '[]' | python3 -c 'import json,sys
+try: ns=json.load(sys.stdin)
+except Exception: ns=[]
+for n in ns:
+    if isinstance(n,dict) and n.get("kind")=="release_gate" and n.get("message"):
+        print("💡 Release Gate sugerido: "+n["message"])
+        print("   Ejecuta /build:release (o la skill releasing-a-version): corre los gates pesados UNA vez sobre el diff acumulado.")' 2>/dev/null
+  exit 0
+fi
 
 ROOT="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
 STATE="$ROOT/.claude/state/build-state.json"

package/hooks/build/release-ops.sh

@@ -0,0 +1,171 @@
+#!/usr/bin/env bash
+# release-ops.sh — operaciones del OUTER LOOP que conducen las skills [EP-OR-08-C]:
+# veredictos del Release Gate y reporte de integración de un miembro del front paralelo.
+# NO es un hook registrado: lo invocan `releasing-a-version` y `managing-parallel-front`.
+#
+# Línea de corte (spec §2): **reportar un hecho medido es acto de agente; decidir es acto
+# humano**. Por eso aquí están los veredictos y el reporte de integración, y NO están:
+# cerrar la release, planificar/abrir/drenar/cerrar el front, ni publicar contexto — esos
+# viven en la consola del hub, con PDP, y las skills se limitan a instruir al humano.
+#
+#   uso: release-ops.sh <verdict|close-hint|front-integration> …
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/runtime-ops.sh"
+
+usage() {
+  cat >&2 <<'USAGE'
+uso: release-ops.sh <subcomando> [opciones]
+
+  verdict <line> <security|smell|ux|coherence|stack_arch|integration> <pass|fail|na>
+          [--evidence T | --evidence-file F]     reporta un veredicto del Release Gate
+  close-hint <line>                              recuerda cómo se cierra (acto humano)
+  front-integration <front_id> --merge-status <pending|merged|conflict>
+          [--resmoke pass|fail] [--evidence T | --evidence-file F]
+
+códigos de salida: 0 ok · 2 uso · 3 legacy · 5 offline · 6 rechazado
+USAGE
+}
+
+# _rel_evidence_json — misma política que en slice-ops: fichero preferido, texto corto si no.
+_rel_evidence_json() {
+  local ev="$1" evfile="$2"
+  if [ -n "$evfile" ]; then ops_json_str_file "$evfile"; else ops_json_str "$ev"; fi
+}
+
+# ── verdict ──────────────────────────────────────────────────────────────────────────
+cmd_verdict() {
+  local line="${1:-}" gate="${2:-}" estado="${3:-}" ev="" evfile="" mode payload resp status pfile
+  if [ -z "$line" ] || [ -z "$gate" ] || [ -z "$estado" ]; then usage; return $OPS_RC_USAGE; fi
+  shift 3
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --evidence) ev="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      --evidence-file) evfile="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      *) shift ;;
+    esac
+  done
+  case " $OPS_RELEASE_GATES " in
+    *" $gate "*) : ;;
+    *) echo "⛔ gate de release desconocido «${gate}». Canónicos: $OPS_RELEASE_GATES" >&2
+       echo "  (los gates por slice — dor, tdd, journey_smoke… — van por slice-ops.sh gate)" >&2
+       return $OPS_RC_REJECTED ;;
+  esac
+  case "$estado" in
+    pass|fail|na) : ;;
+    *) echo "⛔ estado inválido «${estado}» (pass|fail|na)" >&2; return $OPS_RC_REJECTED ;;
+  esac
+  mode="$(ops_mode)"
+  [ "$mode" = "legacy" ] && { echo "LEGACY: escribe el gate en releases[] del fichero"; return $OPS_RC_LEGACY; }
+  payload="{\"release_line\":$(ops_json_str "$line"),\"gate\":$(ops_json_str "$gate"),\"status\":$(ops_json_str "$estado"),\"evidence\":$(_rel_evidence_json "$ev" "$evfile")}"
+  if [ "$mode" = "dual" ]; then
+    pfile="$(ops_tmpjson "$payload")" || return $OPS_RC_OFFLINE
+    ops_mirror release_verdict_reported "$pfile" || echo "⚠ veredicto de release no espejado; el comparador dual lo marcará" >&2
+    rm -f "$pfile"
+    return $OPS_RC_OK
+  fi
+  resp="$(runtime_post "$(ops_path_release_verdicts "$(ops_urlenc "$line")")" "$payload")"
+  status="$(runtime_http_status)"
+  case "$status" in
+    200|201|202)
+      echo "veredicto de release registrado: $gate=$estado en $line"
+      echo "El cierre de la release NO lo hace el agente: lo hace un humano en la consola (spec §2)."
+      return $OPS_RC_OK ;;
+    422)
+      echo "⛔ 422 el servidor rechazó el veredicto: $resp — no reintentes; corrige y vuelve a medir." >&2
+      return $OPS_RC_REJECTED ;;
+    401|403)
+      echo "⛔ token sin permiso para reportar veredictos de release ($status): habla con el ADMIN." >&2
+      return $OPS_RC_REJECTED ;;
+    *)
+      # [#44] SIN fallback offline: `release_gate_verdict` es del agregado `release` y
+      # POST /events solo ingiere ámbito slice (slice_id obligatorio y slice existente,
+      # progress_service._apply_and_append) o proyecto — el evento encolado era rechazo
+      # garantizado al drenar y el veredicto jamás llegaba. Mismo patrón que
+      # propose-asset: rc 5 y reintento explícito al reconectar.
+      echo "OFFLINE: no se pudo reportar el veredicto de release (status $status) y este acto" >&2
+      echo "  no tiene camino por la cola offline. Reintenta cuando haya red:" >&2
+      echo "  release-ops.sh verdict $line $gate $estado" >&2
+      return $OPS_RC_OFFLINE ;;
+  esac
+}
+
+# ── close-hint ───────────────────────────────────────────────────────────────────────
+# Cero red a propósito: es un recordatorio de gobierno, no una llamada.
+cmd_close_hint() {
+  local line="${1:-}"
+  [ -n "$line" ] || { usage; return $OPS_RC_USAGE; }
+  cat <<HINT
+El cierre de la release «${line}» es un acto de GOBIERNO HUMANO (spec §2):
+  1. El agente reporta los 6 veredictos con \`release-ops.sh verdict $line <gate> <estado>\`.
+  2. El runtime agrega: parciales NO promueven a passed.
+  3. Una persona con permiso cierra la línea en la consola del hub.
+El arnés no cierra releases ni con token de agente: esa superficie exige PDP.
+HINT
+  return $OPS_RC_OK
+}
+
+# ── front-integration ────────────────────────────────────────────────────────────────
+# Cada worktree se registra como AGENTE PROPIO (mismo token de proyecto, `agent_key`
+# distinto): reporta la integración de SU miembro. Planificar, abrir, drenar y cerrar el
+# front siguen siendo humanos.
+cmd_front_integration() {
+  local front="${1:-}" merge="" resmoke="" ev="" evfile="" mode akey payload resp status pfile
+  [ -n "$front" ] || { usage; return $OPS_RC_USAGE; }
+  shift
+  while [ $# -gt 0 ]; do
+    case "$1" in
+      --merge-status) merge="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      --resmoke) resmoke="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      --evidence) ev="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      --evidence-file) evfile="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
+      *) shift ;;
+    esac
+  done
+  case "$merge" in
+    pending|merged|conflict) : ;;
+    *) echo "⛔ --merge-status debe ser pending|merged|conflict" >&2; return $OPS_RC_REJECTED ;;
+  esac
+  case "$resmoke" in
+    ""|pass|fail) : ;;
+    *) echo "⛔ --resmoke debe ser pass|fail" >&2; return $OPS_RC_REJECTED ;;
+  esac
+  mode="$(ops_mode)"
+  [ "$mode" = "legacy" ] && { echo "LEGACY: actualiza parallel_front.members[] en el fichero"; return $OPS_RC_LEGACY; }
+  payload="{\"merge_status\":$(ops_json_str "$merge"),\"re_smoke\":{\"status\":$(ops_json_str "$resmoke"),\"evidence\":$(_rel_evidence_json "$ev" "$evfile")}}"
+  if [ "$mode" = "dual" ]; then
+    pfile="$(ops_tmpjson "$payload")" || return $OPS_RC_OFFLINE
+    ops_mirror front_integration_reported "$pfile" || echo "⚠ integración de front no espejada; el comparador dual la marcará" >&2
+    rm -f "$pfile"
+    return $OPS_RC_OK
+  fi
+  akey="$(runtime_field agent_key)"
+  [ -n "$akey" ] || { echo "⛔ este worktree no está registrado como agente: corre \`trycore-build init\` en él" >&2; return $OPS_RC_REJECTED; }
+  resp="$(runtime_post "$(ops_path_front_integration "$(ops_urlenc "$front")" "$(ops_urlenc "$akey")")" "$payload")"
+  status="$(runtime_http_status)"
+  case "$status" in
+    200|201|202) echo "integración reportada: merge_status=$merge re_smoke=${resmoke:-n/a}"; return $OPS_RC_OK ;;
+    422) echo "⛔ 422 el servidor rechazó el reporte: $resp" >&2; return $OPS_RC_REJECTED ;;
+    401|403) echo "⛔ token sin permiso ($status): habla con el ADMIN." >&2; return $OPS_RC_REJECTED ;;
+    *)
+      # [#44] SIN fallback offline: `front_integration_reported` NO existe en el catálogo
+      # v2 del hub (el hecho del catálogo, `front_member_integrated`, es del agregado
+      # `front` y POST /events no lo ingiere) y la superficie síncrona de integración es
+      # de gobierno humano (`can_govern_front`). Encolarlo era rechazo garantizado: rc 5
+      # y reintento explícito al reconectar (mismo patrón que propose-asset).
+      echo "OFFLINE: no se pudo reportar la integración (status $status) y este acto no" >&2
+      echo "  tiene camino por la cola offline. Reintenta cuando haya red:" >&2
+      echo "  release-ops.sh front-integration $front --merge-status $merge${resmoke:+ --resmoke $resmoke}" >&2
+      return $OPS_RC_OFFLINE ;;
+  esac
+}
+
+SUB="${1:-}"
+[ $# -gt 0 ] && shift
+case "$SUB" in
+  verdict) cmd_verdict "$@"; exit $? ;;
+  close-hint) cmd_close_hint "$@"; exit $? ;;
+  front-integration) cmd_front_integration "$@"; exit $? ;;
+  ""|-h|--help|help) usage; exit $OPS_RC_USAGE ;;
+  *) echo "subcomando desconocido: $SUB" >&2; usage; exit $OPS_RC_USAGE ;;
+esac

package/hooks/build/scaffold-guard.sh

@@ -8,11 +8,38 @@
 set -uo pipefail
 
 ROOT="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
-STATE="$ROOT/.claude/state/build-state.json"
-[ -f "$STATE" ] || exit 0
 
 INPUT="$(cat)"
 
+# [EP-OR-08-B] En modo runtime los hechos vienen de la caché de proyección (la escribe
+# session-start.sh desde /agent/context), NUNCA de la red: este hook corre en PreToolUse y
+# la red está prohibida aquí. En legacy|dual el fichero sigue siendo primario (spec §6.1).
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/projection.sh"
+if [ "$(runtime_mode)" = "runtime" ]; then
+  CACHE="$(runtime_projection_path)"
+  [ -f "$CACHE" ] || exit 0   # aún sin sincronizar: nada que vigilar (auto-arme)
+  if ! command -v python3 >/dev/null 2>&1; then
+    echo "⛔ scaffold-guard: python3 no disponible; no puedo verificar el gate de scaffold. Instala python3 (trycore-build doctor)." >&2
+    exit 2
+  fi
+  PHASE="$(projection_get active_slice.phase "")"
+  case "$PHASE" in
+    red|green|refactor|smoke|api|data) ;;
+    *) exit 0 ;;   # sin slice o en dor/change/pr/archived: permitido
+  esac
+  [ "$(projection_get project.scaffold_confirmed false)" = "true" ] && exit 0
+  echo "⛔ scaffold-guard (Paso 1 fundamental): el slice está en fase de código pero el scaffold NO está confirmado." >&2
+  echo "   Confirma primero que existe un scaffold runnable del proyecto (ver building-a-slice Fase 0 / DoR)." >&2
+  echo "   El arnés NO genera el scaffold: créalo según tu stack (stack-allowlist.json) y confírmalo." >&2
+  projection_is_stale && echo "   ⚠ Veredicto emitido con proyección stale (sin refrescar): el runtime no respondió en el último arranque." >&2
+  exit 2
+fi
+
+# Camino legacy|dual: leer build-state.json
+STATE="$ROOT/.claude/state/build-state.json"
+[ -f "$STATE" ] || exit 0
+
 # Guarda python3 [H4]: si falta, no podemos leer el estado de forma fiable. Fail-closed
 # DIRIGIDO: solo bloqueamos si la edición NO es del propio scaffold/planificación obvia.
 if ! command -v python3 >/dev/null 2>&1; then