@trycore/spec-build-harness 0.11.1 → 0.13.0

package/scripts/tests/test-skill-ops.sh

@@ -83,7 +83,7 @@ rm -f "$PROJ/.claude/state/outbox/"*.json
 # protegidos porque la capa de compat del despacho los traduce y entrega.)
 for t in slice_archived wiring_item_updated slice_escalated gate_verdict checkpoint_recorded \
          project_fact_updated wiring_checklist_seeded slice_submitted handoff_recorded telemetry_gap \
-         checkpoint_created verdict_reported escalation_raised; do
+         phase_advanced checkpoint_created verdict_reported escalation_raised; do
   case " $RUNTIME_OUTBOX_PROTECTED " in
     *" $t "*) : ;;
     *) echo "FAIL $t no está en RUNTIME_OUTBOX_PROTECTED"; fail=1 ;;
@@ -394,6 +394,28 @@ rc=$?
 echo "$out" | grep -q "modo:" && echo "$out" | grep -q "sl-7" && echo "$out" | grep -qi "cola" \
   && echo "OK status informa modo, slice y cola" || { echo "FAIL status incompleto: $out"; fail=1; }
 
+# [issue #52] Visibilidad de outbox/rejected/: sin rechazados, status lo dice («ninguno»);
+# con rechazados, reporta el conteo y la RAZÓN del más reciente — hoy un slice_archived
+# rechazado era invisible (cola 0 pendientes = «éxito» aparente).
+echo "$out" | grep -qi "rechazados" && echo "$out" | grep -qi "ninguno" \
+  && echo "OK status sin rechazados reporta «ninguno»" || { echo "FAIL status sin línea de rechazados: $out"; fail=1; }
+mkdir -p "$PROJ/.claude/state/outbox/rejected"
+cat > "$PROJ/.claude/state/outbox/rejected/20260828000000000001-cid-rej-1.json" <<'JSON'
+{"client_event_id": "cid-rej-1", "type": "progress_noted", "payload": {"note": "x"},
+ "enqueued_at": "2026-08-28T00:00:00.000000Z", "rejected_reason": "razón vieja"}
+JSON
+cat > "$PROJ/.claude/state/outbox/rejected/20260828000000000002-cid-rej-2.json" <<'JSON'
+{"client_event_id": "cid-rej-2", "type": "slice_archived", "payload": {},
+ "enqueued_at": "2026-08-28T00:00:01.000000Z", "slice_id": "sl-7",
+ "rejected_reason": "archivar exige estar en la fase pr"}
+JSON
+out="$(bash "$SO" status --no-refresh)"
+echo "$out" | grep -q "2 evento(s)" && echo "$out" | grep -q "⚠" \
+  && echo "OK status reporta el conteo de rechazados con ⚠" || { echo "FAIL status sin conteo de rechazados: $out"; fail=1; }
+echo "$out" | grep -q "slice_archived" && echo "$out" | grep -q "archivar exige estar en la fase pr" \
+  && echo "OK status muestra tipo y razón del rechazo más reciente" || { echo "FAIL status sin razón del último rechazo: $out"; fail=1; }
+rm -rf "$PROJ/.claude/state/outbox/rejected"
+
 # status es informativo: NUNCA falla aunque no haya nada.
 rm -f "$PROJ/.claude/state/runtime-projection.json"
 rc=0; out="$(TRYCORE_RUNTIME_MODE=legacy bash "$SO" status --no-refresh)" || rc=$?
@@ -430,20 +452,20 @@ n="$(find "$PROJ/.claude/state/outbox" -name '*.json' 2>/dev/null | wc -l | tr -
   || { echo "FAIL escalate con outbox no escribible (rc=$rc n=$n out=$out)"; fail=1; }
 rm -f "$PROJ/.claude/state/outbox/"*.json
 
-# usage: lista los 13 subcomandos REALMENTE implementados (contrato con la prosa de las
-# skills) — el plan queda completo con la Task 4 (wiring/progress/checkpoint).
+# usage: lista los 14 subcomandos REALMENTE implementados (contrato con la prosa de las
+# skills) — 13 del plan EP-OR-08-C + `phase` (issue #52).
 usage_out="$(bash "$SO" --help 2>&1)"
-for sub in mode claim next-step gate submit archive wiring progress checkpoint fact propose-asset status escalate; do
+for sub in mode claim next-step phase gate submit archive wiring progress checkpoint fact propose-asset status escalate; do
   echo "$usage_out" | grep -q -- "$sub" || { echo "FAIL usage no documenta $sub"; fail=1; }
 done
 echo "$usage_out" | grep -qi "pendientes" \
   && { echo "FAIL usage todavía anuncia pendientes tras completar la Task 4"; fail=1; } \
-  || echo "OK usage documenta los 13 subcomandos como implementados, sin pendientes"
+  || echo "OK usage documenta los 14 subcomandos como implementados, sin pendientes"
 
 # Regresión de modo LEGACY sobre TODOS los subcomandos IMPLEMENTADOS que transicionan:
-# rc 3 y cero red (los 13, ya con wiring/progress/checkpoint de la Task 4).
+# rc 3 y cero red (los 14, ya con phase del issue #52).
 : > "$TMP/curl-legacy.log"
