@trycore/spec-build-harness 0.10.0 → 0.11.1

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

@@ -24,7 +24,10 @@ 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.
-OPS_MAX_TEXT=4000
+# [#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).
@@ -91,20 +94,23 @@ ops_tmpjson() {
 # 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. Fichero ausente => null.
+# 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 "[]"
+  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=[]
+out={}
 for f in files:
     if not isinstance(f,dict):
         continue
@@ -112,7 +118,7 @@ for f in files:
     if not isinstance(p,str) or not p:
         continue
     full=os.path.join(root,".claude",p)
-    sha=None
+    sha=""
     try:
         h=hashlib.sha256()
         with open(full,"rb") as fh:
@@ -120,8 +126,8 @@ for f in files:
                 h.update(chunk)
         sha=h.hexdigest()
     except Exception:
-        sha=None
-    out.append({"path":p,"sha256":sha})
+        sha=""
+    out[p]=sha
 print(json.dumps(out,ensure_ascii=False))
 PY
 }

package/hooks/build/release-ops.sh

@@ -35,7 +35,7 @@ _rel_evidence_json() {
 
 # ── verdict ──────────────────────────────────────────────────────────────────────────
 cmd_verdict() {
-  local line="${1:-}" gate="${2:-}" estado="${3:-}" ev="" evfile="" mode payload resp status pfile
+  local line="${1:-}" gate="${2:-}" estado="${3:-}" ev="" evfile="" mode payload resp status pfile rel_status closed_by
   if [ -z "$line" ] || [ -z "$gate" ] || [ -z "$estado" ]; then usage; return $OPS_RC_USAGE; fi
   shift 3
   while [ $# -gt 0 ]; do
@@ -57,7 +57,7 @@ cmd_verdict() {
   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")}"
+  payload="{\"release_line\":$(ops_json_str "$line"),\"gate\":$(ops_json_str "$gate"),\"status\":$(ops_json_str "$estado"),\"verdict\":$(ops_json_str "$(printf %s "$estado" | tr a-z A-Z)"),\"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
@@ -69,7 +69,30 @@ cmd_verdict() {
   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)."
+      # [A-con-B] El hub auto-cierra la release cuando el ÚLTIMO veredicto de cada uno
+      # de los 6 gates canónicos es PASS (closed_by=AUTO_6_OF_6_PASS, queda en el audit
+      # trail). Con algún fail/partial el cierre sigue siendo decisión HUMANA en la
+      # consola. Fail-open: un hub previo sin release_status cae al recordatorio.
+      rel_status="$(printf '%s' "$resp" | python3 -c 'import json,sys
+try:
+    print(json.load(sys.stdin).get("release_status") or "")
+except Exception:
+    print("")' 2>/dev/null)"
+      closed_by="$(printf '%s' "$resp" | python3 -c 'import json,sys
+try:
+    print(json.load(sys.stdin).get("closed_by") or "")
+except Exception:
+    print("")' 2>/dev/null)"
+      case "$rel_status" in
+        PASSED)
+          echo "✅ release «${line}» CERRADA por el hub: 6/6 gates PASS (closed_by: ${closed_by:-AUTO_6_OF_6_PASS})." ;;
+        FAILED)
+          echo "⛔ release «${line}» en FAILED en el hub; los hallazgos bloqueantes se corrigen como slice y se re-mide." ;;
+        IN_PROGRESS)
+          echo "release aún IN_PROGRESS: el hub auto-cierra al llegar el 6/6 PASS; con algún fail/partial el cierre es decisión humana en la consola (spec §2)." ;;
+        *)
+          echo "El hub auto-cierra con 6/6 PASS; si algún gate queda en fail, el cierre/decisión es humano en la consola (spec §2)." ;;
+      esac
       return $OPS_RC_OK ;;
     422)
       echo "⛔ 422 el servidor rechazó el veredicto: $resp — no reintentes; corrige y vuelve a medir." >&2
@@ -78,11 +101,14 @@ cmd_verdict() {
       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)"
+      # [#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
 }
@@ -93,11 +119,13 @@ 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):
+Política de cierre de la release «${line}» (A-con-B):
   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.
