@trycore/spec-build-harness 0.11.1 → 0.13.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.1",
+  "version": "0.13.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.1
+0.13.0

package/commands/build/onboard.md

@@ -243,30 +243,47 @@ en el runtime. **Importarlo es un acto de gobierno**: la superficie exige sesió
 el token de agente. El arnés **prepara y valida**; una persona sube.
 
 1. Extrae el grafo de los artefactos de discovery ya leídos (`docs/03-backlog/epicas.md`,
-   `docs/02-user-story-map/`, `docs/04-historias/`) a un JSON:
+   `docs/02-user-story-map/`, `docs/04-historias/`) a un JSON. **Las dependencias las extrae
+   el script, no tú** (paso 2): puebla `depends_on` con lo que veas, pero **nunca lo dejes
+   vacío por defecto** — un grafo sin aristas no falla, solo empobrece el Lienzo en silencio
+   (issue #56: 41/41 épicas llegaron al hub con `depends_on: []`).
 
    ```json
    {"project_ref": "<nombre del proyecto>",
     "epics": [{"code": "EP-001", "title": "…", "layer": "foundational",
                "files_scope": ["src/core/**"], "depends_on": [],
-               "stories": [{"id": "HU-001", "title": "…"}]}],
-    "release_lines": [{"id": "R1-mvp", "epics": ["EP-001"]}]}
+               "stories": [{"id": "HU-001", "title": "…"}]},
+              {"code": "EP-002", "title": "…", "layer": "business",
+               "files_scope": ["src/pagos/**"], "depends_on": ["EP-001"],
+               "stories": [{"id": "HU-011", "title": "…"}]}],
+    "release_lines": [{"id": "R1-mvp", "epics": ["EP-001", "EP-002"]}]}
    ```
 
-2. Normalízalo y valídalo (determinista, nunca sube nada). La salida va a
-   `.claude/state/graph-bundle.json` para que `trycore-build migrate` la encuentre sola:
+2. Normalízalo y valídalo (determinista, nunca sube nada). **Pasa siempre `--from-docs`**: el
+   script relee el campo `**Depende de**` de cada sección de épica y **une** ese grafo al del
+   JSON — es la única lectura fiable de las dependencias, que la metodología escribe como
+   prosa. La salida va a `.claude/state/graph-bundle.json` para que `trycore-build migrate` la
+   encuentre sola:
 
    ```bash
-   python3 .claude/scripts/lib/graph-bundle.py < /tmp/epics.json > .claude/state/graph-bundle.json
+   python3 .claude/scripts/lib/graph-bundle.py --from-docs docs/03-backlog/epicas.md \
+     < /tmp/epics.json > .claude/state/graph-bundle.json
    ```
 
+   Para inspeccionar solo lo extraído (sin armar el bundle):
+   `python3 .claude/scripts/lib/graph-bundle.py --print-deps docs/03-backlog/epicas.md`.
+   Si una épica declara el campo estructurado `depende_de: [EP-001]`, ese gana sobre la prosa.
+
    El script emite las épicas en el **formato exacto del hub**: `layer` en MAYÚSCULA
    (`FOUNDATIONAL`|`BUSINESS` — un layer inválido rechaza el grafo ENTERO), historias con
    `code`, y `release_line` (string) por épica.
 
 3. **Lee los avisos** (`warnings` del bundle y stderr): capa ausente, dependencia inexistente,
-   ciclo, línea de release que referencia una épica desconocida. Corrígelos en discovery — el arnés
-   **no inventa** el grafo ni edita `epicas.md` (salvo el carve-out de la épica caparazón, Fase 2c).
+   ciclo, línea de release que referencia una épica desconocida, épica que está en los docs pero
+   no en tu JSON, épica sin campo `Depende de`. Contrasta la línea `info: … N aristas en el
+   grafo` con lo que declara el backlog: **0 aristas en un backlog con dependencias es el
+   síntoma de #56**. Corrígelos en discovery — el arnés **no inventa** el grafo ni edita
+   `epicas.md` (salvo el carve-out de la épica caparazón, Fase 2c).
 
 4. **Entrega al ADMIN un solo fichero.** Si vas a migrar historial, corre `trycore-build migrate`:
    embebe el grafo como sección `graph` del bundle de estado (un único fichero para la pantalla de

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/normalize.js

@@ -1118,6 +1118,17 @@ export function verifyNormalizedBundle(bundle) {
                 message: 'source_key debe tener entre 1 y 200 caracteres (LegacyImported, event_catalog.py:446)',
             });
         }