-for sub in "gate tdd pass" "submit" "archive" "wiring update w1 passing" "progress algo" "checkpoint --note algo" "fact project-kind greenfield" "propose-asset --type-key t --path p --content-file $TMP/asset.md" "escalate algo --gate fidelity"; do
+for sub in "phase pr" "gate tdd pass" "submit" "archive" "wiring update w1 passing" "progress algo" "checkpoint --note algo" "fact project-kind greenfield" "propose-asset --type-key t --path p --content-file $TMP/asset.md" "escalate algo --gate fidelity"; do
   rc=0
   bash -c "PATH=\"$TMP/fakebin:\$PATH\" FAKE_CURL_LOG=\"$TMP/curl-legacy.log\" TRYCORE_RUNTIME_MODE=legacy CLAUDE_PROJECT_DIR=\"$PROJ\" BUILD_CONFIG_FILE=\"$BUILD_CONFIG_FILE\" bash \"$SO\" $sub" >/dev/null 2>&1 || rc=$?
   [ "$rc" = 3 ] || { echo "FAIL «${sub}» en legacy devolvió $rc (esperado 3)"; fail=1; }
@@ -694,6 +716,186 @@ n="$(find "$PROJ/.claude/state/outbox" -name '*.json' 2>/dev/null | wc -l | tr -
   || { echo "FAIL archive con outbox no escribible (rc=$rc n=$n out=$out)"; fail=1; }
 rm -f "$PROJ/.claude/state/outbox/"*.json
 
