@trycore/spec-build-harness 0.14.2 → 0.16.0

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

@@ -38,6 +38,13 @@ source "$ROOT/hooks/build/lib/runtime-ops.sh" 2>/dev/null || { echo "FAIL no exi
 [ "$(ops_path_epic_proposal p-1 prop-7)" = "/projects/p-1/agent/epic-proposals/prop-7" ] \
   && echo "OK ops_path_epic_proposal" || { echo "FAIL ops_path_epic_proposal"; fail=1; }
 
+# [EP-OR-17] Re-sync del grafo: mismo carril `/agent/`. Sin él se cae en la superficie HUMANA
+# (sesión + PDP), que a un bearer de agente le responde 403 auditado.
+[ "$(ops_path_graph_sync_proposals p-1)" = "/projects/p-1/agent/graph-sync-proposals" ] \
+  && echo "OK ops_path_graph_sync_proposals" || { echo "FAIL ops_path_graph_sync_proposals"; fail=1; }
+[ "$(ops_path_graph_sync_proposal p-1 gs-7)" = "/projects/p-1/agent/graph-sync-proposals/gs-7" ] \
+  && echo "OK ops_path_graph_sync_proposal" || { echo "FAIL ops_path_graph_sync_proposal"; fail=1; }
+
 # [#62] Ledger: upsert por client_event_id, sin duplicar, conservando lo no mencionado.
 rm -f "$(ops_epic_ledger_path)"
 ops_epic_ledger_upsert '{"client_event_id":"cid-1","status":"QUEUED","draft":{"title":"Notificaciones"}}'
@@ -144,7 +151,7 @@ fi
 rm -f "$PROJ/.claude/state/outbox/"*.json
 
 # --- ops_mirror: sólo tiene sentido con project_id; nunca lanza sin él ---
-ops_mirror gate_reported "$TMP/payload.json"; rc=$?
+ops_mirror gate_verdict "$TMP/payload.json" EP-003; rc=$?
 [ "$rc" -ne 0 ] && echo "OK ops_mirror sin credenciales -> rc != 0" || { echo "FAIL ops_mirror sin credenciales"; fail=1; }
 
 # ══════════════ slice-ops.sh: mode / claim / next-step [Task 2] ══════════════
@@ -183,6 +190,56 @@ STUBS="$STUBS $!"
 sleep 0.3
 runtime_credentials_merge "{\"runtime_url\":\"http://127.0.0.1:$PORT_CL\",\"project_token\":\"tok-c\",\"project_id\":\"p-1\",\"agent_key\":\"ak-1\",\"manifest_hash\":\"sha256:v1\"}"
 
+# ── [EP-OR-17] Ledger y cid del re-sync del grafo ────────────────────────────────────
+# Va aquí, y no arriba con el ledger de épicas, porque `ops_graph_sync_cid` necesita la
+# `agent_key` de las credenciales que la línea anterior acaba de fijar.
+rm -f "$(ops_graph_sync_ledger_path)"
+ops_graph_sync_ledger_upsert '{"client_event_id":"ak-1:graph-sync:0","status":"QUEUED","epics":41}'
+ops_graph_sync_ledger_upsert '{"client_event_id":"ak-1:graph-sync:0","status":"PROPOSED","proposal_id":"gs-7"}'
+ops_graph_sync_ledger_read | python3 -c "
+import json,sys
+ps=json.load(sys.stdin)['proposals']
+e=ps[0]
+print('SI' if len(ps)==1 and e['status']=='PROPOSED' and e['proposal_id']=='gs-7' and e['epics']==41 else 'NO')" \
+  | grep -q SI && echo "OK el ledger de graph-sync hace upsert sin perder campos" \
+  || { echo "FAIL upsert del ledger de graph-sync"; fail=1; }
+case "$(ops_graph_sync_ledger_path)" in
+  */.claude/state/graph-sync-proposals.json) echo "OK el ledger de graph-sync vive en su propio fichero" ;;
+  *) echo "FAIL ruta del ledger de graph-sync"; fail=1 ;;
+esac
+
+# El cid es DETERMINISTA y avanza con el ledger: el reintento reusa el mismo, una propuesta
+# nueva toma el siguiente.
+rm -f "$(ops_graph_sync_ledger_path)"
+cid_a="$(ops_graph_sync_cid)"; cid_b="$(ops_graph_sync_cid)"
+[ "$cid_a" = "$cid_b" ] && echo "OK ops_graph_sync_cid es estable mientras no se registre nada" \
+  || { echo "FAIL cid inestable ($cid_a / $cid_b)"; fail=1; }
+[ "$cid_a" = "ak-1:graph-sync:1" ] && echo "OK el cid sigue el patrón <agent_key>:graph-sync:<n>" \
+  || { echo "FAIL patrón del cid ($cid_a)"; fail=1; }
+ops_graph_sync_ledger_upsert "{\"client_event_id\":\"$cid_a\",\"status\":\"PROPOSED\"}"
+[ "$(ops_graph_sync_cid)" = "ak-1:graph-sync:2" ] \
+  && echo "OK el cid avanza cuando el ledger registra una propuesta" \
+  || { echo "FAIL el cid no avanza ($(ops_graph_sync_cid))"; fail=1; }
+[ "${#cid_a}" -le 64 ] && echo "OK el cid cabe en los 64 caracteres del contrato" \
+  || { echo "FAIL cid demasiado largo (${#cid_a})"; fail=1; }
+# Una agent_key larga no puede desbordar el contrato: se sustituye por su sha256 truncado.
+ak_prev="$(runtime_field agent_key)"
+runtime_credentials_merge "{\"agent_key\":\"$(python3 -c 'print("a"*120)')\"}"
+cid_l="$(ops_graph_sync_cid)"
+[ "${#cid_l}" -le 64 ] && [ -n "$cid_l" ] \
+  && echo "OK una agent_key larga no desborda el cid (${#cid_l})" \
+  || { echo "FAIL cid desbordado con agent_key larga (${#cid_l})"; fail=1; }
+runtime_credentials_merge "{\"agent_key\":\"$ak_prev\"}"
+rm -f "$(ops_graph_sync_ledger_path)"
+
+# El ledger de épicas no se toca: misma conducta tras extraer la base común.
+rm -f "$(ops_epic_ledger_path)"
+ops_epic_ledger_upsert '{"client_event_id":"cid-9","status":"QUEUED"}'
+ops_epic_ledger_read | grep -q '"cid-9"' \
+  && echo "OK el ledger de épicas sobrevive a la extracción de la base común" \
+  || { echo "FAIL regresión del ledger de épicas"; fail=1; }
+rm -f "$(ops_epic_ledger_path)"
+
 # (#39) `claim --epic` NO existe en el protocolo del hub: `TasksNextIn` no declara
 # epic_code (pydantic lo ignoraba y la cola repartía OTRA épica con claim "exitoso").
 # Debe fallar EXPLÍCITO antes de tocar la red.