+  2. El runtime agrega y AUTO-CIERRA en verde: con el último veredicto de los 6 gates
+     canónicos en PASS la release pasa a PASSED (closed_by=AUTO_6_OF_6_PASS, audit trail).
+  3. Los casos DEGRADADOS (algún fail/partial, deudas por decidir) siguen siendo gobierno
+     humano: una persona con permiso decide y cierra en la consola del hub (PDP).
+Parciales no promueven; el gobierno humano vive donde hay decisión real, no en el clic.
 HINT
   return $OPS_RC_OK
 }
@@ -145,10 +173,14 @@ cmd_front_integration() {
     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"
+      # [#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
 }

package/hooks/build/slice-ops.sh

@@ -21,7 +21,8 @@ usage() {
 uso: slice-ops.sh <subcomando> [opciones]
 
   mode                                          imprime legacy|dual|runtime
-  claim [--epic EP-XXX]                         reclama trabajo (solo modo runtime)
+  claim                                         reclama trabajo (solo modo runtime; el hub
+                                                reparte por orden de cola — no hay --epic)
   next-step                                     deriva la siguiente acción desde la caché
   gate <nombre> <pass|fail|na> [--evidence «texto» | --evidence-file F]
                                                 reporta un veredicto del slice (hecho medido)
@@ -90,13 +91,13 @@ if cp:
 PY
 }
 