+# ══════════════ slice-ops.sh: phase (cadena de fases del hub) [issue #52] ══════════════
+# El hub modela la fase con `phase_advanced {to}` de ORDEN ESTRICTO (domain.py:400-407,
+# PHASES dor→…→pr→archived) y `slice_archived` exige phase == pr (domain.py:499-500).
+# Sin este subcomando el slice se quedaba en dor server-side y el archivado caía a
+# rejected/ EN SILENCIO (piloto 2026-08-28).
+
+# Sin argumento: uso incorrecto.
+rc=0; bash "$SO" phase >/dev/null 2>&1 || rc=$?
+[ "$rc" = 2 ] && echo "OK phase sin argumento -> rc 2" || { echo "FAIL phase sin argumento rc ($rc)"; fail=1; }
+
+# Fase desconocida (o archived, que no se reporta por aquí): rechazo LOCAL, sin red ni cola.
+rm -f "$PROJ/.claude/state/outbox/"*.json
+: > "$TMP/calls-ga.jsonl"
+rc=0; bash "$SO" phase inventada >/dev/null 2>&1 || rc=$?
+n="$(find "$PROJ/.claude/state/outbox" -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
+[ "$rc" = 6 ] && [ "$n" = 0 ] && echo "OK phase desconocida -> rc 6 sin encolar" || { echo "FAIL phase desconocida (rc=$rc n=$n)"; fail=1; }
+rc=0; bash "$SO" phase archived >/dev/null 2>&1 || rc=$?
+[ "$rc" = 6 ] && echo "OK phase archived -> rc 6 (archived se alcanza con archive, no con phase)" || { echo "FAIL phase archived rc ($rc)"; fail=1; }
+
+# Runtime, un paso: el servidor conoce «red» -> `phase green` encola EXACTAMENTE un
+# phase_advanced {to: green} con slice_id.
+python3 - "$TMP/routes-ga.json" <<'PYX'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":True},"active_slice":{"slice_id":"sl-7","phase":"red","gates":{"dor":True}},"context":{"manifest_hash":"sha256:v1"}}}
+json.dump(d,open(p,"w"))
+PYX
+rm -f "$PROJ/.claude/state/outbox/"*.json
+rc=0; out="$(bash "$SO" phase green)" || rc=$?
+[ "$rc" = 0 ] && echo "OK phase green -> rc 0" || { echo "FAIL phase green rc ($rc)"; fail=1; }
+[ "$(python3 - "$PROJ/.claude/state/outbox" <<'PYX'
+import json,sys,glob,os
+evs=[json.load(open(p)) for p in sorted(glob.glob(os.path.join(sys.argv[1],"*.json"))) if not os.path.basename(p).startswith(".")]
+pa=[e for e in evs if e.get("type")=="phase_advanced"]
+ok = len(evs)==1 and len(pa)==1 and pa[0]["payload"]=={"to":"green"} and pa[0].get("slice_id")=="sl-7"
+print("SI" if ok else "NO")
+PYX
+)" = SI ] && echo "OK phase green encola un único phase_advanced {to} con slice_id" \
+  || { echo "FAIL evento(s) de phase green"; fail=1; }
+
+# Cadena con huecos: el servidor sigue en «red»; `phase pr` emite green→…→pr EN ORDEN
+# (el orden estricto del hub no admite saltos) y avisa del hueco.
+rm -f "$PROJ/.claude/state/outbox/"*.json
+rc=0; out="$(bash "$SO" phase pr 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "OK phase pr con huecos -> rc 0" || { echo "FAIL phase pr rc ($rc)"; fail=1; }
+[ "$(python3 - "$PROJ/.claude/state/outbox" <<'PYX'
+import json,sys,glob,os
+tos=[json.load(open(p))["payload"].get("to") for p in sorted(glob.glob(os.path.join(sys.argv[1],"*.json")))
+     if not os.path.basename(p).startswith(".") and json.load(open(p)).get("type")=="phase_advanced"]
+print("SI" if tos==["green","refactor","smoke","api","data","dod","pr"] else "NO:"+",".join(str(t) for t in tos))
+PYX
+)" = SI ] && echo "OK phase pr encola la cadena green→…→pr en orden" || { echo "FAIL cadena de phase pr"; fail=1; }
+echo "$out" | grep -q "⚠" && echo "OK phase pr avisa del hueco rellenado" || { echo "FAIL phase pr sin aviso de hueco ($out)"; fail=1; }
+
+# Idempotencia contra la COLA: la cadena ya está pendiente en la outbox -> repetir
+# `phase pr` no encola nada nuevo (el daemon aún no drenó, pero el cliente ya lo sabe).
+n_antes="$(find "$PROJ/.claude/state/outbox" -name '*.json' ! -name '.dispatch-state.json' | wc -l | tr -d ' ')"
+rc=0; bash "$SO" phase pr >/dev/null 2>&1 || rc=$?
+n_despues="$(find "$PROJ/.claude/state/outbox" -name '*.json' ! -name '.dispatch-state.json' | wc -l | tr -d ' ')"
+[ "$rc" = 0 ] && [ "$n_antes" = "$n_despues" ] \
+  && echo "OK phase pr repetido es idempotente (cuenta la cola pendiente)" \
+  || { echo "FAIL idempotencia por cola (antes=$n_antes despues=$n_despues rc=$rc)"; fail=1; }
+
+# Idempotencia contra la PROYECCIÓN: el servidor ya está en pr -> nada que emitir.
+python3 - "$TMP/routes-ga.json" <<'PYX'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":True},"active_slice":{"slice_id":"sl-7","phase":"pr","gates":{"dor":True}},"context":{"manifest_hash":"sha256:v1"}}}
+json.dump(d,open(p,"w"))
+PYX
+rm -f "$PROJ/.claude/state/outbox/"*.json
+rc=0; out="$(bash "$SO" phase pr)" || rc=$?
+n="$(find "$PROJ/.claude/state/outbox" -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
+[ "$rc" = 0 ] && [ "$n" = 0 ] && echo "OK phase pr con el servidor ya en pr -> no-op idempotente" \
+  || { echo "FAIL idempotencia por proyección (rc=$rc n=$n out=$out)"; fail=1; }
+
+# Catch-up en archive [issue #52]: slice_archived exige phase == pr — si el servidor quedó
+# atrás (pipeline corrido con una skill vieja, sin llamadas a `phase`), archive emite la
+# cadena que falte ANTES del archivado, con aviso. Es el workaround del piloto hecho sistema.
+python3 - "$TMP/routes-ga.json" <<'PYX'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":True},"active_slice":{"slice_id":"sl-7","phase":"dor","gates":{"dor":True}},"context":{"manifest_hash":"sha256:v1"}}}
+json.dump(d,open(p,"w"))
+PYX
+agent_context_fetch_and_cache >/dev/null
+rm -f "$PROJ/.claude/state/outbox/"*.json
+rc=0; out="$(bash "$SO" archive --epic EP-003 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "OK archive con catch-up -> rc 0" || { echo "FAIL archive catch-up rc ($rc)"; fail=1; }
+[ "$(python3 - "$PROJ/.claude/state/outbox" <<'PYX'
+import json,sys,glob,os
+evs=[json.load(open(p)) for p in sorted(glob.glob(os.path.join(sys.argv[1],"*.json"))) if not os.path.basename(p).startswith(".")]
+tos=[e["payload"].get("to") for e in evs if e.get("type")=="phase_advanced"]
+tipos=[e.get("type") for e in evs]
+ok = tos==["change","red","green","refactor","smoke","api","data","dod","pr"] \
+  and tipos[-1]=="slice_archived" and all(t=="phase_advanced" for t in tipos[:-1]) \
+  and all(e.get("slice_id")=="sl-7" for e in evs)
+print("SI" if ok else "NO:"+",".join(tipos))
+PYX
+)" = SI ] && echo "OK archive encola la cadena dor→…→pr ANTES de slice_archived" \
+  || { echo "FAIL catch-up de archive"; fail=1; }
+echo "$out" | grep -q "server-side" && echo "OK archive avisa del catch-up (slice atrasado server-side)" \
+  || { echo "FAIL archive sin aviso de catch-up ($out)"; fail=1; }
+rm -f "$PROJ/.claude/state/outbox/"*.json
+
+# archive con el servidor ya en pr: SOLO slice_archived, sin cadena ni aviso.
+python3 - "$TMP/routes-ga.json" <<'PYX'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":True},"active_slice":{"slice_id":"sl-7","phase":"pr","gates":{"dor":True}},"context":{"manifest_hash":"sha256:v1"}}}
+json.dump(d,open(p,"w"))
+PYX
+agent_context_fetch_and_cache >/dev/null
+rc=0; out="$(bash "$SO" archive --epic EP-003 2>&1)" || rc=$?
+n_pa="$(grep -l '"type": "phase_advanced"' "$PROJ/.claude/state/outbox/"*.json 2>/dev/null | wc -l | tr -d ' ')"
+n_ar="$(grep -l '"type": "slice_archived"' "$PROJ/.claude/state/outbox/"*.json 2>/dev/null | wc -l | tr -d ' ')"
+[ "$rc" = 0 ] && [ "$n_pa" = 0 ] && [ "$n_ar" = 1 ] && ! echo "$out" | grep -q "server-side" \
+  && echo "OK archive con el servidor en pr no emite cadena ni aviso" \
+  || { echo "FAIL archive sin catch-up (rc=$rc pa=$n_pa ar=$n_ar)"; fail=1; }
+rm -f "$PROJ/.claude/state/outbox/"*.json
+
+# dual: phase ESPEJA (phase_advanced ∈ TIPOS_DE_ESPEJO del hub) con la identidad local,
+# sin tocar la cola — mismo patrón que gate/submit en dual.
+cat > "$PROJ/.claude/state/build-state.json" <<'JSON'
+{"version":"1.0.0","active_slice":{"epica":"EP-009","openspec_change":"add-pagos","branch":"feature/pagos","phase":"green","gates":{"dor":true}}}
+JSON
+python3 - "$TMP/routes-ga.json" <<'PYX'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":True},"active_slice":{"slice_id":"sl-7","phase":"red","gates":{"dor":True}},"context":{"manifest_hash":"sha256:v1"}}}
+json.dump(d,open(p,"w"))
+PYX
+: > "$TMP/calls-ga.jsonl"
+rm -f "$PROJ/.claude/state/outbox/"*.json
+rc=0; TRYCORE_RUNTIME_MODE=dual bash "$SO" phase green >/dev/null 2>&1 || rc=$?
+n="$(find "$PROJ/.claude/state/outbox" -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
+[ "$rc" = 0 ] && [ "$n" = 0 ] && echo "OK phase en dual -> rc 0 sin encolar" || { echo "FAIL phase dual (rc=$rc n=$n)"; fail=1; }
+[ "$(python3 - "$TMP/calls-ga.jsonl" <<'PYX'
+import json,sys
+tos=[]
+for line in open(sys.argv[1]):
+    c=json.loads(line)
+    if c["path"]=="/projects/p-1/mirror/transitions":
+        b=json.loads(c["body"])
+        if b.get("kind")=="phase_advanced":
+            tos.append((b["payload"].get("to"), b["payload"].get("slice_ref",{}).get("epic_code")))
+print("SI" if tos==[("green","EP-009")] else "NO:"+repr(tos))
+PYX
+)" = SI ] && echo "OK phase en dual espeja phase_advanced {to} con slice_ref" \
+  || { echo "FAIL espejo de phase en dual"; fail=1; }
+
+# dual: archive también hace catch-up por el espejo (cadena red→…→pr antes del archivado).
+: > "$TMP/calls-ga.jsonl"
+rc=0; out="$(TRYCORE_RUNTIME_MODE=dual bash "$SO" archive --epic EP-009 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "$out" | grep -q "server-side" \
+  && echo "OK archive en dual avisa del catch-up" || { echo "FAIL archive dual catch-up (rc=$rc out=$out)"; fail=1; }
+[ "$(python3 - "$TMP/calls-ga.jsonl" <<'PYX'
+import json,sys
+kinds=[]
+for line in open(sys.argv[1]):
+    c=json.loads(line)
+    if c["path"]=="/projects/p-1/mirror/transitions":
+        b=json.loads(c["body"])
+        kinds.append((b.get("kind"), b["payload"].get("to")))
+esperado=[("phase_advanced",t) for t in ["green","refactor","smoke","api","data","dod","pr"]]+[("slice_archived",None)]
+print("SI" if kinds==esperado else "NO:"+repr(kinds))
+PYX
+)" = SI ] && echo "OK archive en dual espeja la cadena hasta pr y luego slice_archived" \
+  || { echo "FAIL cadena del archive dual"; fail=1; }
+
+# Restaura la ruta y la caché al estado que esperan los bloques siguientes (sl-7, fase tdd).
+python3 - "$TMP/routes-ga.json" <<'PYX'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":True},"active_slice":{"slice_id":"sl-7","phase":"tdd","gates":{"dor":True,"tdd":False}},"context":{"manifest_hash":"sha256:v1"}}}
+json.dump(d,open(p,"w"))
+PYX
+agent_context_fetch_and_cache >/dev/null
+rm -f "$PROJ/.claude/state/outbox/"*.json
+
 # dual: el fichero es primario -> se espeja la transición con la identidad LOCAL.
 cat > "$PROJ/.claude/state/build-state.json" <<'JSON'
 {"version":"1.0.0","active_slice":{"epica":"EP-009","openspec_change":"add-pagos","branch":"feature/pagos","phase":"tdd","gates":{"dor":true}}}