@@ -927,16 +984,18 @@ n="$(find "$PROJ/.claude/state/outbox" -name '*.json' 2>/dev/null | wc -l | tr -
 [ "$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
+# [EP-OR-17] El shape es MirrorTransitionsIn: la épica va en el SOBRE (`epic_code`), no como
+# `slice_ref` dentro del payload — los schemas del catálogo son extra="forbid".
 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")))
+        for t in json.loads(c["body"])["transitions"]:
+            if t["event_type"]=="phase_advanced":
+                tos.append((t["payload"].get("to"), t["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" \
+)" = SI ] && echo "OK phase en dual espeja phase_advanced {to} con el epic_code en el sobre" \
   || { 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).
@@ -950,12 +1009,14 @@ 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)]
+        for t in json.loads(c["body"])["transitions"]:
+            kinds.append((t["event_type"], t["payload"].get("to")))
+# [EP-OR-17] `slice_archived` NO está en TIPOS_DE_ESPEJO del hub: la cadena de fases sí se
+# espeja, y el archivado se corta en local (rc 8) en vez de viajar para volver rechazado.
+esperado=[("phase_advanced",t) for t in ["green","refactor","smoke","api","data","dod","pr"]]
 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" \
+)" = SI ] && echo "OK archive en dual espeja la cadena de fases y no el slice_archived no espejable" \
   || { 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).
@@ -982,12 +1043,16 @@ for line in open(sys.argv[1]):
     c=json.loads(line)
     if c["path"]=="/projects/p-1/mirror/transitions":
         b=json.loads(c["body"])
-        # [#44] el espejo también usa el nombre del catálogo (TIPOS_DE_ESPEJO del hub
-        # enumera gate_verdict, no verdict_reported).
-        ok = b["kind"]=="gate_verdict" and b["origin"]=="mirror" and b["payload"]["slice_ref"]["epic_code"]=="EP-009"
+        t=b["transitions"][0]
+        # [#44] el espejo usa el nombre del catálogo (gate_verdict, no verdict_reported).
+        # [EP-OR-17] La identidad local viaja en el SOBRE (`epic_code`); el `origin` ya no se
+        # manda — la marca de origen-espejo la estampa el SERVIDOR, y lo que dijera el cliente
+        # no elegiría el origen de todos modos.
+        ok = (list(b.keys())==["transitions"] and t["event_type"]=="gate_verdict"
+              and t["epic_code"]=="EP-009" and "slice_ref" not in t["payload"])
 print("SI" if ok else "NO")
 PYX
-)" = SI ] && echo "OK dual espeja con la identidad fichero-primaria" || { echo "FAIL espejo dual"; fail=1; }
+)" = SI ] && echo "OK dual espeja con la identidad fichero-primaria en el sobre" || { echo "FAIL espejo dual"; fail=1; }
 [ ! -s "$PROJ/.claude/state/outbox" ] || true
 grep -q '"path": "/slices/' "$TMP/calls-ga.jsonl" && { echo "FAIL dual llamó a la superficie primaria"; fail=1; } || echo "OK dual no llama a /slices (el fichero decide)"
 
@@ -999,12 +1064,15 @@ runtime_credentials_merge "{\"runtime_url\":\"http://127.0.0.1:$PORT_GA\"}"
 
 # ══════════════ hooks/build/dual-compare.sh [Task E] ══════════════
 # build-state.json de arriba sigue en pie: EP-009, phase tdd, gates {dor:true}.
-# En dual, escalate NO encola: espeja por POST /projects/{id}/mirror/transitions (el
-# fichero es primario) — igual que el resto de cmd_* en dual (ver el bloque de arriba).
+# En dual, escalate NO encola: intenta el espejo (el fichero es primario).
+# [EP-OR-17] `slice_escalated` existe en el catálogo del hub pero NO es espejable
+# (`TIPOS_DE_ESPEJO` solo cubre apertura, fases, gates, wiring, checkpoints, handoff y notas de
+# progreso). Antes la escalada viajaba para volver rechazada; ahora se corta en local. La
+# discrepancia sigue siendo VISIBLE donde el humano la lee —el stderr del hook Stop— y el hueco
+# de registro en el hub queda documentado como pendiente hub-side, no disimulado aquí.
 DC="$ROOT/hooks/build/dual-compare.sh"
 mirror_escalated() {
-  # SI/NO: ¿calls-ga.jsonl tiene un POST a mirror/transitions con kind=slice_escalated?
-  # [#44] la escalada usa el nombre del catálogo v2 (slice_escalated) también en el espejo.
+  # SI/NO: ¿viajó al espejo un `slice_escalated`? Debe ser NO: el hub no lo acepta.
   python3 - "$TMP/calls-ga.jsonl" <<'PYX'
 import json,sys
 found=False
@@ -1014,9 +1082,9 @@ for line in open(sys.argv[1]):
     except Exception:
         continue
     if c.get("path")=="/projects/p-1/mirror/transitions":
-        b=json.loads(c["body"])
-        if b.get("kind")=="slice_escalated":
-            found=True
+        for t in json.loads(c["body"]).get("transitions") or []:
+            if t.get("event_type")=="slice_escalated":
+                found=True
 print("SI" if found else "NO")
 PYX
 }
@@ -1053,9 +1121,10 @@ json.dump(d,open(p,"w"))
 PYX
 : > "$TMP/calls-ga.jsonl"
 rc=0; err="$(TRYCORE_RUNTIME_MODE=dual bash "$DC" 2>&1 1>/dev/null)" || rc=$?
-[ "$rc" = 0 ] && [ "$(mirror_escalated)" = SI ] && echo "$err" | grep -qi "discrepancia" \
+[ "$rc" = 0 ] && [ "$(mirror_escalated)" = NO ] && echo "$err" | grep -qi "discrepancia" \
   && echo "$err" | grep -q "EP-009" && echo "$err" | grep -q "EP-999" \