-# _claim_once <epic> — una llamada. rc 20 = reintentable (drift|contention), resto = final.
+# _claim_once — una llamada. rc 20 = reintentable (drift|contention), resto = final.
+# [#39] El cuerpo lleva SOLO context_hashes: `TasksNextIn` del hub no declara epic_code
+# (pydantic lo ignoraba en silencio y la cola repartía OTRA épica con claim "exitoso").
 _claim_once() {
-  local epic="$1" hashes body resp status reason
+  local hashes body resp status reason
   hashes="$(ops_context_hashes)"
-  body="{\"context_hashes\":$hashes"
-  [ -n "$epic" ] && body="$body,\"epic_code\":$(ops_json_str "$epic")"
-  body="$body}"
+  body="{\"context_hashes\":$hashes}"
   resp="$(runtime_post "$OPS_PATH_CLAIM" "$body")"
   status="$(runtime_http_status)"
   case "$status" in
@@ -161,12 +162,26 @@ cmd_claim() {
     echo "Abre el slice en local y reporta cada transición con los demás subcomandos (espejo)."
     return $OPS_RC_LEGACY
   fi
+  # [#39] El hub NO soporta el claim dirigido: `TasksNextIn` solo declara context_hashes
+  # y un epic_code en el cuerpo se ignoraría en silencio — en el piloto un
+  # `claim --epic EP-040` devolvió un claim "exitoso" de EP-001 y dejó un lease que hubo
+  # que liberar desde la consola. Fallo EXPLÍCITO antes de tocar la red: jamás un claim
+  # que devuelva otra épica distinta de la pedida sin error.
+  if [ -n "$epic" ]; then
+    echo "⛔ claim --epic no existe en el protocolo del hub: POST /tasks/next no acepta" >&2
+    echo "  epic_code y el servidor repartiría la PRIMERA épica de su cola como si fuera" >&2
+    echo "  la pedida (dejando un lease huérfano que solo la consola admin libera)." >&2
+    echo "  Protocolo real: el hub reparte por orden de cola — reclama sin --epic y trabaja" >&2
+    echo "  lo que entregue. Para dirigir una épica concreta: termina el slice en modo dual," >&2
+    echo "  pide al ADMIN apagar el espejo (cutover) y reclama del hub lo que la cola sirva." >&2
+    return $OPS_RC_USAGE
+  fi
   # Contexto primero (protocolo §3 regla 1). context-sync.sh es fail-open: si no puede,
   # sale 0 y deja el lock anterior — el claim seguirá y el servidor detectará el drift.
   expected="$(projection_get context.manifest_hash "")"
   [ -n "$expected" ] || expected="$(runtime_field manifest_hash)"
   bash "$HERE/context-sync.sh" "$expected" >/dev/null 2>&1
-  _claim_once "$epic"
+  _claim_once
   rc=$?
   if [ $rc -eq 20 ]; then
     # Drift o contención: reintentar EXACTAMENTE una vez (protocolo §7). Pasar "" a
@@ -180,7 +195,7 @@ cmd_claim() {
     agent_context_fetch_and_cache >/dev/null 2>&1
     expected="$(projection_get context.manifest_hash "")"
     bash "$HERE/context-sync.sh" "$expected" >/dev/null 2>&1
-    _claim_once "$epic"
+    _claim_once
     rc=$?
     if [ $rc -eq 20 ]; then
       echo "otro agente tomó la tarea; pide la siguiente"
@@ -235,11 +250,14 @@ PY
 }
 
 # ── fact ─────────────────────────────────────────────────────────────────────────────
-# Hechos de PROYECTO (spec §4.1-B): dos ya persisten en el runtime con superficie admin
-# (`scaffold_confirmed`, `design_source_*`) y ganan evento + proyección; tres se crean
-# completos (`project_kind`, `foundation`, `harness_phase`). Todos son de ámbito proyecto:
-# se encolan SIN `slice_id` (el servidor los admite así, spec §3.1 rev. 3).
-# La CONFIRMACIÓN sigue siendo humana: este subcomando REPORTA lo que el humano confirmó.
+# Hechos de PROYECTO, contrato del catálogo v2 del hub [#38] (project_facts_domain):
+# - Hechos MÁQUINA (`project_kind`, `harness_phase`, `foundation`): UN solo tipo,
+#   `project_fact_updated`, con el payload EXACTO {fact, value, source:"AGENT"}
+#   (extra="forbid": ninguna otra clave viaja). Ámbito proyecto: sin `slice_id`.
+# - Hechos HUMANOS (`scaffold_confirmed`, `design_source_*`): el hub los rechaza en TODA
+#   superficie de agente — se fijan tras el PDP por la superficie admin
+#   (PATCH /orchestrator/projects/{project_id}). En runtime/dual NO se encola: rechazo
+#   local claro que dirige al humano a la consola del hub. En legacy nada cambia.
 cmd_fact() {
   local hecho="${1:-}" mode
   [ -n "$hecho" ] && shift
@@ -282,50 +300,45 @@ _ops_emit_event() {
   return $OPS_RC_OK
 }
 
-# _fact_emit <tipo> <payload_json> — un hecho de PROYECTO (sin slice_id): mismo contrato de
-# _ops_emit_event, con el aviso de fallo y el mensaje de éxito que esperan las skills.
-_fact_emit() {
-  local tipo="$1" payload="$2"
-  if ! _ops_emit_event "$tipo" "$payload" ""; then
-    echo "⚠ hecho \"$tipo\" no se pudo encolar (outbox no escribible u otro fallo local)" >&2
+# _fact_human_reject <fact> — [#38] rechazo LOCAL del hecho humano en runtime/dual: el hub
+# responde 422 en TODA superficie de agente (`rechazo_de_hecho_humano`); encolarlo era un
+# reintento eterno de algo que jamás iba a entrar. El humano lo fija en la consola del hub.
+_fact_human_reject() {
+  local fact="$1"
+  echo "⛔ «${fact}» es un hecho HUMANO: no entra por la superficie de agente del hub." >&2
+  echo "  Se fija tras el PDP por la superficie admin: PATCH /orchestrator/projects/{project_id}" >&2
+  echo "  (consola del hub). Pide al ADMIN del proyecto que lo confirme allí; este subcomando" >&2
+  echo "  no lo encola. En modo legacy sigue escribiéndose en el fichero local." >&2
+  return $OPS_RC_REJECTED
+}
+
+# _fact_machine_emit <fact> <value_json> — [#38] hecho MÁQUINA del catálogo v2: payload
+# EXACTO {fact, value, source:"AGENT"} (extra="forbid" en el hub: nada más viaja) y SIN
+# slice_id (ámbito proyecto). También en dual va por la COLA (POST /events): la ingesta
+# espejo solo acepta transiciones de slice (TIPOS_DE_ESPEJO) y rechazaría el hecho.
+_fact_machine_emit() {
+  local fact="$1" value_json="$2" payload pfile
+  payload="{\"fact\":$(ops_json_str "$fact"),\"value\":$value_json,\"source\":\"AGENT\"}"
+  pfile="$(ops_tmpjson "$payload")" || {
+    echo "⚠ hecho \"$fact\" no se pudo encolar (fallo local)" >&2
+    return $OPS_RC_OFFLINE
+  }
+  if ! ops_enqueue_from_file project_fact_updated "$pfile" ""; then
+    rm -f "$pfile"
+    echo "⚠ hecho \"$fact\" no se pudo encolar (outbox no escribible u otro fallo local)" >&2
     return $OPS_RC_OFFLINE
   fi
-  [ "$(ops_mode)" = "runtime" ] && echo "hecho de proyecto \"$tipo\" encolado"
+  rm -f "$pfile"
+  echo "hecho de proyecto \"$fact\" encolado (project_fact_updated)"
   return $OPS_RC_OK
 }
 
 _fact_scaffold() {
-  local by="" notes=""
-  while [ $# -gt 0 ]; do
-    case "$1" in
-      --by) by="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      --notes) notes="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      *) shift ;;
-    esac
-  done
-  [ -n "$by" ] || { echo "⛔ falta --by: el scaffold lo confirma una PERSONA, no el modelo" >&2; return $OPS_RC_REJECTED; }
-  _fact_emit scaffold_confirmed "{\"confirmed\":true,\"confirmed_by\":$(ops_json_str "$by"),\"notes\":$(ops_json_str "$notes")}"
+  _fact_human_reject scaffold_confirmed
 }
 
 _fact_design_source() {
-  local applies="" source="" confirmed="false" by="" notes=""
-  while [ $# -gt 0 ]; do
-    case "$1" in
-      --applies) applies="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      --source) source="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      --confirmed) confirmed="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      --by) by="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      --notes) notes="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
-      *) shift ;;
-    esac
-  done
-  case "$applies" in true|false) : ;; *) echo "⛔ --applies debe ser true|false" >&2; return $OPS_RC_REJECTED ;; esac
-  case "$confirmed" in true|false) : ;; *) echo "⛔ --confirmed debe ser true|false" >&2; return $OPS_RC_REJECTED ;; esac
-  if [ "$confirmed" = "true" ] && [ -z "$by" ]; then
-    echo "⛔ falta --by: la fuente de diseño la confirma una PERSONA" >&2
-    return $OPS_RC_REJECTED
-  fi
-  _fact_emit design_source_declared "{\"applies\":$applies,\"source\":$(ops_json_str "$source"),\"confirmed\":$confirmed,\"confirmed_by\":$(ops_json_str "$by"),\"notes\":$(ops_json_str "$notes")}"
+  _fact_human_reject design_source_confirmed
 }
 
 _fact_project_kind() {
@@ -338,12 +351,14 @@ _fact_project_kind() {
     esac
   done
   case "$kind" in greenfield|brownfield) : ;; *) echo "⛔ project-kind debe ser greenfield|brownfield" >&2; return $OPS_RC_REJECTED ;; esac