@@ -1036,6 +1238,14 @@ nr="$(find "$PROJ/.claude/state/outbox/rejected" -name '*.json' 2>/dev/null | wc
 [ "$n" = 0 ] && [ "$nr" = 1 ] \
   && echo "OK el elemento rechazado por el hub se aparta a rejected/ (no se reenvía)" \
   || { echo "FAIL elemento rechazado (pendientes=$n rechazados=$nr)"; fail=1; }
+# [issue #52] La razón del hub queda PERSISTIDA en el fichero apartado (rejected_reason):
+# es lo que `slice-ops.sh status` y `trycore-build status/doctor` muestran después.
+fr="$(find "$PROJ/.claude/state/outbox/rejected" -name '*.json' | head -1)"
+[ -n "$fr" ] && [ "$(python3 -c "
+import json;d=json.load(open('$fr'))
+print('SI' if 'desconocido para el catálogo v2' in (d.get('rejected_reason') or '') else 'NO')")" = SI ] \
+  && echo "OK el fichero apartado conserva la razón del hub (rejected_reason)" \
+  || { echo "FAIL rejected/ sin rejected_reason persistida"; fail=1; }
 # [#44] El fichero 0.10.x `verdict_reported {gate, status}` viajó TRADUCIDO al catálogo v2
 # (gate_verdict {gate, verdict: PASS}) — la traducción vive en el único punto de salida.
 [ "$(python3 - "$TMP/calls-ga.jsonl" <<'PYX'
@@ -1107,6 +1317,15 @@ nr="$(find "$PROJ/.claude/state/outbox/rejected" -name '*.json' 2>/dev/null | wc
 [ "$rc" = 0 ] && [ "$n" = 0 ] && [ "$nr" = 3 ] && ! grep -q '"path": "/events"' "$TMP/calls-ga.jsonl" \
   && echo "OK los tipos sin equivalente se apartan localmente a rejected/ sin tocar la red" \
   || { echo "FAIL pre-filtro de tipos sin equivalente (rc=$rc pendientes=$n rechazados=$nr)"; fail=1; }
+# [issue #52] También el apartado local persiste su razón (rejected_reason).
+[ "$(python3 - "$PROJ/.claude/state/outbox/rejected" <<'PYX'
+import json,glob,os,sys
+ok=all("catálogo" in (json.load(open(p)).get("rejected_reason") or "")
+       for p in glob.glob(os.path.join(sys.argv[1],"*.json")))
+print("SI" if ok else "NO")
+PYX
+)" = SI ] && echo "OK los tipos sin equivalente llevan rejected_reason" \
+  || { echo "FAIL apartado local sin rejected_reason"; fail=1; }
 rm -rf "$PROJ/.claude/state/outbox/rejected"
 
 # [#44] telemetry_gap de la evicción con el payload del catálogo: {dropped, window_h,
@@ -1154,6 +1373,13 @@ n="$(find "$PROJ/.claude/state/outbox" -maxdepth 1 -name '*.json' ! -name '.disp
 nr="$(find "$PROJ/.claude/state/outbox/rejected" -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
 [ "$n" = 0 ] && [ "$nr" = 1 ] && echo "OK el lote 4xx se mueve a rejected/ y no se reintenta" \
   || { echo "FAIL lote 4xx (pendientes=$n rechazados=$nr)"; fail=1; }
+# [issue #52] El lote 4xx también persiste su razón (HTTP status) en cada fichero apartado.
+fr="$(find "$PROJ/.claude/state/outbox/rejected" -name '*.json' | head -1)"
+[ -n "$fr" ] && [ "$(python3 -c "
+import json;d=json.load(open('$fr'))
+print('SI' if '422' in (d.get('rejected_reason') or '') else 'NO')")" = SI ] \
+  && echo "OK el lote 4xx conserva la razón (HTTP 422) en rejected_reason" \
+  || { echo "FAIL lote 4xx sin rejected_reason"; fail=1; }
 echo "$err" | grep -q "dict_type" && echo "OK el 4xx loggea el cuerpo del error del hub" \
   || { echo "FAIL 4xx sin cuerpo del error ($err)"; fail=1; }
 [ ! -f "$PROJ/.claude/state/outbox/.dispatch-state.json" ] \
@@ -1202,6 +1428,7 @@ CATALOGO = {
     "handoff_recorded":        {"claves": {"note", "resume_hint", "stopped_at"},
                                 "obligatorias": {"note"}, "ambito": "slice"},
     "slice_escalated":         {"claves": {"cause"}, "obligatorias": {"cause"}, "ambito": "slice"},
+    "phase_advanced":          {"claves": {"to"}, "obligatorias": {"to"}, "ambito": "slice"},
     "slice_submitted":         {"claves": set(), "obligatorias": set(), "ambito": "slice"},
     "slice_archived":          {"claves": set(), "obligatorias": set(), "ambito": "slice"},
     "wiring_checklist_seeded": {"claves": {"items"}, "obligatorias": {"items"}, "ambito": "slice"},
@@ -1240,7 +1467,8 @@ fuera=sorted(t for t in encontrados if t not in catalogo)
 # el guard está ciego y también es un fallo.
 esperados={"gate_verdict","checkpoint_recorded","progress_noted","slice_escalated",
            "slice_submitted","slice_archived","wiring_checklist_seeded",
-           "wiring_item_updated","project_fact_updated","handoff_recorded"}
+           "wiring_item_updated","project_fact_updated","handoff_recorded",
+           "phase_advanced"}
 ciegos=sorted(esperados-encontrados)
 if fuera:
     print("FUERA_DE_CATALOGO:"+",".join(fuera))
@@ -1258,6 +1486,7 @@ PYX
 runtime_credentials_merge '{"runtime_url":"http://127.0.0.1:9"}'
 rm -f "$PROJ/.claude/state/outbox/"*.json "$PROJ/.claude/state/outbox/.dispatch-state.json"
 bash "$SO" gate tdd pass --evidence "verde" >/dev/null 2>&1
+bash "$SO" phase red >/dev/null 2>&1
 bash "$SO" submit --pr-url "https://example.invalid/pr/9" >/dev/null 2>&1
 bash "$SO" archive --epic EP-003 >/dev/null 2>&1
 bash "$SO" wiring seed --file "$TMP/items-small.json" >/dev/null 2>&1
@@ -1303,7 +1532,7 @@ for path in sorted(glob.glob(os.path.join(sys.argv[2],"*.json"))):
                 errores.append("wiring_checklist_seeded: item fuera de schema %r" % it); break
 esperados={"gate_verdict","slice_submitted","slice_archived","wiring_checklist_seeded",
            "wiring_item_updated","progress_noted","checkpoint_recorded","slice_escalated",
-           "project_fact_updated","telemetry_gap"}
+           "project_fact_updated","telemetry_gap","phase_advanced"}
 faltantes=sorted(esperados-vistos)
 if faltantes:
     errores.append("productores sin evento encolado (¿cambió un subcomando?): %s" % faltantes)