+        // ImportBundleIn tipa `original` como dict: un escalar responde 422
+        // `dict_type` en la validación pydantic y tumba el bundle ENTERO, antes de
+        // la persistencia por-entrada (issue #55). El bundle sale envuelto de
+        // `wireOriginal`; esto es la red que lo detecta en seco si alguien vuelve a
+        // emitir un escalar por otra vía.
+        if (typeof u.original !== 'object' || u.original === null || Array.isArray(u.original)) {
+            violations.push({
+                source_key: `unmapped[${i}]`,
+                message: 'original debe ser un objeto JSON: el hub lo tipa como dict y responde 422 dict_type sobre el bundle entero (ImportBundleIn)',
+            });
+        }
     });
     return violations;
 }

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/dist/lib/state-bundle.js

@@ -72,6 +72,20 @@ export function graphEpicsWithoutRepresentation(graph, representedCodes) {
         .map((e) => (typeof e.code === 'string' ? e.code : ''))
         .filter((code) => code !== '' && !represented.has(code));
 }
+/** El hub tipa `unmapped[].original` como dict (`ImportBundleIn`): un escalar
+ * responde 422 `dict_type` y tumba el bundle ENTERO en la validación pydantic,
+ * antes de la persistencia por-entrada — observado en el piloto con
+ * `facts[project_kind_source]: "auto"` (issue #55), pero lo emiten cuatro
+ * sitios (fact fuera de catálogo, elemento de history[] no-objeto, nota de
+ * release y `parallel_front.status: "closed"`). Los normalizadores conservan
+ * el valor legacy tal cual — la envoltura pertenece al cable y solo alcanza a
+ * lo que no es ya un objeto JSON, para no anidar dos veces lo que ya viaja bien. */
+function wireOriginal(entry) {
+    const { original } = entry;
+    if (typeof original === 'object' && original !== null && !Array.isArray(original))
+        return entry;
+    return { ...entry, original: { value: original } };
+}
 export function buildStateBundle(raw, projectRef, preHarness) {
     const warnings = [];
     const st = typeof raw === 'object' && raw !== null && !Array.isArray(raw) ? raw : {};
@@ -94,7 +108,7 @@ export function buildStateBundle(raw, projectRef, preHarness) {
     const fronts = front ? [front] : [];
     const factsUnmapped = [];
     const facts = normalizeFacts(st, EPOCH_ISO, warnings, factsUnmapped);
-    const unmapped = [...historyUnmapped, ...releasesUnmapped, ...frontUnmapped, ...factsUnmapped];
+    const unmapped = [...historyUnmapped, ...releasesUnmapped, ...frontUnmapped, ...factsUnmapped].map(wireOriginal);
     // Épicas pre-arnés (issue #42): lista CONFIRMADA por el humano — entrada
     // sintética archivada sin gates por épica (patrón del workaround del piloto).
     // Conflicto obvio ⇒ error, no fusión: una épica declarada pre-arnés que YA

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 |
@@ -199,3 +201,29 @@ reducer **no bloquea** el trabajo local: se avisa y queda como discrepancia del
 **Lo que el agente NO hace** (superficies humanas, con PDP): cerrar una release, planificar/abrir/
 drenar/cerrar un front, subir el bundle de import del grafo y publicar contexto. El arnés prepara,
 propone y reporta; la persona decide en la consola del hub.
+
+---
+
+## 11. Bundle de import histórico (`POST /projects/{id}/import/bundle`)
+
+Lo produce `trycore-build migrate` (`src/lib/state-bundle.ts`) y lo sube una persona con sesión de
+ADMIN. La validación del hub es **pydantic sobre el cuerpo entero**: un solo campo mal tipado
+responde 422 y rechaza el bundle completo **antes** de la persistencia por-entrada — no hay
+degradación parcial. De ahí que el contrato de las secciones "de rescate" importe tanto como el de
+los eventos.
+
+`unmapped[]` — todo lo que el estado legacy trae y el catálogo del hub no sabe nombrar (spec §7:
+*nada se pierde, nada bloquea*):
+
+| Campo | Tipo exigido | Nota |
+|---|---|---|
+| `source_key` | string, 1..200 | `LegacyImported`, `event_catalog.py:446` |
+| `original` | **dict** | un escalar responde 422 `dict_type` (issue #55) |
+| `occurred_at` | ISO-8601 UTC | ancla del dato legacy, no la hora de la migración |
+
+El estado legacy guarda escalares en cuatro de los sitios que caen aquí (fact fuera de catálogo,
+elemento de `history[]` no-objeto, nota de release, `parallel_front.status: "closed"`), así que
+`buildStateBundle` **envuelve** todo `original` que no sea ya un objeto JSON como `{"value": …}`.
+La envoltura es del cable: los normalizadores conservan el valor legacy tal cual, y un `original`
+que ya es dict viaja intacto (nunca se anida dos veces). `migrate --verify` comprueba el invariante
+en seco, sin red.

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/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.1",
+  "version": "0.13.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": {