+  # --source auto|human se sigue aceptando (compat con los comandos /build:*), pero NO
+  # viaja: en la superficie de agente el hub solo admite source="AGENT" (progress_service).
   case "$src" in auto|human) : ;; *) echo "⛔ --source debe ser auto|human" >&2; return $OPS_RC_REJECTED ;; esac
-  _fact_emit project_kind_declared "{\"project_kind\":$(ops_json_str "$kind"),\"source\":$(ops_json_str "$src")}"
+  _fact_machine_emit project_kind "$(ops_json_str "$kind")"
 }
 
 _fact_foundation() {
-  local required="" epic="" cfile="" checklist="[]"
+  local required="" epic="" cfile=""
   while [ $# -gt 0 ]; do
     case "$1" in
       --required) required="${2:-}"; [ $# -ge 2 ] && shift 2 || shift ;;
@@ -353,22 +368,16 @@ _fact_foundation() {
     esac
   done
   case "$required" in true|false) : ;; *) echo "⛔ --required debe ser true|false" >&2; return $OPS_RC_REJECTED ;; esac
-  if [ -n "$cfile" ] && [ -f "$cfile" ] && command -v python3 >/dev/null 2>&1; then
-    checklist="$(python3 -c '
-import json,sys
-try:
-    d=json.load(open(sys.argv[1]))
-except Exception:
-    d=[]
-print(json.dumps(d if isinstance(d,list) else [], ensure_ascii=False))' "$cfile" 2>/dev/null || echo "[]")"
-  fi
-  _fact_emit foundation_declared "{\"required\":$required,\"epic\":$(ops_json_str "$epic"),\"checklist\":$checklist}"
+  # El hub proyecta `foundation` a un Boolean (`foundation_confirmed`): el value es el
+  # booleano de --required. --epic y --checklist-file se aceptan por compat con
+  # /build:onboard pero NO viajan (extra="forbid"): la checklist queda en los docs locales.
+  _fact_machine_emit foundation "$required"
 }
 
 _fact_harness_phase() {
   local fase="${1:-}"
   case "$fase" in authoring|building) : ;; *) echo "⛔ harness-phase debe ser authoring|building" >&2; return $OPS_RC_REJECTED ;; esac