@@ -1364,4 +1593,122 @@ echo 'no-json' | python3 "$GB" > /dev/null 2> "$TMP/gb3.err"
 rc=$?
 [ "$rc" = 1 ] && ! grep -q "Traceback" "$TMP/gb3.err" && echo "OK graph-bundle con entrada ilegible -> rc 1 limpio" || { echo "FAIL entrada ilegible ($rc)"; fail=1; }
 
+# ══════════ graph-bundle.py --from-docs / --print-deps [issue #56] ══════════
+# El grafo llegaba al hub con `depends_on: []` (41/41 épicas en el piloto): la
+# extracción vivía en el LLM y el ejemplo de onboard anclaba en []. El extractor
+# es ahora DETERMINISTA y lee la prosa de `docs/03-backlog/epicas.md`.
+mkdir -p "$TMP/docs"
+cat > "$TMP/docs/epicas.md" <<'MD'
+# Backlog — épicas
+
+**Dependencias entre épicas**: EP-999 (esto está FUERA de toda sección: se ignora)
+
+## EP-001 — Cimiento
+
+**Depende de**: nada.
+
+**Resumen**: base técnica.
+
+---
+
+## EP-002 — Cobros
+
+**Anexo A**: Fase 3 · **Depende de**: **EP-001** (base de datos), EP-404 (no existe en el grafo)
+
+**Resumen**: cobra.
+
+## EP-003 — Reportes
+
+**Depende de**: EP-002 (pipeline de export),
+EP-001 (cimiento). Ninguna bloquea: todas archivadas.
+
+**Resumen**: reporta.
+
+## EP-004 — Estructurada
+
+depende_de: [EP-003]
+
+**Depende de**: EP-001 en prosa — gana el campo estructurado.
+
+## EP-005 — Autorreferente
+
+**Depende de**: EP-005 (a sí misma: se excluye), EP-001
+MD
+
+# 1) --print-deps: extracción pura, determinista, inspeccionable.
+out="$(python3 "$GB" --print-deps "$TMP/docs/epicas.md" 2> "$TMP/gb4.err")"
+rc=$?
+# `**Depende de**: nada.` es una declaración, no una ausencia: entra con lista vacía.
+esperado='{"EP-001": [], "EP-002": ["EP-001", "EP-404"], "EP-003": ["EP-001", "EP-002"], "EP-004": ["EP-003"], "EP-005": ["EP-001"]}'
+[ "$rc" = 0 ] && [ "$(echo "$out" | python3 -c 'import json,sys;print(json.dumps(json.load(sys.stdin),sort_keys=True))')" = "$esperado" ] \
+  && echo "OK --print-deps extrae de la prosa (multilínea, campo estructurado, sin autorreferencia)" \
+  || { echo "FAIL --print-deps ($rc) -> $out"; fail=1; }
+
+# 2) --from-docs puebla el grafo aunque el JSON del modelo traiga depends_on vacíos.
+cat > "$TMP/epics56.json" <<'JSON'
+{"project_ref":"acme","epics":[
+  {"code":"EP-001","title":"Cimiento","layer":"foundational","depends_on":[]},
+  {"code":"EP-002","title":"Cobros","layer":"business","depends_on":[]},
+  {"code":"EP-003","title":"Reportes","layer":"business","depends_on":[]},
+  {"code":"EP-004","title":"Estructurada","layer":"business","depends_on":["EP-002"]}
+]}
+JSON
+out="$(python3 "$GB" --from-docs "$TMP/docs/epicas.md" < "$TMP/epics56.json" 2> "$TMP/gb5.err")"
+rc=$?
+[ "$rc" = 0 ] && [ "$(echo "$out" | python3 -c 'import json,sys;d=json.load(sys.stdin);print(";".join(e["code"]+"="+",".join(e["depends_on"]) for e in d["epics"]))')" = "EP-001=;EP-002=EP-001,EP-404;EP-003=EP-001,EP-002;EP-004=EP-002,EP-003" ] \
+  && echo "OK --from-docs puebla depends_on desde los docs (unión con lo declarado)" \
+  || { echo "FAIL --from-docs ($rc) -> $out"; fail=1; }
+grep -q "EP-404" "$TMP/gb5.err" \
+  && echo "OK --from-docs mantiene el aviso de dependencia inexistente" || { echo "FAIL sin aviso de dep inexistente con --from-docs"; fail=1; }
+grep -q "EP-005" "$TMP/gb5.err" \
+  && echo "OK --from-docs avisa de la épica que está en docs pero no en el JSON" || { echo "FAIL sin aviso de épica ausente del JSON"; fail=1; }
+echo "$out" | grep -q '"depends_on_source"' \
+  && echo "OK el bundle deja traza de la fuente de dependencias" || { echo "FAIL el bundle no declara depends_on_source"; fail=1; }
+
+# 3) Los ciclos que vienen de la prosa se cazan igual (el aviso ya existía).
+cat > "$TMP/docs/ciclo.md" <<'MD'
+## EP-010 — A
+**Depende de**: EP-011
+## EP-011 — B
+**Depende de**: EP-010
+MD
+echo '{"epics":[{"code":"EP-010","title":"A","layer":"business"},{"code":"EP-011","title":"B","layer":"business"}]}' \
+  | python3 "$GB" --from-docs "$TMP/docs/ciclo.md" > /dev/null 2> "$TMP/gb6.err"
+rc=$?
+[ "$rc" = 0 ] && grep -qi "ciclo" "$TMP/gb6.err" \
+  && echo "OK --from-docs + ciclo de la prosa -> aviso, sin bloquear" || { echo "FAIL ciclo desde docs ($rc)"; fail=1; }
+
+# 4) Ruta ilegible: rc 1 con mensaje, jamás traceback ni silencio (el fallo del piloto
+#    fue precisamente un grafo vacío que no falló).
+echo '{"epics":[]}' | python3 "$GB" --from-docs "$TMP/docs/no-existe.md" > /dev/null 2> "$TMP/gb7.err"
+rc=$?
+[ "$rc" = 1 ] && ! grep -q "Traceback" "$TMP/gb7.err" \
+  && echo "OK --from-docs con ruta ilegible -> rc 1 limpio" || { echo "FAIL ruta ilegible ($rc)"; fail=1; }
+# Flag sin argumento: mismo trato.
+echo '{"epics":[]}' | python3 "$GB" --from-docs > /dev/null 2> "$TMP/gb8.err"
+[ "$?" = 1 ] && ! grep -q "Traceback" "$TMP/gb8.err" \
+  && echo "OK --from-docs sin argumento -> rc 1 limpio" || { echo "FAIL --from-docs sin argumento"; fail=1; }
+
+# 4-bis) Sección presente pero SIN el campo: aviso distinto al de sección ausente
+#        (un backlog que dibuja sus dependencias en ASCII no es un backlog sin épicas).
+printf '## EP-020 — Con seccion, sin campo\n\n**Resumen**: x.\n' > "$TMP/docs/sin-campo.md"
+echo '{"epics":[{"code":"EP-020","title":"X","layer":"business"},{"code":"EP-021","title":"Y","layer":"business"}]}' \
+  | python3 "$GB" --from-docs "$TMP/docs/sin-campo.md" > /dev/null 2> "$TMP/gb10.err"
+grep -q "EP-020 tiene sección" "$TMP/gb10.err" && grep -q "EP-021 no aparece como sección" "$TMP/gb10.err" \
+  && echo "OK distingue sección sin campo de épica ausente de los docs" || { echo "FAIL avisos de cobertura de docs"; fail=1; }
+
+# 4-ter) Las dos banderas juntas son un error explícito (ignorar una en silencio es el
+#        patrón que causó #56).
+echo '{"epics":[]}' | python3 "$GB" --from-docs "$TMP/docs/epicas.md" --print-deps "$TMP/docs/epicas.md" > /dev/null 2> "$TMP/gb11.err"
+[ "$?" = 1 ] && grep -qi "excluyentes" "$TMP/gb11.err" \
+  && echo "OK --from-docs y --print-deps juntas -> rc 1 explícito" || { echo "FAIL banderas excluyentes"; fail=1; }
+
+# 5) Sin sección de épica reconocible: aviso explícito (no silencio).
+printf 'texto sin encabezados de epica\n' > "$TMP/docs/vacio.md"
+echo '{"epics":[{"code":"EP-001","title":"X","layer":"business"}]}' \
+  | python3 "$GB" --from-docs "$TMP/docs/vacio.md" > /dev/null 2> "$TMP/gb9.err"
+grep -qi "ninguna secci" "$TMP/gb9.err" \
+  && echo "OK avisa cuando los docs no traen secciones de épica" || { echo "FAIL sin aviso de docs sin épicas"; fail=1; }
+
+
 exit $fail

