@trycore/spec-build-harness 0.8.4 → 0.10.0

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,164 @@
+#!/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 ;;
+    *)
+      pfile="$(ops_tmpjson "$payload")" || return $OPS_RC_OFFLINE
+      # Sin slice_id: un veredicto de release es de ámbito release/proyecto, no de slice.
+      ops_enqueue_from_file verdict_reported "$pfile" ""
+      rm -f "$pfile"
+      echo "OFFLINE: veredicto de release encolado (tipo protegido)"
+      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 ;;
+    *)
+      pfile="$(ops_tmpjson "$payload")" || return $OPS_RC_OFFLINE
+      ops_enqueue_from_file front_integration_reported "$pfile" ""
+      rm -f "$pfile"
+      echo "OFFLINE: reporte de integración encolado"
+      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

package/hooks/build/session-start.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# session-start.sh — SessionStart (startup|clear|compact) [EP-OR-08-B].
+# La parte de RED del arranque de sesión: registro idempotente del agente (con el catálogo
+# de asset types del paquete), hidratación de la caché de proyección desde /agent/context,
+# sincronización de contexto por hash y aseguramiento del daemon de heartbeat.
+# El RENDER del estado a `additionalContext` lo hace load-build-state.sh, que corre después.
+# Fail-open absoluto: cualquier fallo imprime un aviso por stderr y sale 0 — un runtime
+# caído jamás impide arrancar una sesión (RNF-6).
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/runtime-client.sh"
+source "$HERE/lib/projection.sh"
+source "$HERE/lib/agent-context.sh"
+
+cat >/dev/null 2>&1   # consumir el payload del hook (protocolo); no se usa aquí
+
+MODE="$(runtime_mode)"
+[ "$MODE" = "legacy" ] && exit 0
+command -v python3 >/dev/null 2>&1 || exit 0
+[ -n "$(runtime_url)" ] || exit 0   # sin `trycore-build init` (sub-slice D) no hay runtime
+
+# sst_pkg_root — raíz del PAQUETE (no del proyecto). Los hooks se instalan como symlinks
+# por fichero (linkChildren), así que hay que resolver la cadena de enlaces a mano:
+# `readlink -f` no es portable al BSD readlink de macOS.
+sst_pkg_root() {
+  local src="${BASH_SOURCE[0]}" target i=0
+  while [ -L "$src" ] && [ "$i" -lt 10 ]; do
+    target="$(readlink "$src" 2>/dev/null)" || break
+    case "$target" in
+      /*) src="$target" ;;
+      *)  src="$(dirname "$src")/$target" ;;
+    esac
+    i=$((i + 1))
+  done
+  (cd "$(dirname "$src")/../.." >/dev/null 2>&1 && pwd -P) 2>/dev/null
+}
+
+# sst_harness_version — versión instalada en el consumidor; si no, la del paquete.
+sst_harness_version() {
+  local f pkg
+  f="$(config_root)/.claude/.build-harness-version"
+  if [ -f "$f" ]; then
+    tr -d ' \n' < "$f"
+    return
+  fi
+  pkg="$(sst_pkg_root)"
+  if [ -n "$pkg" ] && [ -f "$pkg/VERSION" ]; then
+    tr -d ' \n' < "$pkg/VERSION"
+    return
+  fi
+  echo "0.0.0"
+}
+
+# sst_asset_types — el array `types` de asset-types.json del paquete (protocolo §6).
+# Cadena de resolución: plugin > copia en .claude/ (la siembra es del sub-slice D) >
+# paquete resuelto por symlink. Sin fichero: "[]" — el registro sigue funcionando.
+sst_asset_types() {
+  local pkg candidates f
+  pkg="$(sst_pkg_root)"
+  candidates="${CLAUDE_PLUGIN_ROOT:-}/asset-types.json
+$(config_root)/.claude/asset-types.json
+${pkg:-}/asset-types.json"
+  while IFS= read -r f; do
+    case "$f" in /asset-types.json|asset-types.json) continue ;; esac
+    [ -f "$f" ] || continue
+    python3 - "$f" <<'PY' 2>/dev/null && return
+import json,sys
+try:
+    d=json.load(open(sys.argv[1]))
+    t=d.get("types")
+    print(json.dumps(t if isinstance(t,list) else [],ensure_ascii=False))
+except Exception:
+    raise SystemExit(1)
+PY
+  done <<EOS
+$candidates
+EOS
+  echo "[]"
+}
+
+HV="$(sst_harness_version)"
+AT="$(sst_asset_types)"
+
+runtime_register "$HV" "$AT"
+RC=$?
+if [ "$RC" -eq 2 ]; then
+  echo "⛔ El runtime rechaza esta versión del arnés ($HV): incompatible_version." >&2
+  echo "   Actualiza el paquete (npm i -g @trycore/spec-build-harness@latest) y reabre la sesión." >&2
+  echo "   Mientras tanto se trabaja con la caché local: los guards siguen operando." >&2
+  exit 0
+fi
+
+if ! agent_context_fetch_and_cache; then
+  echo "⚠ El runtime no respondió: se trabaja con la caché de proyección local." >&2
+fi
+
+EXPECTED="$(projection_get context.manifest_hash "")"
+[ -n "$EXPECTED" ] || EXPECTED="$(runtime_field manifest_hash)"
+bash "$HERE/context-sync.sh" "$EXPECTED"
+
+bash "$HERE/heartbeat.sh" --ensure "$PPID" >/dev/null 2>&1
+
+exit 0

package/hooks/build/session-stop.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# session-stop.sh — Stop [EP-OR-08-B].
+# Flush de la cola al cerrar el turno, pero SIN red en el hilo del hook: deja un sentinela
+# en outbox/.flush-request y se asegura de que el daemon esté vivo. El daemon lo consume en
+# su siguiente tick y despacha (protocolo §5, spec §11: «señal local al daemon»).
+# Nunca bloquea el cierre: exit 0 siempre, sin stdout (en Stop, stdout inyecta contexto).
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HERE/lib/runtime-client.sh"
+
+cat >/dev/null 2>&1   # consumir el payload del hook
+
+MODE="$(runtime_mode)"
+[ "$MODE" = "legacy" ] && exit 0
+
+DIR="$(runtime_outbox_dir)"
+mkdir -p "$DIR" 2>/dev/null
+: > "$DIR/.flush-request" 2>/dev/null
+
+bash "$HERE/heartbeat.sh" --ensure "$PPID" >/dev/null 2>&1
+
+exit 0