-  && echo "OK dual-compare con épica distinta escala con el detalle de ambos lados" || { echo "FAIL dual-compare épica distinta (rc=$rc err=$err)"; fail=1; }
+  && echo "OK dual-compare con épica distinta avisa con el detalle de ambos lados, sin mandar al espejo un tipo que el hub no acepta" \
+  || { echo "FAIL dual-compare épica distinta (rc=$rc err=$err)"; fail=1; }
 
 # dual, gate DISTINTO (mismo epic/fase): también cuenta como discrepancia.
 python3 - "$TMP/routes-ga.json" <<'PYX'
@@ -1065,8 +1134,10 @@ d["GET /agent/context"]={"status":200,"body":{"active_slice":{"slice_id":"sl-9",
 json.dump(d,open(p,"w"))
 PYX
 : > "$TMP/calls-ga.jsonl"
-rc=0; TRYCORE_RUNTIME_MODE=dual bash "$DC" >/dev/null 2>&1 || rc=$?
-[ "$(mirror_escalated)" = SI ] && echo "OK dual-compare detecta gate distinto (dor: true vs false)" || { echo "FAIL dual-compare gate distinto"; fail=1; }
+rc=0; err="$(TRYCORE_RUNTIME_MODE=dual bash "$DC" 2>&1 1>/dev/null)" || rc=$?
+echo "$err" | grep -qi "discrepancia" && [ "$(mirror_escalated)" = NO ] \
+  && echo "OK dual-compare detecta gate distinto (dor: true vs false)" \
+  || { echo "FAIL dual-compare gate distinto (rc=$rc err=$err)"; fail=1; }
 
 # dual, runtime SIN slice activo (el fichero sí tiene): también es discrepancia.
 python3 - "$TMP/routes-ga.json" <<'PYX'
@@ -1076,8 +1147,10 @@ d["GET /agent/context"]={"status":200,"body":{"project":{"scaffold_confirmed":Tr
 json.dump(d,open(p,"w"))
 PYX
 : > "$TMP/calls-ga.jsonl"
-rc=0; TRYCORE_RUNTIME_MODE=dual bash "$DC" >/dev/null 2>&1 || rc=$?
-[ "$(mirror_escalated)" = SI ] && echo "OK dual-compare detecta slice ausente en el runtime" || { echo "FAIL dual-compare slice ausente en runtime"; fail=1; }
+rc=0; err="$(TRYCORE_RUNTIME_MODE=dual bash "$DC" 2>&1 1>/dev/null)" || rc=$?
+echo "$err" | grep -qi "discrepancia" && [ "$(mirror_escalated)" = NO ] \
+  && echo "OK dual-compare detecta slice ausente en el runtime" \
+  || { echo "FAIL dual-compare slice ausente en runtime (rc=$rc err=$err)"; fail=1; }
 
 # fail-open: espejo caído (runtime inalcanzable) -> nunca lanza, nunca aborta (rc 0 siempre).
 python3 - "$TMP/routes-ga.json" <<'PYX'
@@ -1999,6 +2072,317 @@ out="$(cd "$PROJ" && bash "$SO" epic-writeback 2>&1)"; rc=$?
 [ $rc -eq 4 ] && echo "OK epic-writeback rc 4 sin fichero de epicas" \
   || { echo "FAIL epic-writeback sin fichero (rc $rc): $out"; fail=1; }
 
+# ══════════════ slice-ops.sh: graph-sync / graph-sync-status [EP-OR-17] ══════════════
+# Stub PROPIO (puerto, routes-gs.json y calls-gs.jsonl): mutar los de arriba rompería
+# aserciones aguas arriba, y este bloque reescribe la ruta del POST varias veces.
+PORT_GS="$(freeport)"
+cat > "$TMP/routes-gs.json" <<'JSON'
+{"POST /projects/p-1/agent/graph-sync-proposals": {"status": 201, "body": {"id": "gs-7", "project_id": "p-1", "status": "PROPOSED", "graph_version": 4, "bundle": {"epics": []}, "delta": {"epics_added": [{"code": "EP-002", "title": "Cobros", "layer": "BUSINESS", "stories": ["HU-011"]}], "epics_changed": [], "stories_added": [], "stories_changed": []}, "proposed_by": "ak-1", "proposed_at": "2026-09-07T10:00:00Z"}},
+ "GET /agent/context": {"status": 200, "body": {"project": {}, "active_slice": null, "nudges": [], "context": {"manifest_hash": "sha256:v1", "version": 4, "graph_version": 4}}},
+ "POST /events": {"status": 200, "body": {"accepted": [], "duplicates": [], "rejected": []}}}
+JSON
+: > "$TMP/calls-gs.jsonl"
+python3 "$ROOT/scripts/tests/lib/http-stub.py" "$PORT_GS" "$TMP/routes-gs.json" "$TMP/calls-gs.jsonl" &
+STUB_GS=$!
+STUBS="$STUBS $STUB_GS"
+sleep 0.3
+runtime_credentials_merge "{\"runtime_url\":\"http://127.0.0.1:$PORT_GS\",\"project_token\":\"tok-gs\",\"project_id\":\"p-1\",\"agent_key\":\"ak-1\"}"
+runtime_projection_write '{"fetched_at":"2099-01-01T00:00:00Z","active_slice":null,"nudges":[],"context":{"manifest_hash":"sha256:v1","version":4,"graph_version":4}}'
+
+cat > "$TMP/gs-epics.json" <<'JSON'
+{"epics":[{"code":"EP-001","title":"Cimiento","layer":"foundational","stories":[]},
+          {"code":"EP-002","title":"Cobros","layer":"business","depends_on":["EP-001"],
+           "stories":[{"id":"HU-011","title":"Registrar cobro"}]}]}
+JSON
+
+# legacy y dual: el grafo vive en los documentos y entra al hub por el import de admin.
+rc=0; out="$(TRYCORE_RUNTIME_MODE=legacy bash "$SO" graph-sync --file "$TMP/gs-epics.json" 2>&1)" || rc=$?
+[ "$rc" = 3 ] && echo "OK graph-sync en legacy -> rc 3" || { echo "FAIL graph-sync legacy rc ($rc): $out"; fail=1; }
+
+# --dry-run: imprime el bundle proyectado y NO abre socket. Sirve en cualquier modo.
+: > "$TMP/calls-gs.jsonl"
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-epics.json" --dry-run 2>/dev/null)" || rc=$?
+[ "$rc" = 0 ] && echo "OK graph-sync --dry-run -> rc 0" || { echo "FAIL dry-run rc ($rc)"; fail=1; }
+printf '%s' "$out" | python3 -c "
+import json,sys
+d=json.load(sys.stdin)
+print('SI' if list(d.keys())==['epics'] and len(d['epics'])==2 else 'NO')" | grep -q SI \
+  && echo "OK --dry-run enseña el bundle proyectado" || { echo "FAIL dry-run sin bundle ($out)"; fail=1; }
+grep -q 'graph-sync-proposals' "$TMP/calls-gs.jsonl" && { echo "FAIL --dry-run tocó la red"; fail=1; } \
+  || echo "OK --dry-run no abre socket"
+
+# Bundle que no cumple el contrato: se corta en LOCAL, sin abrir socket.
+echo '{"epics":[{"code":"EP-009","title":"Sin capa"}]}' > "$TMP/gs-malo.json"
+: > "$TMP/calls-gs.jsonl"
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-malo.json" 2>&1)" || rc=$?
+[ "$rc" = 2 ] && echo "OK bundle inválido -> rc 2 (uso)" || { echo "FAIL bundle inválido rc ($rc): $out"; fail=1; }
+grep -q 'graph-sync-proposals' "$TMP/calls-gs.jsonl" && { echo "FAIL bundle inválido tocó la red"; fail=1; } \
+  || echo "OK un bundle inválido no abre socket"
+
+# 201: PROPOSED en el ledger con el id del hub; el cuerpo cumple GraphSyncProposeIn.
+rm -f "$(ops_graph_sync_ledger_path)"
+rm -f "$PROJ/.claude/state/outbox/"*.json "$PROJ/.claude/state/outbox/rejected/"*.json 2>/dev/null
+: > "$TMP/calls-gs.jsonl"
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-epics.json" 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "OK graph-sync 201 -> rc 0" || { echo "FAIL graph-sync 201 rc ($rc): $out"; fail=1; }
+echo "$out" | grep -q "gs-7" && echo "OK graph-sync enseña el id de la propuesta" \
+  || { echo "FAIL id ausente ($out)"; fail=1; }
+echo "$out" | grep -qi "aprueb" && echo "OK graph-sync dice que falta la aprobación humana" \
+  || { echo "FAIL sin mención de la aprobación ($out)"; fail=1; }
+echo "$out" | grep -q "EP-002" && echo "OK graph-sync resume el delta que devuelve el hub" \
+  || { echo "FAIL delta sin resumir ($out)"; fail=1; }
+python3 - "$TMP/calls-gs.jsonl" <<'PYX' | grep -q SI \
+  && echo "OK el cuerpo enviado cumple GraphSyncProposeIn" || { echo "FAIL cuerpo de graph-sync"; fail=1; }
+import json,sys
+env=None
+for line in open(sys.argv[1]):
+    c=json.loads(line)
+    if c["path"].endswith("/agent/graph-sync-proposals") and c["method"]=="POST":
+        env=json.loads(c["body"])
+ok = (env is not None
+      and set(env.keys()) <= {"bundle","client_event_id","graph_version"}
+      and list(env["bundle"].keys())==["epics"]
+      and len(env["bundle"]["epics"])==2
+      and env["bundle"]["epics"][1]["layer"]=="BUSINESS"
+      and env["client_event_id"].endswith(":graph-sync:1")
+      and env["graph_version"]==4)
+print("SI" if ok else "NO %s" % json.dumps(env))
+PYX
+ops_graph_sync_ledger_read | python3 -c "
+import json,sys
+ps=json.load(sys.stdin)['proposals']
+print('SI' if len(ps)==1 and ps[0]['status']=='PROPOSED' and ps[0]['proposal_id']=='gs-7' else 'NO')" \
+  | grep -q SI && echo "OK el ledger registra la propuesta PROPOSED" \
+  || { echo "FAIL ledger tras 201"; fail=1; }
+
+# 200 empty_delta: el grafo ya está al día. No es un error y NO deja entrada viva en el ledger.
+python3 - "$TMP/routes-gs.json" <<'PYX'
+import json,sys
+d=json.load(open(sys.argv[1]))
+d["POST /projects/p-1/agent/graph-sync-proposals"]={"status":200,"body":{"empty_delta":True,"message":"El bundle coincide con el grafo vigente: no hay cambios que proponer"}}
+json.dump(d,open(sys.argv[1],"w"))
+PYX
+rm -f "$(ops_graph_sync_ledger_path)"
+rm -f "$PROJ/.claude/state/outbox/"*.json "$PROJ/.claude/state/outbox/rejected/"*.json 2>/dev/null
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-epics.json" 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "OK graph-sync empty_delta -> rc 0" || { echo "FAIL empty_delta rc ($rc): $out"; fail=1; }
+echo "$out" | grep -qi "al día" && echo "OK empty_delta se anuncia como grafo al día" \
+  || { echo "FAIL mensaje de empty_delta ($out)"; fail=1; }
+ops_graph_sync_ledger_read | python3 -c "
+import json,sys
+ps=json.load(sys.stdin)['proposals']
+print('SI' if all(p.get('status')!='PROPOSED' for p in ps) else 'NO')" | grep -q SI \
+  && echo "OK empty_delta no deja una propuesta viva en el ledger" \
+  || { echo "FAIL empty_delta dejó una propuesta viva"; fail=1; }
+
+# 422: bundle inválido para el hub -> rechazo, con el motivo del hub a la vista.
+python3 - "$TMP/routes-gs.json" <<'PYX'
+import json,sys
+d=json.load(open(sys.argv[1]))
+d["POST /projects/p-1/agent/graph-sync-proposals"]={"status":422,"body":{"detail":"la épica EP-002 depende de EP-999, que no existe"}}
+json.dump(d,open(sys.argv[1],"w"))
+PYX
+rm -f "$(ops_graph_sync_ledger_path)"
+rm -f "$PROJ/.claude/state/outbox/"*.json "$PROJ/.claude/state/outbox/rejected/"*.json 2>/dev/null
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-epics.json" 2>&1)" || rc=$?
+[ "$rc" = 6 ] && echo "OK graph-sync 422 -> rc 6" || { echo "FAIL 422 rc ($rc): $out"; fail=1; }
+echo "$out" | grep -q "EP-999" && echo "OK el 422 muestra el motivo del hub" \
+  || { echo "FAIL motivo del 422 ($out)"; fail=1; }
+
+# 409 graph_version_stale: se refresca el contexto y se reintenta UNA vez con el MISMO cid.
+python3 - "$TMP/routes-gs.json" <<'PYX'
+import json,sys
+d=json.load(open(sys.argv[1]))
+d["POST /projects/p-1/agent/graph-sync-proposals"]={"status":409,"body":{"detail":{"error":"graph_version_stale","message":"el grafo avanzo","graph_version":9}}}
+d["GET /agent/context"]["body"]["context"]["graph_version"]=9
+json.dump(d,open(sys.argv[1],"w"))
+PYX
+rm -f "$(ops_graph_sync_ledger_path)"
+rm -f "$PROJ/.claude/state/outbox/"*.json "$PROJ/.claude/state/outbox/rejected/"*.json 2>/dev/null
+runtime_graph_clear_stale
+runtime_projection_write '{"fetched_at":"2099-01-01T00:00:00Z","active_slice":null,"nudges":[],"context":{"manifest_hash":"sha256:v1","version":4,"graph_version":4}}'
+: > "$TMP/calls-gs.jsonl"
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-epics.json" 2>&1)" || rc=$?
+n="$(grep -c '"path": "/projects/p-1/agent/graph-sync-proposals"' "$TMP/calls-gs.jsonl" | tr -d ' ')"
+[ "$n" = 2 ] && echo "OK el 409 stale provoca UN reintento (2 envíos)" \
+  || { echo "FAIL reintentos del 409 ($n): $out"; fail=1; }
+python3 - "$TMP/calls-gs.jsonl" <<'PYX' | grep -q SI \
+  && echo "OK el reintento reusa el MISMO client_event_id y re-estampa la versión" \
+  || { echo "FAIL identidad del reintento"; fail=1; }
+import json,sys
+envs=[json.loads(json.loads(l)["body"]) for l in open(sys.argv[1])
+      if json.loads(l)["path"].endswith("/agent/graph-sync-proposals")]
+ok = (len(envs)==2 and envs[0]["client_event_id"]==envs[1]["client_event_id"]
+      and envs[1]["graph_version"]==9)
+print("SI" if ok else "NO %s" % json.dumps(envs))
+PYX
+echo "$out" | grep -qi "rancio\|grafo" && echo "OK el 409 stale se explica al usuario" \
+  || { echo "FAIL mensaje del 409 ($out)"; fail=1; }
+
+# 404 anti-oráculo: el mensaje no puede afirmar cuál de las dos causas fue.
+python3 - "$TMP/routes-gs.json" <<'PYX'
+import json,sys
+d=json.load(open(sys.argv[1]))
+d["POST /projects/p-1/agent/graph-sync-proposals"]={"status":404,"body":{"detail":"Proyecto no encontrado"}}
+json.dump(d,open(sys.argv[1],"w"))
+PYX
+rm -f "$(ops_graph_sync_ledger_path)"
+rm -f "$PROJ/.claude/state/outbox/"*.json "$PROJ/.claude/state/outbox/rejected/"*.json 2>/dev/null
+runtime_graph_clear_stale
+rc=0; out="$(bash "$SO" graph-sync --file "$TMP/gs-epics.json" 2>&1)" || rc=$?
+[ "$rc" = 6 ] && echo "OK graph-sync 404 -> rc 6" || { echo "FAIL 404 rc ($rc): $out"; fail=1; }
+echo "$out" | grep -qi "indistinguible\|no es el tuyo" \
+  && echo "OK el 404 se explica como anti-oráculo" || { echo "FAIL mensaje del 404 ($out)"; fail=1; }
+
+# --- graph-sync-status: el veredicto humano, legible por la terminal que propuso ---
+# El motivo del rechazo lo escribe el ADMIN precisamente para que lo lea quien propuso: sin
+# este subcomando el veredicto se queda en la consola y el agente vuelve a proponer lo mismo.
+rm -f "$(ops_graph_sync_ledger_path)"
+ops_graph_sync_ledger_upsert '{"client_event_id":"ak-1:graph-sync:1","status":"PROPOSED","proposal_id":"gs-7"}'
+ops_graph_sync_ledger_upsert '{"client_event_id":"ak-1:graph-sync:2","status":"PROPOSED","proposal_id":"gs-8"}'
+cat > "$TMP/routes-gs.json" <<'JSON'
+{"GET /projects/p-1/agent/graph-sync-proposals/gs-7": {"status": 200, "body": {"id": "gs-7", "status": "APPROVED", "graph_version": 4, "graph_version_applied": 5, "decided_by": "u-1", "reject_reason": null}},
+ "GET /projects/p-1/agent/graph-sync-proposals/gs-8": {"status": 200, "body": {"id": "gs-8", "status": "REJECTED", "graph_version": 4, "reject_reason": "EP-014 no está en el PRD aprobado", "decided_by": "u-1"}}}
+JSON
+rc=0; out="$(bash "$SO" graph-sync-status 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "OK graph-sync-status -> rc 0" || { echo "FAIL graph-sync-status rc ($rc): $out"; fail=1; }
+echo "$out" | grep -q "APPROVED" && echo "$out" | grep -q "v5" \
+  && echo "OK graph-sync-status muestra APPROVED con la versión aplicada" \
+  || { echo "FAIL render de APPROVED ($out)"; fail=1; }
+echo "$out" | grep -q "EP-014 no está en el PRD aprobado" \
+  && echo "OK graph-sync-status muestra el motivo del rechazo que escribió el ADMIN" \
+  || { echo "FAIL motivo del rechazo ($out)"; fail=1; }
+ops_graph_sync_ledger_read | python3 -c "
+import json,sys
+ps={p['proposal_id']:p for p in json.load(sys.stdin)['proposals']}
+print('SI' if ps['gs-7']['status']=='APPROVED' and ps['gs-8']['status']=='REJECTED' else 'NO')" \
+  | grep -q SI && echo "OK el ledger se actualiza con el veredicto" \
+  || { echo "FAIL ledger tras el veredicto"; fail=1; }
+
+out="$(bash "$SO" graph-sync-status --id gs-7 2>&1)"
+echo "$out" | grep -q "gs-7" && ! echo "$out" | grep -q "gs-8" \
+  && echo "OK --id filtra a una propuesta" || { echo "FAIL --id no filtra ($out)"; fail=1; }
+
+rm -f "$(ops_graph_sync_ledger_path)"
+rc=0; out="$(bash "$SO" graph-sync-status 2>&1)" || rc=$?
+[ "$rc" = 0 ] && echo "$out" | grep -qi "ninguna\|no hay" \
+  && echo "OK graph-sync-status sin propuestas -> rc 0 y lo dice" \
+  || { echo "FAIL sin propuestas (rc $rc): $out"; fail=1; }
+
+rc=0; out="$(TRYCORE_RUNTIME_MODE=legacy bash "$SO" graph-sync-status 2>&1)" || rc=$?
+[ "$rc" = 3 ] && echo "OK graph-sync-status en legacy -> rc 3" || { echo "FAIL status legacy rc ($rc)"; fail=1; }
+
+# Un 404 al consultar es el MISMO anti-oráculo: propuesta ajena o inexistente, sin distinguir.
+ops_graph_sync_ledger_upsert '{"client_event_id":"ak-1:graph-sync:9","status":"PROPOSED","proposal_id":"gs-99"}'
+out="$(bash "$SO" graph-sync-status --id gs-99 2>&1)"
+echo "$out" | grep -qi "indistinguible\|no es de este proyecto\|desconocida" \
+  && echo "OK una propuesta que el hub no reconoce se explica sin oráculo" \
+  || { echo "FAIL 404 del status ($out)"; fail=1; }
+rm -f "$(ops_graph_sync_ledger_path)"
+
+# ══════════════ espejo dual: el cuerpo que el hub acepta de verdad [EP-OR-17] ══════════════
+[ "$OPS_RC_NOT_MIRRORABLE" = 8 ] && echo "OK OPS_RC_NOT_MIRRORABLE=8" || { echo "FAIL rc del espejo"; fail=1; }
+
+# Réplica local de TIPOS_DE_ESPEJO del hub (event_catalog.py: los schemas que heredan de
+# _TransicionDeEspejo). Test ANTI-DRIFT: si el hub amplía la enumeración, esta lista tiene que
+# ampliarse a la vez — dos listas del mismo hecho divergen, y la que calla es la que miente.
+esperados="checkpoint_recorded gate_verdict handoff_recorded phase_advanced phase_reverted progress_noted slice_opened wiring_checklist_seeded wiring_item_updated"
+got="$(echo $OPS_MIRROR_TYPES | tr ' ' '\n' | sort | tr '\n' ' ' | sed 's/ $//')"
+[ "$got" = "$esperados" ] && echo "OK OPS_MIRROR_TYPES replica la enumeración normativa del hub" \
+  || { echo "FAIL OPS_MIRROR_TYPES ($got)"; fail=1; }
+
+echo '{"gate":"security","status":"pass"}' > "$TMP/mir-payload.json"
+cat > "$TMP/routes-gs.json" <<'JSON'
+{"POST /projects/p-1/mirror/transitions": {"status": 200, "body": {"results": [{"client_event_id": "c1", "epic_code": "EP-003", "event_type": "gate_verdict", "status": "applied", "reason": null}], "applied": 1, "duplicates": 0, "rejected": 0}}}
+JSON
+
+# Un tipo fuera de la enumeración NO gasta red: hoy viajaba y volvía rechazado por elemento, y
+# el aviso genérico mandaba al usuario a revisar una conexión que funcionaba.
+: > "$TMP/calls-gs.jsonl"
+rc=0; err="$(ops_mirror release_verdict_reported "$TMP/mir-payload.json" EP-003 2>&1)" || rc=$?
+[ "$rc" = 8 ] && echo "OK un tipo no espejable -> rc 8" || { echo "FAIL tipo no espejable rc ($rc)"; fail=1; }
+grep -q 'mirror/transitions' "$TMP/calls-gs.jsonl" && { echo "FAIL un tipo no espejable tocó la red"; fail=1; } \
+  || echo "OK un tipo no espejable no abre socket"
+echo "$err" | grep -qi "catálogo\|enumeración" \
+  && echo "OK el aviso dice POR QUÉ no se espeja" || { echo "FAIL aviso del tipo no espejable ($err)"; fail=1; }
+
+# Sin epic_code no se envía: el hub lo exige y el lote sería un 422 garantizado.
+: > "$TMP/calls-gs.jsonl"
+rm -f "$PROJ/.claude/state/build-state.json"
+rc=0; ops_mirror gate_verdict "$TMP/mir-payload.json" "" >/dev/null 2>&1 || rc=$?
+[ "$rc" = 5 ] && echo "OK sin epic_code -> rc 5, sin red" || { echo "FAIL sin epic_code rc ($rc)"; fail=1; }
+grep -q 'mirror/transitions' "$TMP/calls-gs.jsonl" && { echo "FAIL sin epic_code tocó la red"; fail=1; } \
+  || echo "OK sin epic_code no abre socket"
+
+# El epic_code cae al estado local cuando no se pasa: en dual el fichero es primario.
+echo '{"active_slice":{"epica":"EP-077","phase":"green"}}' > "$PROJ/.claude/state/build-state.json"
+: > "$TMP/calls-gs.jsonl"
+ops_mirror gate_verdict "$TMP/mir-payload.json" >/dev/null 2>&1
+python3 - "$TMP/calls-gs.jsonl" <<'PYX' | grep -q SI \
+  && echo "OK el epic_code cae a active_slice.epica del estado local" \
+  || { echo "FAIL fallback del epic_code"; fail=1; }
+import json,sys
+env=None
+for line in open(sys.argv[1]):
+    c=json.loads(line)
+    if c["path"].endswith("/mirror/transitions"):
+        env=json.loads(c["body"])
+print("SI" if env and env["transitions"][0]["epic_code"]=="EP-077" else "NO %s" % json.dumps(env))
+PYX
+
+# El cuerpo es {"transitions":[{client_event_id, epic_code, event_type, payload}]} — y el
+# payload NO lleva claves de más (los schemas del catálogo son extra="forbid").
+: > "$TMP/calls-gs.jsonl"
+rc=0; ops_mirror gate_verdict "$TMP/mir-payload.json" EP-003 >/dev/null 2>&1 || rc=$?
+[ "$rc" = 0 ] && echo "OK espejo aplicado -> rc 0" || { echo "FAIL espejo aplicado rc ($rc)"; fail=1; }
+python3 - "$TMP/calls-gs.jsonl" <<'PYX' | grep -q SI \
+  && echo "OK el espejo manda el shape MirrorTransitionsIn" || { echo "FAIL shape del espejo"; fail=1; }
+import json,sys
+env=None
+for line in open(sys.argv[1]):
+    c=json.loads(line)
+    if c["path"].endswith("/mirror/transitions"):
+        env=json.loads(c["body"])
+t=(env or {}).get("transitions") or [{}]
+ok = (list((env or {}).keys())==["transitions"] and len(t)==1
+      and set(t[0].keys())=={"client_event_id","epic_code","event_type","payload"}
+      and t[0]["epic_code"]=="EP-003" and t[0]["event_type"]=="gate_verdict"
+      and 1 <= len(t[0]["client_event_id"]) <= 64
+      and set(t[0]["payload"].keys())=={"gate","status"})
+print("SI" if ok else "NO %s" % json.dumps(env))
+PYX
+
+# Un duplicado no es un fallo: el hub deduplica por client_event_id y el trabajo local siguió.
+python3 - "$TMP/routes-gs.json" <<'PYX'
+import json,sys
+d=json.load(open(sys.argv[1]))
+r=d["POST /projects/p-1/mirror/transitions"]["body"]
+r["results"][0]["status"]="duplicate"; r["applied"]=0; r["duplicates"]=1
+json.dump(d,open(sys.argv[1],"w"))
+PYX
+rc=0; ops_mirror gate_verdict "$TMP/mir-payload.json" EP-003 >/dev/null 2>&1 || rc=$?
+[ "$rc" = 0 ] && echo "OK espejo duplicado -> rc 0" || { echo "FAIL espejo duplicado rc ($rc)"; fail=1; }
+
+# Un rechazo POR ELEMENTO se lee y se muestra: es el motivo, no el cuerpo crudo.
+python3 - "$TMP/routes-gs.json" <<'PYX'
+import json,sys
+d=json.load(open(sys.argv[1]))
+r=d["POST /projects/p-1/mirror/transitions"]["body"]
+r["results"][0]["status"]="rejected"
+r["results"][0]["reason"]="la épica 'EP-003' no existe en el grafo del proyecto"
+r["applied"]=0; r["duplicates"]=0; r["rejected"]=1
+json.dump(d,open(sys.argv[1],"w"))
+PYX
+rc=0; err="$(ops_mirror gate_verdict "$TMP/mir-payload.json" EP-003 2>&1)" || rc=$?
+[ "$rc" = 6 ] && echo "OK espejo rechazado -> rc 6" || { echo "FAIL espejo rechazado rc ($rc)"; fail=1; }
+echo "$err" | grep -q "no existe en el grafo" \
+  && echo "OK el rechazo del espejo muestra el motivo POR ELEMENTO" \
+  || { echo "FAIL motivo del rechazo del espejo ($err)"; fail=1; }
+echo "$err" | grep -q "graph-sync" \
+  && echo "OK el rechazo por épica ausente apunta a graph-sync" \
+  || { echo "FAIL el rechazo no sugiere graph-sync ($err)"; fail=1; }
+rm -f "$PROJ/.claude/state/build-state.json"
+
 # ══════════════ scripts/lib/graph-bundle.py [Task 13 · issue #41] ══════════════
 GB="$ROOT/scripts/lib/graph-bundle.py"
 cat > "$TMP/epics.json" <<'JSON'
@@ -2153,6 +2537,66 @@ grep -q "EP-020 tiene sección" "$TMP/gb10.err" && grep -q "EP-021 no aparece co
 
 # 4-ter) Las dos banderas juntas son un error explícito (ignorar una en silencio es el
 #        patrón que causó #56).
+# ══════════ graph-bundle.py --for-sync [EP-OR-17] ══════════
+# La proyección de contrato del carril `graph-sync`. `GraphSyncBundle` es extra="forbid" y
+# admite SOLO `epics`: cualquier clave de preparación (bundle_version, kind, project_ref,
+# warnings…) es un 422. Y lo que en el bundle de preparación es AVISO aquí es RECHAZO: sin un
+# ADMIN revisando antes de subirlo, un aviso ignorado es el 422 del hub con pasos extra.
+cat > "$TMP/sync-in.json" <<'JSON'
+{"project_ref": "demo",
+ "epics": [{"code": "EP-002", "title": "Cobros", "layer": "business",
+            "files_scope": ["src/cobros/**"], "depends_on": ["EP-001"],
+            "stories": [{"id": "HU-011", "title": "Registrar cobro"}]},
+           {"code": "EP-001", "title": "Cimiento", "layer": "foundational",
+            "stories": []}],
+ "release_lines": [{"id": "R1", "epics": ["EP-001", "EP-002"]}]}
+JSON
+rc=0; out="$(python3 "$GB" --for-sync < "$TMP/sync-in.json" 2>"$TMP/sync-err.txt")" || rc=$?
+[ "$rc" = 0 ] && echo "OK --for-sync con bundle válido -> rc 0" \
+  || { echo "FAIL --for-sync rc ($rc): $(cat "$TMP/sync-err.txt")"; fail=1; }
+printf '%s' "$out" | python3 -c "
+import json,sys
+d=json.load(sys.stdin)
+e=d['epics']
+ok = (list(d.keys())==['epics'] and len(e)==2 and e[0]['code']=='EP-001'
+      and e[1]['layer']=='BUSINESS' and e[1]['stories'][0]['code']=='HU-011'
+      and e[1]['release_line']=='R1'
+      and not any(k in e[0] for k in ('warnings','bundle_version','kind','project_ref')))
+print('SI' if ok else 'NO')" | grep -q SI \
+  && echo "OK --for-sync emite solo {epics:[…]} con el shape del contrato" \
+  || { echo "FAIL shape de --for-sync ($out)"; fail=1; }
+
+echo '{"epics":[{"code":"EP-009","title":"Sin capa"}]}' > "$TMP/sync-nolayer.json"
+rc=0; python3 "$GB" --for-sync < "$TMP/sync-nolayer.json" >/dev/null 2>"$TMP/sync-err.txt" || rc=$?
+[ "$rc" = 2 ] && echo "OK --for-sync sin layer -> rc 2" || { echo "FAIL layer ausente rc ($rc)"; fail=1; }
+grep -q "EP-009" "$TMP/sync-err.txt" && grep -qi "layer" "$TMP/sync-err.txt" \
+  && echo "OK el rechazo nombra la épica y el campo" \
+  || { echo "FAIL mensaje de layer ausente ($(cat "$TMP/sync-err.txt"))"; fail=1; }
+
+python3 -c "
+import json
+hs=[{'id':'HU-%03d'%i,'title':'h%d'%i} for i in range(101)]
+print(json.dumps({'epics':[{'code':'EP-010','title':'Muchas','layer':'BUSINESS','stories':hs}]}))" > "$TMP/sync-techo.json"
+rc=0; python3 "$GB" --for-sync < "$TMP/sync-techo.json" >/dev/null 2>"$TMP/sync-err.txt" || rc=$?
+[ "$rc" = 2 ] && echo "OK --for-sync con 101 historias -> rc 2" || { echo "FAIL techo de historias rc ($rc)"; fail=1; }
+grep -q "100" "$TMP/sync-err.txt" && echo "OK el rechazo por techo dice cuál es el techo" \
+  || { echo "FAIL mensaje de techo ($(cat "$TMP/sync-err.txt"))"; fail=1; }
+
+echo '{"epics":[]}' > "$TMP/sync-vacio.json"
+rc=0; python3 "$GB" --for-sync < "$TMP/sync-vacio.json" >/dev/null 2>"$TMP/sync-err.txt" || rc=$?
+[ "$rc" = 2 ] && echo "OK --for-sync sin épicas -> rc 2" || { echo "FAIL bundle vacío rc ($rc)"; fail=1; }
+
+# El modo de preparación NO cambia: sigue tolerando lo que el ADMIN va a revisar.
+rc=0; out="$(python3 "$GB" < "$TMP/sync-nolayer.json" 2>/dev/null)" || rc=$?
+[ "$rc" = 0 ] && printf '%s' "$out" | grep -q '"bundle_version"' \
+  && echo "OK el modo de preparación sigue tolerando layer ausente (rc 0 + avisos)" \
+  || { echo "FAIL regresión en el modo de preparación (rc $rc)"; fail=1; }
+
+# --for-sync se combina con --from-docs: las dependencias en prosa también viajan al hub.
+rc=0; out="$(python3 "$GB" --for-sync --from-docs "$TMP/docs/epicas.md" < "$TMP/sync-in.json" 2>/dev/null)" || rc=$?
+[ "$rc" = 0 ] && echo "OK --for-sync se combina con --from-docs" \
+  || { echo "FAIL --for-sync con --from-docs (rc $rc)"; fail=1; }
+
 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; }
@@ -2171,7 +2615,7 @@ PORT_GV="$(freeport)"
 cat > "$TMP/routes-gv.json" <<JSON
 {"GET /agent/context": {"status": 200, "body": {"project": {}, "active_slice": {}, "nudges": [],
   "context": {"manifest_hash": "sha256:v2", "version": 9, "graph_version": 45}}},
- "POST /tasks/next": {"status": 409, "body": {"reason": "stale_graph", "graph_version": 45}}}
+ "POST /tasks/next": {"status": 409, "body": {"detail": {"error": "graph_version_stale", "message": "el grafo avanzo", "graph_version": 45}}}}
 JSON
 : > "$TMP/calls-gv.jsonl"
 python3 "$ROOT/scripts/tests/lib/http-stub.py" "$PORT_GV" "$TMP/routes-gv.json" "$TMP/calls-gv.jsonl" &
@@ -2231,6 +2675,51 @@ PY
 [ "$has" = NO ] && [ $rc -eq 7 ] && echo "OK sin hub que versione, el claim no manda nada nuevo" \
   || { echo "FAIL compatibilidad hacia atras del claim (has=$has rc=$rc)"; fail=1; }
 
+# --- [EP-OR-17] Los OTROS motivos del 409, como los emite el hub de verdad ---
+# El `case` esperaba `reason: drift|contention|…` en la raíz y el hub anida todo bajo `detail`:
+# los cuatro casos caían en el `*)` y salían como rechazo duro. Un drift es REINTENTABLE tras
+# sincronizar el contexto, y reportarlo como rechazo dejaba al agente sin claim y sin salida.
+python3 - "$TMP/routes-gv.json" <<'PY'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["POST /tasks/next"]={"status":409,"body":{"detail":{"message":"tu contexto local no coincide","manifest_hash":"sha256:v9"}}}
+json.dump(d,open(p,"w"))
+PY
+: > "$TMP/calls-gv.jsonl"
+out="$(bash "$SO" claim 2>&1)"; rc=$?
+n="$(grep -c '"path": "/tasks/next"' "$TMP/calls-gv.jsonl" | tr -d ' ')"
+[ "$n" = 2 ] && echo "OK un 409 de drift (detail.manifest_hash) se reintenta una vez" \
+  || { echo "FAIL reintentos del 409 de drift ($n)"; fail=1; }
+[ $rc -eq 7 ] && echo "OK un drift persistente acaba en NO_WORK, no en rechazo duro" \
+  || { echo "FAIL rc del 409 de drift ($rc): $out"; fail=1; }
+
+python3 - "$TMP/routes-gv.json" <<'PY'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["POST /tasks/next"]={"status":409,"body":{"detail":"contención con otra escritura del contexto: reintenta el claim"}}
+json.dump(d,open(p,"w"))
+PY
+: > "$TMP/calls-gv.jsonl"
+out="$(bash "$SO" claim 2>&1)"; rc=$?
+n="$(grep -c '"path": "/tasks/next"' "$TMP/calls-gv.jsonl" | tr -d ' ')"
+[ "$n" = 2 ] && [ $rc -eq 7 ] && echo "OK un 409 de contención se reintenta una vez" \
+  || { echo "FAIL 409 de contención (n=$n rc=$rc): $out"; fail=1; }
+
+python3 - "$TMP/routes-gv.json" <<'PY'
+import json,sys
+p=sys.argv[1]; d=json.load(open(p))
+d["POST /tasks/next"]={"status":409,"body":{"detail":"el contexto vigente del proyecto no resuelve (manifiesto ausente): no hay trabajo sin contexto declarado"}}
+json.dump(d,open(p,"w"))
+PY
+: > "$TMP/calls-gv.jsonl"
+out="$(bash "$SO" claim 2>&1)"; rc=$?
+n="$(grep -c '"path": "/tasks/next"' "$TMP/calls-gv.jsonl" | tr -d ' ')"
+[ "$n" = 1 ] && [ $rc -eq 6 ] && echo "OK un contexto irresoluble NO se reintenta (rc 6)" \
+  || { echo "FAIL 409 de contexto irresoluble (n=$n rc=$rc): $out"; fail=1; }
+echo "$out" | grep -q "no hay trabajo sin contexto declarado" \
+  && echo "OK el 409 enseña el motivo del hub en prosa, no el JSON crudo" \
+  || { echo "FAIL prosa del 409 ($out)"; fail=1; }
+
 kill "$STUB_GV" 2>/dev/null; wait "$STUB_GV" 2>/dev/null
 
 exit $fail