package/skills/building-a-slice/SKILL.md

@@ -133,6 +133,16 @@ Espejo de la Fase 0, para proyectos **con UI**. Antes de abrir el primer slice c
 | 7 · pr | Abrir PR + archivar change en el mismo PR | `opsx:archive`, `opsx:sync` | — | `gitflow.md` |
 | 8 · release? | Preguntar si correr el Release Gate ahora | usuario (default computado) | — | abajo |
 
+> **Reporta la fase al runtime en cada transición** (modos `dual`/`runtime`; en `legacy` el
+> comando devuelve rc 3 y no haces nada): `bash .claude/hooks/build/slice-ops.sh phase <to>`
+> **al entrar** en cada fase. Las fases del hub son más finas que las de esta tabla:
+> `dor → change → red → green → refactor → smoke → api → data → dod → pr` — la fase 3 · tdd
+> reporta **tres** (`phase red` al escribir el test rojo, `phase green` al pasarlo,
+> `phase refactor` al refactorizar) y la 5 reporta `api` y luego `data`; la 7 · pr reporta
+> `phase pr` al abrir el PR. El subcomando es idempotente y rellena huecos solo (cadena
+> completa, el orden del hub es estricto); sin estos reportes el slice queda «en
+> construcción» en el hub aunque su PR ya esté mergeado. Ver `references/runtime-protocol.md`.
+
 Los gates `stack`, `security`, `smell`, `ux` y la coherencia triple completa **ya no se cierran
 aquí**: pertenecen al Release Gate. Las **deps** siguen vigiladas en tiempo real por el hook
 `stack-guard.sh`; lint/tsc/gitflow por sus hooks.