-  _fact_emit harness_phase_changed "{\"harness_phase\":$(ops_json_str "$fase")}"
+  _fact_machine_emit harness_phase "$(ops_json_str "$fase")"
 }
 
 # ── propose-asset ────────────────────────────────────────────────────────────────────
@@ -482,7 +491,7 @@ _ops_evidence_json() {
 # Reportar un bloqueo es acto de agente; DECIDIR qué hacer con él es humano (spec §2).
 # El evento deja el rastro en el runtime; la resolución se pide por el canal humano.
 # La nota de gobierno SOLO se imprime si el evento de verdad quedó registrado (mismo patrón
-# de fallo que _fact_emit): un agente jamás debe creer que escaló algo que se perdió.
+# de fallo que _fact_machine_emit): un agente jamás debe creer que escaló algo que se perdió.
 cmd_escalate() {
   local razon="" file="" gate="" mode sid payload
   while [ $# -gt 0 ]; do
@@ -501,9 +510,25 @@ cmd_escalate() {
     echo "LEGACY: no hay runtime donde registrar la escalada; anótala en el PR y habla con el equipo"
     return $OPS_RC_LEGACY
   fi
-  payload="{\"reason\":$(_ops_evidence_json "$razon" "$file"),\"gate\":$(ops_json_str "$gate"),\"phase\":$(ops_json_str "$(projection_get active_slice.phase "")")}"
+  # [#44] El catálogo v2 la llama `slice_escalated` y su payload es EXACTAMENTE {cause}
+  # (extra="forbid"): gate y fase viajan DENTRO del texto de la causa, no como claves.
+  local prefix="" phase tmptxt
+  phase="$(projection_get active_slice.phase "")"
+  [ -n "$gate" ] && prefix="[gate: ${gate}] "
+  [ -n "$phase" ] && prefix="${prefix}[fase: ${phase}] "
+  tmptxt="$(mktemp)" || return $OPS_RC_OFFLINE
+  { printf '%s' "$prefix"; if [ -n "$file" ] && [ -f "$file" ]; then cat "$file"; else printf '%s' "$razon"; fi; } > "$tmptxt"
+  payload="{\"cause\":$(ops_json_str_file "$tmptxt" "$OPS_MAX_TEXT")}"
+  rm -f "$tmptxt"
   sid="$(ops_slice_id)"
-  if ! _ops_emit_event escalation_raised "$payload" "$sid"; then
+  # slice_escalated es de ámbito slice (slice_id obligatorio): sin slice el hub lo
+  # rechazaría elemento a elemento — mejor un fallo local accionable que ruido en rejected/.
+  if [ "$mode" = "runtime" ] && [ -z "$sid" ]; then
+    echo "⛔ sin slice activo: slice_escalated exige slice_id (catálogo v2) y el hub rechazaría el evento." >&2
+    echo "  Reclama trabajo primero o reporta el bloqueo por el PR / la consola del hub." >&2
+    return $OPS_RC_NO_SLICE
+  fi
+  if ! _ops_emit_event slice_escalated "$payload" "$sid"; then
     echo "⚠ la escalada no se pudo registrar (outbox no escribible u otro fallo local): repórtala por el PR mientras tanto" >&2
     return $OPS_RC_OFFLINE
   fi
@@ -559,11 +584,14 @@ _ops_require_slice() {
   return $OPS_RC_OK
 }
 
-# _ops_post_or_queue <path> <payload> <tipo_evento> <slice_id> <etiqueta>
+# _ops_post_or_queue <path> <payload> <tipo_evento> <slice_id> <etiqueta> [queue_payload]
 # Camino común de los actos primarios: POST y, si el servidor no está, encolar el hecho.
 # Rechazo del servidor (409/422/401/403) => NUNCA se encola (no se reintenta lo rechazado).
+# [#44] `queue_payload` (opcional, default = payload): el cuerpo del endpoint síncrono y
+# el payload del catálogo pueden diferir (p.ej. el checkpoint lleva slice_id en el body
+# de POST /checkpoints, pero el catálogo lo prohíbe dentro del payload del evento).
 _ops_post_or_queue() {
-  local path="$1" payload="$2" tipo="$3" sid="$4" etiqueta="$5" resp status pfile
+  local path="$1" payload="$2" tipo="$3" sid="$4" etiqueta="$5" queue_payload="${6:-$2}" resp status pfile
   resp="$(runtime_post "$path" "$payload")"
   status="$(runtime_http_status)"
   case "$status" in
@@ -583,7 +611,7 @@ _ops_post_or_queue() {
       echo "⛔ token inválido o revocado ($status): pide un token nuevo al ADMIN." >&2
       return $OPS_RC_REJECTED ;;
     *)
-      pfile="$(ops_tmpjson "$payload")" || { echo "OFFLINE: no se pudo encolar $etiqueta" >&2; return $OPS_RC_OFFLINE; }
+      pfile="$(ops_tmpjson "$queue_payload")" || { echo "OFFLINE: no se pudo encolar $etiqueta" >&2; return $OPS_RC_OFFLINE; }
       if ops_enqueue_from_file "$tipo" "$pfile" "$sid"; then
         rm -f "$pfile"
         echo "OFFLINE: $etiqueta encolado (tipo protegido, se entrega al reconectar)"
@@ -623,14 +651,30 @@ cmd_gate() {
   esac
   mode="$(ops_mode)"
   [ "$mode" = "legacy" ] && { echo "LEGACY: escribe el gate en el fichero (references/state-protocol.md)"; return $OPS_RC_LEGACY; }
+  # [#44] El hub no tiene veredicto «na»: cualquier verdict ≠ PASS/FAIL es bloqueo
+  # (domain.py, invariante 5) — emitirlo era rechazo garantizado. El gate no aplicable
+  # simplemente no se reporta; queda documentado en el PR.
+  if [ "$estado" = "na" ]; then
+    echo "veredicto «na» de «${gate}»: el catálogo del hub no lo admite (solo PASS/FAIL) — no se reporta."
+    echo "Documenta la no-aplicabilidad del gate en el PR; en el hub el gate queda sin evaluar."
+    return $OPS_RC_OK
+  fi
+  # [#44] Contrato real del hub: la clave es `verdict` (VerdictIn y el catálogo
+  # GateVerdict) y el reducer solo promueve con "PASS"/"FAIL" en MAYÚSCULA
+  # (domain.py:423-431) — `status:"pass"` era rechazo en el sync Y en la cola.
+  local verdict
+  case "$estado" in
+    pass) verdict="PASS" ;;
+    fail) verdict="FAIL" ;;
+  esac
   evjson="$(_ops_evidence_json "$ev" "$evfile")"
-  payload="{\"gate\":$(ops_json_str "$gate"),\"status\":$(ops_json_str "$estado"),\"evidence\":$evjson}"
+  payload="{\"gate\":$(ops_json_str "$gate"),\"verdict\":$(ops_json_str "$verdict"),\"evidence\":$evjson}"
   if [ "$mode" = "dual" ]; then
-    _ops_dual_mirror verdict_reported "$payload"
+    _ops_dual_mirror gate_verdict "$payload"
     return $?
   fi
   sid="$(_ops_require_slice)" || return $OPS_RC_NO_SLICE
-  _ops_post_or_queue "$(ops_path_verdicts "$sid")" "$payload" verdict_reported "$sid" "el veredicto de «${gate}»"
+  _ops_post_or_queue "$(ops_path_verdicts "$sid")" "$payload" gate_verdict "$sid" "el veredicto de «${gate}»"
 }
 
 # ── submit ───────────────────────────────────────────────────────────────────────────
@@ -651,7 +695,10 @@ cmd_submit() {
     return $?
   fi
   sid="$(_ops_require_slice)" || return $OPS_RC_NO_SLICE
-  _ops_post_or_queue "$(ops_path_submit "$sid")" "$payload" slice_submitted "$sid" "el submit del slice"
+  # [#44] El catálogo v2 no admite ningún campo en slice_submitted (extra="forbid"):
+  # el evento encolado va con payload {} — pr_url/openspec_change solo acompañan el POST
+  # síncrono (SubmitIn los ignora) y viven en el PR.
+  _ops_post_or_queue "$(ops_path_submit "$sid")" "$payload" slice_submitted "$sid" "el submit del slice" "{}"
 }
 
 # ── archive ──────────────────────────────────────────────────────────────────────────
@@ -675,8 +722,11 @@ cmd_archive() {
     _ops_dual_mirror slice_archived "$payload"
     return $?
   fi
-  sid="$(ops_slice_id)"
-  pfile="$(ops_tmpjson "$payload")" || return $OPS_RC_OFFLINE
+  # [#44] El catálogo v2 no admite ningún campo en slice_archived (extra="forbid") y el
+  # tipo es de ámbito slice (slice_id de primer nivel OBLIGATORIO): con --epic/--pr-url
+  # en el payload o sin slice el hub rechazaba TODO archivado — payload {} y slice exigido.
+  sid="$(_ops_require_slice)" || return $OPS_RC_NO_SLICE
+  pfile="$(ops_tmpjson "{}")" || return $OPS_RC_OFFLINE
   if ops_enqueue_from_file slice_archived "$pfile" "$sid"; then
     rm -f "$pfile"
     echo "slice_archived encolado (se entrega al reconectar; tipo protegido de la cota)"
@@ -717,7 +767,9 @@ _wiring_seed() {
   command -v python3 >/dev/null 2>&1 || { echo "⚠ sin python3: no se puede sembrar el checklist" >&2; return $OPS_RC_OFFLINE; }
   pfile="$(mktemp)" || return $OPS_RC_OFFLINE
   # El payload se construye leyendo el fichero DENTRO de python3 (nunca por argv) y se
-  # normaliza: cada item nace `failing` — el estado inicial no es negociable.
+  # normaliza al schema del catálogo v2 [#44]: WiringChecklistItem es {item_id, kind, ref}
+  # EXACTO (extra="forbid") — `status` no viaja (cada ítem nace `failing` en el fold del
+  # hub; el estado inicial no es negociable) y kind/ref nunca son null (son obligatorios).
   python3 - "$file" > "$pfile" <<'PY' 2>/dev/null
 import json,sys
 try:
@@ -733,9 +785,18 @@ for it in raw if isinstance(raw,list) else []:
     iid=it.get("item_id") or it.get("id")
     if not iid:
         continue
-    items.append({"item_id":iid,"kind":it.get("kind"),"ref":it.get("ref"),"status":"failing"})
+    items.append({"item_id":iid,"kind":it.get("kind") or "","ref":it.get("ref") or ""})
 print(json.dumps({"items":items},ensure_ascii=False))
 PY
+  # El hub exige al menos un ítem (WiringChecklistSeeded.items min_length=1): un checklist
+  # vacío es rechazo garantizado — se corta aquí, sin encolar.
+  local n_items
+  n_items="$(python3 -c 'import json,sys;print(len(json.load(open(sys.argv[1])).get("items") or []))' "$pfile" 2>/dev/null || echo 0)"
+  if [ "$n_items" = 0 ]; then
+    rm -f "$pfile"
+    echo "⛔ el checklist no tiene items válidos (item_id obligatorio): el hub exige al menos uno" >&2
+    return $OPS_RC_REJECTED
+  fi
   mode="$(ops_mode)"
   if [ "$mode" = "dual" ]; then
     ops_mirror wiring_checklist_seeded "$pfile" || echo "⚠ siembra de wiring no espejada; el comparador dual la marcará" >&2
@@ -812,14 +873,15 @@ cmd_progress() {
   fi
   mode="$(ops_mode)"
   [ "$mode" = "legacy" ] && { echo "LEGACY: apendiza la nota en progress_log[] del fichero"; return $OPS_RC_LEGACY; }
+  # [#44] Nombre del catálogo v2: `progress_noted` (payload {note}, sin cambio de claves).
   payload="{\"note\":$(_ops_evidence_json "$nota" "$file")}"
   if [ "$mode" = "dual" ]; then
-    _ops_dual_mirror progress_note_recorded "$payload"
+    _ops_dual_mirror progress_noted "$payload"
     return $?
   fi
   sid="$(ops_slice_id)"
   pfile="$(ops_tmpjson "$payload")" || return $OPS_RC_OFFLINE
-  if ops_enqueue_from_file progress_note_recorded "$pfile" "$sid"; then
+  if ops_enqueue_from_file progress_noted "$pfile" "$sid"; then
     rm -f "$pfile"
     echo "nota de progreso encolada"
     return $OPS_RC_OK
@@ -846,14 +908,23 @@ cmd_checkpoint() {
   root="$(config_root)"
   branch="$(git -C "$root" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")"
   commit="$(git -C "$root" rev-parse HEAD 2>/dev/null || echo "")"
+  # [#44] Contrato real del hub: la nota se llama `summary` (CheckpointIn, max 1000; el
+  # catálogo CheckpointRecorded también). `note` se descartaba en silencio en el sync y
+  # era rechazo por extra="forbid" en la cola. Tope 970 + marcador < 1000.
+  local sumjson
+  if [ -n "$file" ]; then sumjson="$(ops_json_str_file "$file" 970)"; else sumjson="$(ops_json_str "$nota")"; fi
   if [ "$mode" = "dual" ]; then
-    payload="{\"branch\":$(ops_json_str "$branch"),\"commit_sha\":$(ops_json_str "$commit"),\"note\":$(_ops_evidence_json "$nota" "$file")}"
-    _ops_dual_mirror checkpoint_created "$payload"
+    payload="{\"branch\":$(ops_json_str "$branch"),\"commit_sha\":$(ops_json_str "$commit"),\"summary\":$sumjson}"
+    _ops_dual_mirror checkpoint_recorded "$payload"
     return $?
   fi
   sid="$(_ops_require_slice)" || return $OPS_RC_NO_SLICE
-  payload="{\"slice_id\":$(ops_json_str "$sid"),\"branch\":$(ops_json_str "$branch"),\"commit_sha\":$(ops_json_str "$commit"),\"note\":$(_ops_evidence_json "$nota" "$file")}"
-  _ops_post_or_queue "$OPS_PATH_CHECKPOINTS" "$payload" checkpoint_created "$sid" "el checkpoint"
+  # El body síncrono lleva slice_id (POST /checkpoints, CheckpointIn); el payload del
+  # EVENTO no lo admite (extra="forbid"): el slice_id va de primer nivel en la cola.
+  payload="{\"slice_id\":$(ops_json_str "$sid"),\"branch\":$(ops_json_str "$branch"),\"commit_sha\":$(ops_json_str "$commit"),\"summary\":$sumjson}"
+  local queue_payload
+  queue_payload="{\"branch\":$(ops_json_str "$branch"),\"commit_sha\":$(ops_json_str "$commit"),\"summary\":$sumjson}"
+  _ops_post_or_queue "$OPS_PATH_CHECKPOINTS" "$payload" checkpoint_recorded "$sid" "el checkpoint" "$queue_payload"
 }
 
 SUB="${1:-}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycore/spec-build-harness",
-  "version": "0.10.0",
+  "version": "0.11.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/denylist.txt

@@ -28,3 +28,7 @@ cedula
 Gemini
 GEMINI_API_KEY
 validacion-documental
+
+# Piloto runtime 2026-08
+Oriuno
+diagramador-ia-for-process