@trycore/spec-build-harness 0.11.0 → 0.12.0

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "trycore-spec-build-harness",
   "displayName": "Trycore — Spec & Build Harness",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Arnés de construcción de dos loops (slice por épica + release gate) para Claude Code, con gates de calidad, estado compartido y OpenSpec. Compañero de @trycore/spec-product-flow. Agnóstico al proyecto.",
   "author": {
     "name": "Trycore",

package/VERSION

@@ -1 +1 @@
-0.11.0
+0.12.0

package/commands/build/release.md

@@ -70,8 +70,9 @@ reviewer. Es el gate **no negociable**: sin él, no hay release.
 - Reporta **cada** gate medido con
   `bash .claude/hooks/build/release-ops.sh verdict <line> <gate> <pass|fail|na> --evidence-file f`
   (`na` cuando no aplica). El **agregado** lo hace el runtime: **parciales no promueven a `passed`**.
-- Con los seis reportados y en verde, recuérdale al humano que **el cierre es suyo**
-  (`release-ops.sh close-hint <line>`): el agente no cierra releases.
+- Con los seis reportados **en verde, el hub auto-cierra** (`closed_by: AUTO_6_OF_6_PASS`; lo
+  anuncia la respuesta del último `verdict`). Si la release queda degradada, el cierre es
+  decisión humana en la consola (`release-ops.sh close-hint <line>` imprime la política).
 - Algo ✗ → los hallazgos bloqueantes se corrigen **como un slice normal**
   (`/build:slice` / `building-a-slice`) y se **re-corre** el Release Gate.
 
@@ -83,5 +84,5 @@ reviewer. Es el gate **no negociable**: sin él, no hay release.
   vez por release (`O(releases)`).
 - **No dupliques el inner loop**: no se hace TDD ni se cierran gates por slice.
 - **`integration` con deps reales es obligatorio**; no se acepta con todo stubbeado.
-- **El agente reporta, el humano cierra** (spec §2): ninguna llamada de cierre con token de agente.
+- **El agente reporta; el verde se auto-cierra; el degradado lo decide un humano** (política A-con-B): ninguna llamada de cierre con token de agente — el auto-cierre lo ejecuta el runtime al agregar, no el cliente.
 - Delega en `releasing-a-version`; **no** la reimplementa. Si algo contradice `METODOLOGIA.md`, gana la metodología.

package/dist/commands/doctor.js

@@ -8,7 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { targetPaths } from '../lib/paths.js';
-import { runtimeMode, readCredentials, getAgentContext, readLock, outboxStats } from '../lib/runtime-client.js';
+import { runtimeMode, readCredentials, getAgentContext, readLock, outboxStats, rejectedStats } from '../lib/runtime-client.js';
 export function hasBinary(bin) {
     if (process.platform === 'win32') {
         return spawnSync('where', [bin], { stdio: 'ignore' }).status === 0;
@@ -128,6 +128,17 @@ export async function doctor(opts) {
         else {
             console.log('  Cola:       vacía');
         }
+        // [issue #52] rejected/ era invisible: cola vacía ≠ todo entregado — el hub pudo
+        // descartar eventos (p. ej. un slice_archived sin la cadena de fases).
+        const rej = rejectedStats(targetDir);
+        if (rej.count > 0) {
+            console.log(`  Rechazados: ⚠ ${rej.count} evento(s) en outbox/rejected/ — el hub los descartó, NO se reenvían`);
+            console.log(`              último: ${rej.latestType ?? '?'} — ${rej.latestReason ?? 'razón no registrada'}`);
+            console.log('              revisa la causa y re-emite el hecho corregido');
+        }
+        else {
+            console.log('  Rechazados: ninguno');
+        }
     }
     // Detección de doble canal (CLI settings.json + plugin) [H3]
     const settingsHasHooks = fs.existsSync(t.settingsFile) &&

package/dist/commands/status.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { readPackageVersion, targetPaths, PACKAGE_ROOT } from '../lib/paths.js';
 import { countChildren } from '../lib/install-engine.js';
 import { hasBinary } from './doctor.js';
-import { runtimeMode, getAgentContext, readProjection, readLock } from '../lib/runtime-client.js';
+import { runtimeMode, getAgentContext, readProjection, readLock, rejectedStats } from '../lib/runtime-client.js';
 export async function status(opts) {
     const targetDir = path.resolve(opts.targetDir);
     const t = targetPaths(targetDir);
@@ -61,6 +61,14 @@ export async function status(opts) {
         }
         const lock = readLock(targetDir);
         console.log(`  Contexto:     ${lock.manifestHash ? `✓ sincronizado (${lock.fileCount} archivo(s))` : '⚠ sin sincronizar'}`);
+        // [issue #52] Eventos que el hub descartó (outbox/rejected/): sin esta línea, una cola
+        // en 0 parecía éxito mientras un slice_archived rechazado dejaba la épica «en
+        // construcción» para siempre en el hub.
+        const rej = rejectedStats(targetDir);
+        if (rej.count > 0) {
+            console.log(`  Rechazados:   ⚠ ${rej.count} evento(s) en outbox/rejected/ — el hub los descartó, NO se reenvían`);
+            console.log(`                último: ${rej.latestType ?? '?'} — ${rej.latestReason ?? 'razón no registrada'}`);
+        }
         if (mode === 'runtime') {
             console.log('══════════════════════════════════════════════════════');
             return;

package/dist/lib/runtime-client.js

@@ -184,6 +184,40 @@ export function outboxStats(targetDir) {
         return { count: 0, totalBytes: 0, oldestAgeSeconds: null };
     }
 }
+/**
+ * Eventos apartados a `outbox/rejected/` — el hub (o el pre-filtro local) los descartó y
+ * NO se reenvían (issue #52): una cola con 0 pendientes puede seguir escondiendo hechos
+ * perdidos (p. ej. un `slice_archived` sin la cadena de fases). El despacho persiste la
+ * razón en el propio fichero (`rejected_reason`); el más reciente es el último por nombre
+ * (los nombres llevan el timestamp de encolado). Fail-open: sin directorio o con ficheros
+ * ilegibles se degrada a conteo sin razón, jamás lanza.
+ */
+export function rejectedStats(targetDir) {
+    const dir = path.join(runtimePaths(targetDir).outboxDir, 'rejected');
+    try {
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith('.json') && !f.startsWith('.')).sort();
+        if (files.length === 0)
+            return { count: 0, latestType: null, latestReason: null };
+        let latestType = null;
+        let latestReason = null;
+        try {
+            const d = JSON.parse(fs.readFileSync(path.join(dir, files[files.length - 1]), 'utf8'));
+            if (typeof d.type === 'string')
+                latestType = d.type;
+            else if (typeof d.event_type === 'string')
+                latestType = d.event_type;
+            if (typeof d.rejected_reason === 'string')
+                latestReason = d.rejected_reason;
+        }
+        catch {
+            // Fichero ilegible: el conteo sigue valiendo; la razón queda en null.
+        }
+        return { count: files.length, latestType, latestReason };
+    }
+    catch {
+        return { count: 0, latestType: null, latestReason: null };
+    }
+}
 /** ¿El host resuelve una URL http(s) mínimamente bien formada? Validación local, sin red. */
 export function isPlausibleUrl(url) {
     try {

package/docs/runtime/protocolo-cliente-runtime.md

@@ -97,6 +97,7 @@ Offline: sin runtime se trabaja con el último lock; la statusline marca `⚠ st
 - Un archivo JSON por evento (no por lote — `runtime_enqueue_event`), con `client_event_id` (UUID) ⇒ **idempotencia server-side** (reintentos seguros). El despacho (`runtime_dispatch_outbox`) sí agrupa en un único `POST /events` por invocación, con el sobre que el hub exige: `{"events": [{client_event_id, event_type, payload, slice_id?}]}` — la clave interna `type` de los ficheros de la outbox se traduce a `event_type` **al armar el cuerpo** (el formato en disco no cambia; ficheros encolados por 0.10.x drenan sin migración). El ack real del hub es `{accepted[], duplicates[], rejected[{client_event_id, reason}]}` (issue #37).
 - **Capa de compat de nombres/payloads en el mismo punto de salida** (issue #44): los productores encolan los nombres del **catálogo v2** del hub (`gate_verdict`, `checkpoint_recorded`, `slice_escalated`, `progress_noted`), pero los ficheros 0.10.x con los nombres viejos (`verdict_reported`, `checkpoint_created`, `escalation_raised`, `progress_note_recorded`) drenan traducidos — tipo **y** claves de payload (`status`→`verdict` en mayúscula, `note`→`summary`, `reason/gate/phase`→`cause`) — sin migración. Los tipos **sin equivalente** en el catálogo (`tool_use_recorded`, `branch_drift`, `front_integration_reported`) se apartan localmente a `outbox/rejected/` sin gastar red.
 - **Un 4xx no es red caída**: un 4xx del lote (salvo 408/429) o un elemento en `rejected[]` del ack **no se reintenta** — el fichero se mueve a `outbox/rejected/` con la razón loggeada y se avisa. Solo 408/429/5xx/corte de red conservan la cola con backoff (fail-open intacto).
+- **`rejected/` es visible, con su razón persistida** (issue #52): al apartar un evento (elemento rechazado en el ack, pre-filtro local de tipos sin equivalente o lote 4xx) el despacho escribe la razón DENTRO del fichero apartado (`rejected_reason`). La superficie la muestran `slice-ops.sh status` y `trycore-build status`/`doctor` (conteo + tipo y razón del más reciente): antes el rechazo solo salía por el stderr de un daemon que nadie lee — la cola marcaba 0 pendientes y parecía éxito mientras el hub había descartado un `slice_archived` (el piloto lo sufrió: épicas «en construcción» con el PR mergeado). Un rechazo NO se reintenta solo: se corrige la causa y se re-emite el hecho.
 - Despacho en background con backoff persistido (`1 s → 5 s → 30 s → 5 min`, tope; el estado vive en `outbox/.dispatch-state.json` y sobrevive entre invocaciones de hooks distintos). Orden FIFO global — el agrupado por-agregado nace con el catálogo de eventos (sub-slice C).
 - Cota: 5 MB / 72 h — al superarla se descartan primero los eventos evictables (todo tipo fuera de la lista protegida), **nunca** `checkpoint_recorded`, `gate_verdict`, `slice_escalated`, `slice_submitted`, `slice_archived`, `wiring_*`, `project_fact_updated`, `handoff_recorded` ni el propio `telemetry_gap` (nombres del catálogo v2; los alias 0.10.x de los cuatro renombrados siguen protegidos porque la capa de compat los entrega). El descarte se reporta como evento `telemetry_gap` con el payload del catálogo `{dropped, window_h, reason}` (issue #44), coalescido en un único gap mientras la cola siga sobre la cota.
 - Flush forzado en `Stop`: `session-stop.sh` deja el sentinela `outbox/.flush-request`; el daemon `heartbeat.sh` lo consume de forma asíncrona (nunca en el hilo del hook). `trycore-build doctor` **reporta** el tamaño/edad de la cola pero **no** dispara un flush síncrono — sigue sin implementar.
@@ -173,15 +174,16 @@ modo, valida en local lo que es barato validar y encola lo que no pudo entregar.
 | `slice-ops.sh mode` | ninguna (lee `build-config.json`) |
 | `slice-ops.sh claim` | `POST /tasks/next` (§3); `--epic` falla explícito, rc 2 (no hay claim dirigido, §3.6) |
 | `slice-ops.sh next-step` | ninguna: lo **deriva el cliente** desde la caché de proyección |
+| `slice-ops.sh phase <to>` | evento(s) `phase_advanced {to}` en cadena (issue #52): el hub lleva la fase con orden ESTRICTO (`dor→change→red→green→refactor→smoke→api→data→dod→pr`, `domain.py` `PHASES`) y solo acepta la fase siguiente exacta. El cliente emite la cadena que falte desde la fase conocida (proyección ∪ `phase_advanced` pendientes en la cola) hasta `<to>`; idempotente (nada si ya está). `archived` no se reporta aquí (lo produce `archive`). Siempre por cola en `runtime` (tipo protegido de la cota: evictar un eslabón haría ilegal todo lo posterior); espejo en `dual` (`phase_advanced` ∈ `TIPOS_DE_ESPEJO`) |
 | `slice-ops.sh gate <g> <pass\|fail\|na>` | `POST /slices/{id}/verdicts` (`{gate, verdict: PASS\|FAIL, evidence}`); offline → evento `gate_verdict`. `na` **no viaja**: el catálogo no lo admite (aviso local, rc 0, issue #44) |
 | `slice-ops.sh wiring seed\|update` | eventos `wiring_checklist_seeded` (items `{item_id, kind, ref}`, sin `status`) / `wiring_item_updated` |
 | `slice-ops.sh progress` | evento `progress_noted` (evictable) |
 | `slice-ops.sh checkpoint` | `POST /checkpoints` (`summary`, no `note`); offline → evento `checkpoint_recorded {branch, commit_sha, summary}` |
 | `slice-ops.sh submit` | `POST /slices/{id}/submit`; offline → evento `slice_submitted` con payload `{}` (el catálogo no admite campos) |
-| `slice-ops.sh archive` | evento `slice_archived` con payload `{}` y `slice_id` (siempre por cola, idempotente) |
+| `slice-ops.sh archive` | evento `slice_archived` con payload `{}` y `slice_id` (siempre por cola, idempotente). **Catch-up de fase** (issue #52): `slice_archived` exige `phase == pr` en el hub — si la fase conocida quedó atrás (pipeline corrido sin `phase`), se emite antes la cadena `phase_advanced` que falte hasta `pr`, con aviso `⚠ … server-side`. Es el workaround del piloto (2026-08-28) hecho sistema; sin él el archivado caía a `rejected/` en silencio y la épica quedaba «en construcción» para siempre |
 | `slice-ops.sh fact …` | hechos máquina → evento `project_fact_updated` (sin `slice_id`); hechos humanos → rc 6 con remisión al PATCH admin (§3) |
 | `slice-ops.sh propose-asset` | `POST …/context/agent-proposals` (§6) |
-| `slice-ops.sh status` | `GET /agent/context` (refresco) + ficheros locales |
+| `slice-ops.sh status` | `GET /agent/context` (refresco) + ficheros locales; reporta además `outbox/rejected/` (conteo + tipo y razón del rechazo más reciente, issue #52) |
 | `slice-ops.sh escalate` | evento `slice_escalated {cause}` (gate y fase dentro del texto de la causa; exige slice activo en runtime) |
 | `release-ops.sh verdict <line> <gate> <estado>` | `POST /releases/{line}/verdicts`; **sin fallback offline** (rc 5 y reintento al reconectar: el agregado `release` no entra por `POST /events`, issue #44) |
 | `release-ops.sh close-hint <line>` | **ninguna**: el cierre es humano, con PDP |

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

@@ -272,7 +272,10 @@ RUNTIME_OUTBOX_MAX_AGE_S=259200
 # los aparta a rejected/). Los tres alias 0.10.x del final (`checkpoint_created`,
 # `verdict_reported`, `escalation_raised`) siguen protegidos SOLO porque la capa de
 # compat del despacho los traduce y entrega — evictarlos perdería hechos entregables.
-RUNTIME_OUTBOX_PROTECTED="checkpoint_recorded gate_verdict slice_escalated slice_submitted slice_archived handoff_recorded telemetry_gap wiring_checklist_seeded wiring_item_updated project_fact_updated checkpoint_created verdict_reported escalation_raised"
+# [#52] `phase_advanced` es protegido: el orden de fases del hub es ESTRICTO — evictar un
+# eslabón de la cadena haría ilegales todos los eventos posteriores del slice (incluido el
+# slice_archived, que exige phase == pr).
+RUNTIME_OUTBOX_PROTECTED="checkpoint_recorded gate_verdict slice_escalated slice_submitted slice_archived handoff_recorded telemetry_gap wiring_checklist_seeded wiring_item_updated project_fact_updated phase_advanced checkpoint_created verdict_reported escalation_raised"
 
 runtime_outbox_dir() {
   echo "$(config_root)/.claude/state/outbox"
@@ -513,9 +516,15 @@ for path in sys.argv[2:]:
         continue
     t=d.get("event_type") or d.get("type") or ""
     if t in SIN_EQUIVALENTE:
+        # [#52] La razón viaja DENTRO del fichero apartado (rejected_reason): es lo que
+        # `slice-ops.sh status` y `trycore-build status/doctor` muestran después — sin
+        # esto el rechazo era invisible (stderr de un daemon que nadie lee).
         try:
             os.makedirs(rejected_dir,exist_ok=True)
-            os.replace(path,os.path.join(rejected_dir,os.path.basename(path)))
+            d["rejected_reason"]="%r no existe en el catálogo v2 del hub (issue #44): no se envió" % t
+            dest=os.path.join(rejected_dir,os.path.basename(path))
+            json.dump(d,open(dest,"w"),indent=2,ensure_ascii=False)
+            os.unlink(path)
             print("⚠ %r no existe en el catálogo v2 del hub: apartado a rejected/, no se enviará (issue #44)"
                   % t, file=sys.stderr)
         except OSError:
@@ -572,7 +581,8 @@ elif isinstance(resp,dict):
         reasons[cid]=r.get("reason") or "sin razón"
 for p in paths:
     try:
-        cid=json.load(open(p)).get("client_event_id")
+        d=json.load(open(p))
+        cid=d.get("client_event_id")
     except Exception:
         continue
     st=status.get(cid)
@@ -582,9 +592,14 @@ for p in paths:
     elif st=="rejected":
         print("⚠ el hub rechazó el evento %s: %s — apartado a rejected/, no se reenviará"
               % (cid, reasons.get(cid,"sin razón")), file=sys.stderr)
+        # [#52] La razón del hub se persiste en el fichero apartado (rejected_reason):
+        # la muestran `slice-ops.sh status` y `trycore-build status/doctor`.
         try:
             os.makedirs(rejected_dir,exist_ok=True)
-            os.replace(p, os.path.join(rejected_dir, os.path.basename(p)))
+            d["rejected_reason"]=reasons.get(cid,"sin razón")
+            dest=os.path.join(rejected_dir, os.path.basename(p))
+            json.dump(d,open(dest,"w"),indent=2,ensure_ascii=False)
+            os.unlink(p)
         except OSError:
             pass
 PY
@@ -606,8 +621,30 @@ PY
       echo "  ${#files[@]} evento(s) movidos a $rejected_dir/ — NO se reintentarán." >&2
       echo "  Revisa el contrato del cliente (docs/runtime/protocolo-cliente-runtime.md) o" >&2
       echo "  actualiza el arnés; el trabajo local sigue (fail-open)." >&2
+      # [#52] También aquí la razón (HTTP status) queda persistida en cada fichero apartado.
+      python3 - "$rejected_dir" "$status" "${files[@]}" <<'PY' 2>/dev/null
+import json,sys,os
+rd,st=sys.argv[1],sys.argv[2]
+for p in sys.argv[3:]:
+    try:
+        d=json.load(open(p))
+    except Exception:
+        d=None
+    try:
+        dest=os.path.join(rd,os.path.basename(p))
+        if isinstance(d,dict):
+            d["rejected_reason"]="el hub rechazó el lote entero (HTTP %s)" % st
+            json.dump(d,open(dest,"w"),indent=2,ensure_ascii=False)
+            os.unlink(p)
+        else:
+            os.replace(p,dest)
+    except OSError:
+        pass
+PY
+      # Fallback si python3 desapareció a mitad de camino: mover sin anotar (mejor apartado
+      # sin razón que reintento eterno).
       for f in "${files[@]}"; do
-        mv "$f" "$rejected_dir/" 2>/dev/null
+        [ -f "$f" ] && mv "$f" "$rejected_dir/" 2>/dev/null
       done
       rm -f "$state_file"
       return 1

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

@@ -34,6 +34,70 @@ OPS_MAX_TEXT=1970
 OPS_SLICE_GATES="dor coherence_link tdd journey_smoke fidelity api data wiring_verified dod"
 OPS_RELEASE_GATES="security smell ux coherence stack_arch integration"
 
+# Fases canónicas del slice en el hub (domain.py PHASES, issue #52), SIN `archived`:
+# esa fase terminal se alcanza con el evento `slice_archived`, nunca con `phase_advanced`.
+# El orden es NORMATIVO: el reducer del hub solo acepta la fase siguiente exacta
+# (orden estricto, domain.py:400-407) — de aquí salen las cadenas que emite `phase`.
+OPS_SLICE_PHASES="dor change red green refactor smoke api data dod pr"
+
+# ops_phase_idx <fase> — índice de la fase en OPS_SLICE_PHASES; -1 si no es fase del hub.
+ops_phase_idx() {
+  local i=0 p
+  for p in $OPS_SLICE_PHASES; do
+    [ "$p" = "$1" ] && { echo "$i"; return; }
+    i=$((i + 1))
+  done
+  echo -1
+}
+
+# ops_phase_at <idx> — nombre de la fase en esa posición ("" fuera de rango).
+ops_phase_at() {
+  local i=0 p
+  for p in $OPS_SLICE_PHASES; do
+    [ "$i" = "$1" ] && { echo "$p"; return; }
+    i=$((i + 1))
+  done
+  echo ""
+}
+
+# ops_known_phase [slice_id] — la fase del slice que el SERVIDOR conoce (o va a conocer):
+# la de la caché de proyección, avanzada por los `phase_advanced` PENDIENTES de la outbox
+# para ese slice (el daemon aún no drenó, pero el cliente ya los emitió — sin esto, dos
+# llamadas seguidas a `phase` duplicarían la cadena y el hub las rechazaría una a una).
+# Una fase desconocida o ausente cae a `dor` (fase de nacimiento del slice): sobre-emitir
+# desde atrás es seguro — el lote se aplica en orden y el hub rechaza los eslabones ya
+# aplicados elemento a elemento mientras el sufijo válido entra.
+ops_known_phase() {
+  local sid="${1:-}" base idx pidx
+  base="$(projection_get active_slice.phase "")"
+  idx="$(ops_phase_idx "$base")"
+  [ "$idx" -ge 0 ] || idx=0
+  if [ -n "$sid" ] && command -v python3 >/dev/null 2>&1; then
+    pidx="$(python3 - "$(runtime_outbox_dir)" "$sid" "$OPS_SLICE_PHASES" <<'PY' 2>/dev/null
+import json,sys,glob,os
+d,sid,phases=sys.argv[1],sys.argv[2],sys.argv[3].split()
+best=-1
+for p in glob.glob(os.path.join(d,"*.json")):
+    if os.path.basename(p).startswith("."):
+        continue
+    try:
+        e=json.load(open(p))
+    except Exception:
+        continue
+    if e.get("type")!="phase_advanced" or e.get("slice_id")!=sid:
+        continue
+    to=(e.get("payload") or {}).get("to")
+    if to in phases:
+        best=max(best,phases.index(to))
+print(best)
+PY
+)"
+    case "$pidx" in ''|*[!0-9]*) pidx=-1 ;; esac
+    [ "$pidx" -gt "$idx" ] && idx="$pidx"
+  fi
+  ops_phase_at "$idx"
+}
+
 # ── Tabla de rutas ──
 OPS_PATH_CLAIM="/tasks/next"
 OPS_PATH_CHECKPOINTS="/checkpoints"

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
@@ -96,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
 }

package/hooks/build/slice-ops.sh

@@ -4,9 +4,9 @@
 # `building-a-slice`, los comandos /build:* y los agentes, UNA invocación por transición.
 #
 #   uso: slice-ops.sh <subcomando> [opciones]
-#   subcomandos IMPLEMENTADOS (los 13 del plan): mode | claim | next-step | gate | submit |
-#                archive | wiring | progress | checkpoint | fact | propose-asset | status |
-#                escalate.
+#   subcomandos IMPLEMENTADOS (13 del plan + phase, issue #52): mode | claim | next-step |
+#                phase | gate | submit | archive | wiring | progress | checkpoint | fact |
+#                propose-asset | status | escalate.
 #
 # Contrato con la prosa: cada subcomando devuelve un código de salida tipado
 # (0 ok · 2 uso · 3 legacy · 4 sin slice · 5 offline · 6 rechazado · 7 sin trabajo) y
@@ -24,6 +24,8 @@ uso: slice-ops.sh <subcomando> [opciones]
   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é
+  phase <to>                                    reporta la fase del pipeline (emite la cadena
+                                                phase_advanced que falte; idempotente)
   gate <nombre> <pass|fail|na> [--evidence «texto» | --evidence-file F]
                                                 reporta un veredicto del slice (hecho medido)
   submit [--pr-url U] [--openspec-change C]     entrega el slice
@@ -470,6 +472,30 @@ cmd_status() {
   fi
   pend="$(find "$(runtime_outbox_dir)" -maxdepth 1 -name '*.json' ! -name '.dispatch-state.json' 2>/dev/null | wc -l | tr -d ' ')"
   echo "cola:         $pend evento(s) pendiente(s) de despacho"
+  # [issue #52] outbox/rejected/ era invisible: la cola mostraba 0 pendientes y parecía
+  # éxito mientras el hub había descartado eventos (p.ej. un slice_archived sin la cadena
+  # de fases). Se reporta el conteo y la razón del rechazo más reciente.
+  local rej rejinfo
+  rej="$(find "$(runtime_outbox_dir)/rejected" -maxdepth 1 -name '*.json' 2>/dev/null | wc -l | tr -d ' ')"
+  if [ "${rej:-0}" -gt 0 ] 2>/dev/null; then
+    echo "rechazados:   ⚠ $rej evento(s) en outbox/rejected/ — el hub los descartó, NO se reenvían"
+    rejinfo="$(command -v python3 >/dev/null 2>&1 && python3 - "$(runtime_outbox_dir)/rejected" <<'PY' 2>/dev/null
+import json,glob,os,sys
+files=sorted(glob.glob(os.path.join(sys.argv[1],"*.json")))
+if files:
+    try:
+        d=json.load(open(files[-1]))
+    except Exception:
+        d={}
+    print("%s — %s" % (d.get("type") or d.get("event_type") or "?",
+                       d.get("rejected_reason") or "razón no registrada (apartado por un cliente anterior)"))
+PY
+)"
+    [ -n "$rejinfo" ] && echo "              último: $rejinfo"
+    echo "              revisa la causa y re-emite el hecho corregido (un rechazo no se reintenta solo)"
+  else
+    echo "rechazados:   ninguno"
+  fi
   echo "nudges:       $(projection_get nudges '[]')"
   return $OPS_RC_OK
 }
@@ -623,6 +649,91 @@ _ops_post_or_queue() {
   esac
 }
 
+# ── phase ────────────────────────────────────────────────────────────────────────────
+# [issue #52] El hub modela la fase con `phase_advanced {to}` de ORDEN ESTRICTO
+# (domain.py:400-407: solo la fase siguiente exacta) y `slice_archived` exige phase == pr
+# (domain.py:499-500). Este subcomando emite la cadena que falte DESDE la fase conocida
+# (proyección ∪ cola pendiente, ops_known_phase) HASTA <to>: nada si ya está (idempotente),
+# la cadena completa si hay huecos. Va SIEMPRE por la cola en runtime (no hay endpoint
+# síncrono de fase) y por el espejo en dual (phase_advanced ∈ TIPOS_DE_ESPEJO del hub).
+
+# _phase_chain_enqueue <sid> <desde_idx> <hasta_idx> — encola phase_advanced por paso.
+# rc 0 si toda la cadena quedó encolada; rc 5 si algún eslabón no se pudo encolar (y se
+# corta ahí: encolar eslabones posteriores con un hueco delante era rechazo garantizado).
+_phase_chain_enqueue() {
+  local sid="$1" i="$2" hasta="$3" step pfile
+  i=$((i + 1))
+  while [ "$i" -le "$hasta" ]; do
+    step="$(ops_phase_at "$i")"
+    pfile="$(ops_tmpjson "{\"to\":\"$step\"}")" || return $OPS_RC_OFFLINE
+    if ! ops_enqueue_from_file phase_advanced "$pfile" "$sid"; then
+      rm -f "$pfile"
+      echo "⚠ phase_advanced → «${step}» NO se pudo encolar (outbox no escribible u otro fallo local)" >&2
+      return $OPS_RC_OFFLINE
+    fi
+    rm -f "$pfile"
+    i=$((i + 1))
+  done
+  return $OPS_RC_OK
+}
+
+# _phase_chain_mirror <desde_idx> <hasta_idx> — espeja la cadena en dual (fichero primario).
+# Un rechazo del espejo no bloquea (queda como discrepancia del comparador, spec §6.1).
+_phase_chain_mirror() {
+  local i="$1" hasta="$2" step
+  i=$((i + 1))
+  while [ "$i" -le "$hasta" ]; do
+    step="$(ops_phase_at "$i")"
+    _ops_dual_mirror phase_advanced "{\"to\":\"$step\"}" >/dev/null
+    i=$((i + 1))
+  done
+  return $OPS_RC_OK
+}
+
+cmd_phase() {
+  local to="${1:-}" mode sid base bidx tidx rc
+  if [ -z "$to" ]; then
+    echo "uso: slice-ops.sh phase <to>   (fases: $OPS_SLICE_PHASES)" >&2
+    return $OPS_RC_USAGE
+  fi
+  tidx="$(ops_phase_idx "$to")"
+  if [ "$tidx" -lt 0 ]; then
+    echo "⛔ fase desconocida «${to}». Canónicas: $OPS_SLICE_PHASES" >&2
+    echo "  (la fase terminal archived no se reporta por aquí: la produce \`slice-ops.sh archive\`)" >&2
+    return $OPS_RC_REJECTED
+  fi
+  mode="$(ops_mode)"
+  [ "$mode" = "legacy" ] && { echo "LEGACY: la fase vive en el fichero (active_slice.phase, references/state-protocol.md)"; return $OPS_RC_LEGACY; }
+  # La base es la fase que el SERVIDOR conoce: refresco de la proyección a mejor esfuerzo
+  # (fail-open: sin red se sigue con la caché y con los pendientes de la cola).
+  agent_context_fetch_and_cache >/dev/null 2>&1
+  if [ "$mode" = "dual" ]; then
+    base="$(ops_known_phase)"
+    bidx="$(ops_phase_idx "$base")"; [ "$bidx" -ge 0 ] || bidx=0
+    if [ "$bidx" -ge "$tidx" ]; then
+      echo "fase «${to}» ya reportada (server-side: ${base}) — nada que emitir"
+      return $OPS_RC_OK
+    fi
+    [ $((tidx - bidx)) -gt 1 ] && echo "⚠ el slice estaba en «${base}» server-side: se espeja la cadena completa hasta «${to}» (orden estricto del hub, sin saltos)"
+    _phase_chain_mirror "$bidx" "$tidx"
+    echo "fase espejada: ${base} → ${to} ($((tidx - bidx)) transición(es) phase_advanced)"
+    return $OPS_RC_OK
+  fi
+  sid="$(_ops_require_slice)" || return $OPS_RC_NO_SLICE
+  base="$(ops_known_phase "$sid")"
+  bidx="$(ops_phase_idx "$base")"; [ "$bidx" -ge 0 ] || bidx=0
+  if [ "$bidx" -ge "$tidx" ]; then
+    echo "fase «${to}» ya reportada (server-side o pendiente en la cola: ${base}) — nada que emitir"
+    return $OPS_RC_OK
+  fi
+  [ $((tidx - bidx)) -gt 1 ] && echo "⚠ el slice estaba en «${base}» server-side: se emite la cadena completa hasta «${to}» (orden estricto del hub, sin saltos)"
+  _phase_chain_enqueue "$sid" "$bidx" "$tidx"
+  rc=$?
+  [ "$rc" = "$OPS_RC_OK" ] || return $rc
+  echo "fase reportada: ${base} → ${to} ($((tidx - bidx)) evento(s) phase_advanced encolados; se entregan al reconectar)"
+  return $OPS_RC_OK
+}
+
 # ── gate ─────────────────────────────────────────────────────────────────────────────
 # Un veredicto es un HECHO MEDIDO: acto de agente (spec §2). El nombre del gate y el
 # estado se validan en el cliente (compuerta barata, sin round-trip); la compuerta real,
@@ -717,8 +828,24 @@ cmd_archive() {
   done
   mode="$(ops_mode)"
   [ "$mode" = "legacy" ] && { echo "LEGACY: archiva moviendo active_slice a history[] en el fichero"; return $OPS_RC_LEGACY; }
+  # [issue #52] Catch-up de fase: `slice_archived` exige phase == pr en el hub
+  # (domain.py:499-500) y el orden de fases es estricto — un pipeline que no reportó
+  # `phase` dejaba el slice en dor server-side y el archivado caía a rejected/ EN SILENCIO
+  # (piloto 2026-08-28: slices «en construcción» con el PR ya mergeado). Antes de emitir el
+  # archivado se completa la cadena phase_advanced que falte hasta pr — el workaround del
+  # piloto, hecho sistema. Sin refresco de red: la base sale de la caché ∪ cola pendiente
+  # (sobre-emitir desde atrás es seguro: el hub aplica el lote en orden y rechaza solo los
+  # eslabones ya aplicados, elemento a elemento).
+  local base bidx pridx
+  pridx="$(ops_phase_idx pr)"
   payload="{\"epic_code\":$(ops_json_str "$epic"),\"openspec_change\":$(ops_json_str "$change"),\"pr_url\":$(ops_json_str "$pr")}"
   if [ "$mode" = "dual" ]; then
+    base="$(ops_known_phase)"
+    bidx="$(ops_phase_idx "$base")"; [ "$bidx" -ge 0 ] || bidx=0
+    if [ "$bidx" -lt "$pridx" ]; then
+      echo "⚠ el slice estaba en «${base}» server-side: se espeja la cadena phase_advanced hasta pr antes del archivado"
+      _phase_chain_mirror "$bidx" "$pridx"
+    fi
     _ops_dual_mirror slice_archived "$payload"
     return $?
   fi
@@ -726,6 +853,12 @@ cmd_archive() {
   # 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
+  base="$(ops_known_phase "$sid")"
+  bidx="$(ops_phase_idx "$base")"; [ "$bidx" -ge 0 ] || bidx=0
+  if [ "$bidx" -lt "$pridx" ]; then
+    echo "⚠ el slice estaba en «${base}» server-side: se encola la cadena phase_advanced hasta pr antes del archivado"
+    _phase_chain_enqueue "$sid" "$bidx" "$pridx" || return $OPS_RC_OFFLINE
+  fi
   pfile="$(ops_tmpjson "{}")" || return $OPS_RC_OFFLINE
   if ops_enqueue_from_file slice_archived "$pfile" "$sid"; then
     rm -f "$pfile"
@@ -933,6 +1066,7 @@ case "$SUB" in
   mode) ops_mode; exit 0 ;;
   claim) cmd_claim "$@"; exit $? ;;
   next-step) cmd_next_step; exit $? ;;
+  phase) cmd_phase "$@"; exit $? ;;
   gate) cmd_gate "$@"; exit $? ;;
   submit) cmd_submit "$@"; exit $? ;;
   archive) cmd_archive "$@"; exit $? ;;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycore/spec-build-harness",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "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/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)

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**
 

package/skills/releasing-a-version/SKILL.md

@@ -24,9 +24,12 @@ de épicas de la release son las que vas a auditar en bloque.
   `dual`/`runtime` la release vive en el runtime y cada gate se reporta con
   `bash .claude/hooks/build/release-ops.sh verdict <line> <gate> <pass|fail|na>`; en `legacy`, en el
   array `releases[]` del fichero local (protocolo en `building-a-slice/references/state-protocol.md`).
-- **Reportar es de agentes; cerrar es de humanos** (spec §2). El agente mide y reporta los seis
-  veredictos; **la release la cierra una persona en la consola del hub** — el token de agente no
-  puede hacerlo. `release-ops.sh close-hint <line>` imprime el recordatorio.
+- **Reportar es de agentes; el cierre en verde es del runtime; el degradado es humano** (política
+  A-con-B). El agente mide y reporta los seis veredictos; con el último veredicto de los 6 gates
+  canónicos en PASS **el hub auto-cierra** la release (`closed_by: AUTO_6_OF_6_PASS`, audit trail).
+  Si algún gate queda `fail`/`partial` o hay deudas por decidir, **el cierre es decisión humana en
+  la consola** — el gobierno humano vive donde hay decisión real, no en el clic de un resultado
+  derivable. `release-ops.sh close-hint <line>` imprime la política.
 - **Sobre el diff acumulado**: el alcance es el rango de commits de todas las épicas de la release
   (desde el merge anterior a la primera épica de la release hasta `main`).
 - **Delega en subagentes** (devuelven síntesis, protegen el contexto).
@@ -69,8 +72,8 @@ Checklist de cierre: `references/release-dod.md`.
    no aplique — p. ej. `ux` en una release sin UI). Un `rc 6` es el servidor rechazando: muestra su
    razón, no reintentes. Sin red, el veredicto **no** tiene camino por la cola offline (`rc 5`,
    issue #44): reintenta el mismo comando cuando vuelva la red, antes de pedir el cierre.
-6. Cuando los seis estén reportados, **avisa al humano para el cierre**
-   (`release-ops.sh close-hint R1-mvp`): el agente no cierra releases. Si algún gate quedó `fail`,
+6. Con los seis reportados **en verde, el hub cierra solo** (la respuesta del último `verdict`
+   anuncia `release CERRADA … closed_by: AUTO_6_OF_6_PASS`) — no hay paso manual. Si algún gate quedó `fail`,
    lista los hallazgos bloqueantes; el usuario los corrige como un slice normal (fix en
    `building-a-slice`) y se re-corre el Release Gate.
 

package/skills/releasing-a-version/workflows/release-gate.workflow.js

@@ -9,7 +9,7 @@
 //
 // READ-ONLY sobre el estado: esta plantilla devuelve un diagnóstico; la skill
 // releasing-a-version es la ÚNICA que reporta los veredictos (release-ops.sh verdict por gate;
-// en modo legacy, una entrada en releases[] del fichero). El agregado y el cierre son del
+// en modo legacy, una entrada en releases[] del fichero). El agregado y el auto-cierre en verde son del
 // runtime/humano. Parciales NO promueven a passed. Si METODOLOGIA.md (§5) contradice algo aquí,
 // gana la metodología.
 //
@@ -150,11 +150,11 @@ const reviewersGreen = reviews.filter(Boolean).every((r) => r.na || r.value ===
 const status = (reviewersGreen && gates.integration === true) ? 'passed' : 'failed'
 
 return {
-  status,            // reportado por releasing-a-version vía release-ops.sh verdict (agregado y cierre son del runtime/humano).
+  status,            // reportado por releasing-a-version vía release-ops.sh verdict (agregado y auto-cierre en verde son del runtime; el degradado lo decide un humano).
   gates,             // {security, smell, ux, coherence, stack_arch, integration}
   blocking: [
     ...reviews.filter((r) => r && r.value === false).map((r) => ({ gate: r.gate, error: r.error || null, findings: r.findings || [] })),
     ...(gates.integration === true ? [] : [{ gate: 'integration', findings: (integration && integration.findings) || [] }]),
   ],
-  note: 'Read-only. releasing-a-version reporta un veredicto por gate (release-ops.sh verdict). El runtime agrega y un humano cierra la release en la consola. Parciales NO promueven a passed.',
+  note: 'Read-only. releasing-a-version reporta un veredicto por gate (release-ops.sh verdict). El runtime agrega y AUTO-CIERRA con 6/6 PASS (closed_by: AUTO_6_OF_6_PASS); el caso degradado lo decide un humano en la consola. Parciales NO promueven a passed.',
 }