package/skills/building-a-slice/references/runtime-protocol.md

@@ -35,16 +35,17 @@ acto pasa por `slice-ops.sh` (inner loop) y `release-ops.sh` (outer loop), insta
 |---|---|---|
 | Reclamar | `slice-ops.sh claim [--epic EP-XXX]` | Sincroniza el contexto **antes** (regla: no se abre trabajo con contexto viejo) y reporta los sha256 locales de los archivos gobernados. Si la respuesta trae `checkpoint`, **continúa desde él; jamás reinicies**. |
 | Saber el paso | `slice-ops.sh next-step` | Lo deriva el **cliente** desde la proyección: `resume_hint` → wiring `failing` → sub-slice pendiente → primer gate abierto. |
+| Reportar la fase | `slice-ops.sh phase <to>` | **Al entrar en cada fase del pipeline** (`dor → change → red → green → refactor → smoke → api → data → dod → pr`, orden estricto del hub). Emite la cadena `phase_advanced` que falte desde la fase que el servidor conoce (nada si ya está: idempotente). Sin esto el slice se queda en `dor` server-side y el archivado se rechaza. `archived` no se reporta aquí: lo produce `archive`. |
 | Sembrar el cableado | `slice-ops.sh wiring seed --file items.json` | Un item por escenario AC y por punto de integración entre capas. Nacen `failing`. |
 | Cablear un item | `slice-ops.sh wiring update <item_id> passing --kind K --ref HU-XXX --evidence-file f` | `passing` **solo tras prueba real ejecutada**. Sin evidencia el comando avisa: no lo ignores. |
 | Cerrar un gate | `slice-ops.sh gate <nombre> <pass\|fail\|na> --evidence-file f` | Gates canónicos: `dor coherence_link tdd journey_smoke fidelity api data wiring_verified dod`. Un `na` es legítimo cuando el gate no aplica. |
 | Dejar bitácora | `slice-ops.sh progress «hito»` | Sustituye a `progress_log[]`: el event stream **es** la bitácora. |
 | Guardar continuidad | `slice-ops.sh checkpoint --note «dónde me quedé»` | Rama + commit reales. Es lo que permite que otro agente continúe tras una caída. |
 | Entregar | `slice-ops.sh submit --pr-url U --openspec-change C` | Tras abrir el PR. |
-| Archivar | `slice-ops.sh archive --epic EP-XXX --openspec-change C --pr-url U` | Lo dispara `opsx:archive` en el mismo PR. Va por cola (idempotente, protegido de la cota). |
+| Archivar | `slice-ops.sh archive --epic EP-XXX --openspec-change C --pr-url U` | Lo dispara `opsx:archive` en el mismo PR. Va por cola (idempotente, protegido de la cota). **Catch-up automático**: si la fase server-side quedó atrás, emite la cadena `phase_advanced` hasta `pr` antes del archivado y lo avisa (`⚠ … server-side`). |
 | Hechos de proyecto | `slice-ops.sh fact scaffold-confirmed --by «persona»` · `fact design-source …` · `fact project-kind …` · `fact foundation …` | **Reportan lo que un humano confirmó**; el agente nunca confirma por su cuenta. |
 | Bloqueo | `slice-ops.sh escalate «razón» --gate G` | Deja el rastro; la decisión (recortar/diferir/desbloquear) es del equipo. |
-| Ver el estado | `slice-ops.sh status` | Modo, slice, gates, wiring, contexto, lease y cola pendiente. |
+| Ver el estado | `slice-ops.sh status` | Modo, slice, gates, wiring, contexto, lease, cola pendiente y **rechazados** (`outbox/rejected/`: conteo + razón del más reciente — un rechazo del hub NO se reintenta solo; corrige la causa y re-emite). |
 
 ## Reglas duras
 
@@ -60,6 +61,10 @@ acto pasa por `slice-ops.sh` (inner loop) y `release-ops.sh` (outer loop), insta
    reconectar y el `client_event_id` evita duplicados.
 7. **El agente no gobierna.** No cierra releases, no publica contexto, no importa el grafo,
    no abre/drena/cierra fronts: prepara, propone, reporta — y el humano decide en la consola.
+8. **La fase se reporta al entrar, no al final.** El hub lleva la fase con `phase_advanced`
+   de orden estricto: invoca `phase <to>` en cada transición del pipeline. Si un pipeline
+   corrió sin reportarla, `archive` completa la cadena solo (catch-up) — pero la telemetría
+   intermedia del hub habrá estado ciega todo el slice.
 
 ## Qué queda del fichero (legado)
 

package/skills/openspec-archive-change/SKILL.md

@@ -95,7 +95,10 @@ Archive a completed change in the experimental workflow.
 
    It is queued and idempotent (protected from the outbox cap), so it survives an offline
    archive; `rc 3` simply means legacy mode (the file protocol applies). Never block the
-   archive on this step.
+   archive on this step. If the pipeline ran without phase reports, the command catches up
+   by itself: it emits the missing `phase_advanced` chain up to `pr` before the archive
+   event (the hub rejects `slice_archived` on any earlier phase) and prints a `⚠ … server-side`
+   notice — informative, not an error.
 
 6. **Display summary**