@trycore/spec-build-harness 0.10.0 → 0.11.1

package/dist/lib/state-bundle.js

@@ -5,10 +5,74 @@
 // import histórico (docs/superpowers/specs/2026-08-20-cliente-migrate-normalizacion-eventos-design.md):
 // convierte el build-state.json legacy del piloto en la forma ImportBundleIn
 // que ya entiende el import del hub — eventos del catálogo v2, no snapshots crudos.
-import { normalizeHistory, normalizeReleases, normalizeFront, normalizeFacts, validateNormalizedBundle, } from './normalize.js';
+import { normalizeHistory, normalizeReleases, normalizeFront, normalizeFacts, normalizePreHarnessEpic, validateNormalizedBundle, verifyNormalizedBundle, } from './normalize.js';
 export const STATE_BUNDLE_VERSION = 2;
 const EPOCH_ISO = new Date(0).toISOString();
-export function buildStateBundle(raw, projectRef) {
+// Contrato del hub (graph_service.VALID_LAYERS): un layer fuera de este set
+// rechaza el grafo ENTERO (GraphIntegrityError) — mejor pararlo en local.
+const VALID_LAYERS = new Set(['FOUNDATIONAL', 'BUSINESS']);
+/**
+ * Extrae la sección `graph` (formato GraphImportIn del hub) desde el bundle de
+ * `scripts/lib/graph-bundle.py` o desde un `{epics: [...]}` crudo, validando lo
+ * que el hub validará: `layer` ∈ FOUNDATIONAL|BUSINESS, `code` y `title` por
+ * épica, `code` y `title` por historia (`story_in["code"]`). Errores ⇒ graph
+ * null: embeber un grafo que el hub rechazará entero no ayuda a nadie.
+ */
+export function extractGraphSection(raw) {
+    const errors = [];
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return { graph: null, errors: ['el bundle de grafo no es un objeto JSON'] };
+    }
+    const epicsRaw = raw.epics;
+    if (!Array.isArray(epicsRaw)) {
+        return { graph: null, errors: ['el bundle de grafo no tiene `epics` (¿lo generó scripts/lib/graph-bundle.py?)'] };
+    }
+    const epics = [];
+    epicsRaw.forEach((e, i) => {
+        if (typeof e !== 'object' || e === null || Array.isArray(e)) {
+            errors.push(`epics[${i}] no es un objeto`);
+            return;
+        }
+        const epic = e;
+        const code = typeof epic.code === 'string' && epic.code ? epic.code : null;
+        if (!code)
+            errors.push(`epics[${i}] sin \`code\``);
+        const ref = code ?? `epics[${i}]`;
+        if (typeof epic.title !== 'string' || !epic.title) {
+            errors.push(`${ref} sin \`title\` (EpicIn del hub lo exige)`);
+        }
+        if (typeof epic.layer !== 'string' || !VALID_LAYERS.has(epic.layer)) {
+            errors.push(`${ref} con layer ${JSON.stringify(epic.layer ?? null)} fuera de FOUNDATIONAL|BUSINESS: el hub rechazaría el grafo ENTERO`);
+        }
+        for (const [j, s] of (Array.isArray(epic.stories) ? epic.stories : []).entries()) {
+            const story = typeof s === 'object' && s !== null ? s : {};
+            if (typeof story.code !== 'string' || !story.code) {
+                errors.push(`${ref}: historia [${j}] sin \`code\` (el hub hace story_in["code"] — ¿bundle en formato viejo con \`id\`?)`);
+            }
+            else if (typeof story.title !== 'string' || !story.title) {
+                errors.push(`${ref}: historia ${story.code} sin \`title\``);
+            }
+        }
+        epics.push(epic);
+    });
+    if (errors.length > 0)
+        return { graph: null, errors };
+    return { graph: { epics }, errors };
+}
+/**
+ * Épicas del grafo embebido SIN representación en el bundle: ni slice en
+ * history[] ni declaración pre-arnés. Es el síntoma exacto del incidente de
+ * el primer piloto real: quedan «sin empezar» en el hub y
+ * `claim_next` las reparte como trabajo nuevo. Solo detecta — la lista
+ * pre-arnés la confirma el humano, nunca se auto-añade nada.
+ */
+export function graphEpicsWithoutRepresentation(graph, representedCodes) {
+    const represented = new Set(representedCodes);
+    return graph.epics
+        .map((e) => (typeof e.code === 'string' ? e.code : ''))
+        .filter((code) => code !== '' && !represented.has(code));
+}
+export function buildStateBundle(raw, projectRef, preHarness) {
     const warnings = [];
     const st = typeof raw === 'object' && raw !== null && !Array.isArray(raw) ? raw : {};
     if (raw !== null && (typeof raw !== 'object' || Array.isArray(raw))) {
@@ -22,13 +86,40 @@ export function buildStateBundle(raw, projectRef) {
     if (st.releases !== undefined && !Array.isArray(st.releases)) {
         warnings.push('releases no es un array: se descarta (0 releases migradas)');
     }
-    const { entries: history, unmapped: historyUnmapped } = normalizeHistory(historyRaw);
-    const { entries: releases, unmapped: releasesUnmapped } = normalizeReleases(releasesRaw);
-    const front = normalizeFront(st.parallel_front ?? null);
+    const { entries: history, unmapped: historyUnmapped, warnings: historyWarnings } = normalizeHistory(historyRaw);
+    const { entries: releases, unmapped: releasesUnmapped, warnings: releaseWarnings } = normalizeReleases(releasesRaw);
+    warnings.push(...historyWarnings, ...releaseWarnings);
+    const frontUnmapped = [];
+    const front = normalizeFront(st.parallel_front ?? null, warnings, frontUnmapped);
     const fronts = front ? [front] : [];
-    const facts = normalizeFacts(st, EPOCH_ISO);
-    const unmapped = [...historyUnmapped, ...releasesUnmapped];
-    const validationErrors = validateNormalizedBundle({ history, releases, fronts });
+    const factsUnmapped = [];
+    const facts = normalizeFacts(st, EPOCH_ISO, warnings, factsUnmapped);
+    const unmapped = [...historyUnmapped, ...releasesUnmapped, ...frontUnmapped, ...factsUnmapped];
+    // É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
+    // tiene slice (en history[] o como active_slice) es una contradicción que
+    // debe resolver el humano, no el normalizador.
+    const conflictErrors = [];
+    if (preHarness) {
+        const historyCodes = new Set(history.map((h) => h.epic_code));
+        const active = st.active_slice;
+        const activeCode = typeof active === 'object' && active !== null && typeof active.epica === 'string'
+            ? String(active.epica)
+            : null;
+        for (const epic of preHarness.epics) {
+            if (historyCodes.has(epic.code)) {
+                conflictErrors.push(`pre-arnés: la épica "${epic.code}" ya tiene slice en build-state.json (history[]) — una épica no puede declararse pre-arnés y tener historia de slice a la vez; quítala de la lista --pre-harness`);
+                continue;
+            }
+            if (activeCode === epic.code) {
+                conflictErrors.push(`pre-arnés: la épica "${epic.code}" es el active_slice de build-state.json — un slice en construcción no es pre-arnés; ciérralo o quítala de la lista --pre-harness`);
+                continue;
+            }
+            history.push(normalizePreHarnessEpic(epic, preHarness.asOf));
+        }
+    }
+    const validationErrors = [...conflictErrors, ...validateNormalizedBundle({ history, releases, fronts })];
     return {
         bundle_version: STATE_BUNDLE_VERSION,
         kind: 'state',
@@ -44,3 +135,16 @@ export function buildStateBundle(raw, projectRef) {
         validation_errors: validationErrors,
     };
 }
+/** Verificación offline del bundle contra los invariantes del hub (migrate
+ * --verify): delega en `verifyNormalizedBundle`, que replica en seco lo que
+ * `validar_secuencia` del hub aplicaría en el import (import_domain.py:126-172).
+ * Vacío ⇒ el bundle puede entregarse al ADMIN sin motivo de rechazo conocido. */
+export function verifyStateBundle(bundle) {
+    return verifyNormalizedBundle({
+        history: bundle.history,
+        releases: bundle.releases,
+        fronts: bundle.fronts,
+        facts: bundle.facts,
+        unmapped: bundle.unmapped,
+    });
+}

package/docs/runtime/guia-modo-dual-y-migracion.md

@@ -98,10 +98,17 @@ los conozca (proyecciones consultables, no solo lo que ocurra de aquí en adelan
 
 ```bash
 trycore-build migrate --project-ref "<nombre-del-proyecto-en-el-hub>"
-# escribe .claude/state/migration-bundle.json
+# escribe .claude/state/migration-bundle.json (UN solo fichero, con la sección graph embebida
+# si existe .claude/state/graph-bundle.json o se pasa --graph <fichero> — issue #41)
+
+trycore-build migrate --verify   # solo verifica offline contra los invariantes del hub; no escribe nada
 ```
 
-Esto **normaliza y valida en local** — nunca sube nada. Entrega el fichero resultante a un ADMIN
+Esto **normaliza, verifica contra los invariantes del hub y valida en local** — nunca sube nada.
+Si el bundle viola algún invariante (evidencia obligatoria en veredictos passing, límites de
+longitud, catálogo de gates/eventos, orden de fases…), `migrate` **aborta sin escribir el
+fichero**: un bundle que el hub rechazaría no se entrega al ADMIN (lección del primer piloto real,
+issue #40 — el primer import rechazó 36/41 entradas por defectos detectables offline). Entrega el fichero resultante a un ADMIN
 con la instrucción: *«súbelo en la consola del hub, pantalla de import histórico del proyecto»*. El
 import es idempotente y reanuda si falló a medias; las entradas no mapeables se importan igual como
 `legacy_imported` con el payload original — nada se pierde, nada bloquea.

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

@@ -16,7 +16,7 @@
 |---|---|---|---|
 | SessionStart (`startup\|clear\|compact`) | `session-start.sh` | `POST /agents/register` (idempotente, con `asset_types`) + `GET /agent/context` + `context-sync.sh` (§4) + aseguramiento del daemon | Escribe la **caché de proyección normalizada** (`.claude/state/runtime-projection.json`). No inyecta contexto: el render lo hace `load-build-state.sh`, que corre después en el mismo evento. |
 | SessionStart (mismo matcher) | `load-build-state.sh` | **ninguna** | Renderiza `additionalContext` desde la caché en modo `runtime`; en `legacy\|dual` sigue leyendo `build-state.json`. |
-| PostToolUse (`Bash\|Edit\|Write\|MultiEdit\|Task`) | `event-emitter.sh` | **ninguna en el hilo del hook**: encola `tool_use_recorded` | Encola en `.claude/state/outbox/` (§5) y hace la comprobación barata del daemon (stat del pidfile). Solo metadatos: herramienta, ruta relativa, `argv0` — nunca el comando completo ni el fuente (§8). |
+| PostToolUse (`Bash\|Edit\|Write\|MultiEdit\|Task`) | `event-emitter.sh` | **ninguna** | Solo hace la comprobación barata del daemon (stat del pidfile). Desde el issue #44 **no encola nada**: `tool_use_recorded` no existe en el catálogo v2 del hub y era ruido garantizado en `rejected/`; la telemetría de uso queda suspendida hasta que el equipo del hub decida añadir el tipo. |
 | — (daemon, no hook) | `heartbeat.sh --daemon` | `PUT /leases/renew` + `POST /events` | Singleton por repo con registro de ppids de sesión; late cada `lease_ttl_s/3` (valor del servidor) y despacha la cola mientras viva. Ver §9. |
 | — (invocado, no registrado) | `context-sync.sh` | `GET …/context/manifest`, `GET …/context/files?path=…&sha256=…`, `POST /context/synced` | Lo llama `session-start.sh` y, desde el sub-slice C, las skills antes de reclamar. |
 | PreCompact / PostToolUse / Stop | `context-monitor.sh` | encola `handoff_recorded {note, resume_hint, stopped_at}` | En `runtime` el handoff **solo** es evento (no se escribe el fichero); en `dual` se escribe el fichero **y** se emite; en `legacy`, solo el fichero. `handoff_recorded` es de ámbito **slice**: solo se encola con `slice_id` conocido (misma guardia que `event-emitter.sh`); en `dual`, como no hay claim vía runtime, `active_slice` normalmente no llega por `/agent/context` y el evento no se emite (solo queda el fichero). |
@@ -29,7 +29,8 @@ Eventos emitidos por skills (no por hooks) — sub-slice C: `POST /checkpoints`,
 ## 3. Claim (el corazón del pull)
 
 ```
-POST /tasks/next   {context_hashes: [{path, sha256}], epic_code?}
+POST /tasks/next   {context_hashes: {"<path>": "<sha256>", …}}   // dict[str,str]; {} = reporta vacío;
+                                                                 // valor "" = fichero ilegible (nunca null)
   200 → {slice_id, epic_code, epic_title, stories[], files_scope, docs_ref, phase, gates,
          branch_base, openspec_change, manifest_hash,
          lease: {ttl_s, expires_at}, checkpoint: {branch, commit_sha} | null}
@@ -53,12 +54,19 @@ Reglas del cliente (las implementa `slice-ops.sh claim`, no la prosa de la skill
 4. Un agente mantiene **un solo** slice activo; reclamar con lease vigente devuelve el mismo slice.
 5. Modo `dual`: **no se reclama** (el fichero decide el slice, spec §6.1) — el subcomando devuelve
    rc 3. Modo `legacy`: no hay red, rc 3.
+6. **No existe claim dirigido**: `TasksNextIn` no acepta `epic_code` (pydantic ignoraría el campo y
+   la cola repartiría otra épica — incidente del primer piloto, issue #39). `claim --epic` falla explícito
+   (rc 2, sin abrir socket) explicando el protocolo real: terminar el slice en dual → cutover
+   admin → reclamar del hub lo que la cola reparta.
 
 Actos de dominio posteriores (todos por `slice-ops.sh`, ninguno a mano):
 `POST /slices/{id}/verdicts` · `POST /checkpoints` · `POST /slices/{id}/submit` · eventos
-`wiring_*`, `progress_note_recorded`, `slice_archived`, `escalation_raised` y los hechos de
-proyecto (`scaffold_confirmed`, `design_source_declared`, `project_kind_declared`,
-`foundation_declared`, `harness_phase_changed`) por la cola (§5). Outer loop, por
+`wiring_*`, `progress_noted`, `slice_archived`, `slice_escalated` y los hechos de
+proyecto **máquina** (`project_kind`, `harness_phase`, `foundation`) como
+`project_fact_updated {fact, value, source: "AGENT"}` — el único tipo del catálogo v2 para hechos
+(issue #38). Los hechos **humanos** (`scaffold_confirmed`, `design_source_*`) NO viajan por la
+superficie de agente: se fijan tras el PDP por `PATCH /orchestrator/projects/{project_id}`
+(consola admin); `slice-ops fact` los rechaza en runtime/dual con rc 6. Outer loop, por
 `release-ops.sh`: `POST /releases/{line}/verdicts` y
 `POST /fronts/{front_id}/members/{agent_key}/integration`.
 
@@ -86,9 +94,11 @@ Offline: sin runtime se trabaja con el último lock; la statusline marca `⚠ st
 
 ## 5. Cola offline de eventos (`.claude/state/outbox/`)
 
-- 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.
+- 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).
 - 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_created`, `verdict_reported`, `slice_submitted`, `handoff_recorded`, `branch_drift` ni el propio `telemetry_gap`; el descarte se reporta como evento `telemetry_gap` (con `dropped_count`/`dropped_types`) encolado en el mismo acto.
+- 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.
 
 ## 6. Declaración de tipos de asset (`asset-types.json` del paquete)
@@ -161,24 +171,24 @@ modo, valida en local lo que es barato validar y encola lo que no pudo entregar.
 | Comando | Superficie |
 |---|---|
 | `slice-ops.sh mode` | ninguna (lee `build-config.json`) |
-| `slice-ops.sh claim [--epic]` | `POST /tasks/next` (§3) |
+| `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 gate <g> <pass\|fail\|na>` | `POST /slices/{id}/verdicts` |
-| `slice-ops.sh wiring seed\|update` | eventos `wiring_checklist_seeded` / `wiring_item_updated` |
-| `slice-ops.sh progress` | evento `progress_note_recorded` (evictable) |
-| `slice-ops.sh checkpoint` | `POST /checkpoints` |
-| `slice-ops.sh submit` | `POST /slices/{id}/submit` |
-| `slice-ops.sh archive` | evento `slice_archived` (siempre por cola, idempotente) |
-| `slice-ops.sh fact …` | eventos de **ámbito proyecto** (sin `slice_id`) |
+| `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 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 escalate` | evento `escalation_raised` |
-| `release-ops.sh verdict <line> <gate> <estado>` | `POST /releases/{line}/verdicts` |
+| `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 |
-| `release-ops.sh front-integration <front>` | `POST /fronts/{id}/members/{agent_key}/integration` |
+| `release-ops.sh front-integration <front>` | `POST /fronts/{id}/members/{agent_key}/integration`; **sin fallback offline** (rc 5: `front_integration_reported` no existe en el catálogo v2, issue #44) |
 
 **Códigos de salida** (contrato con la prosa): `0` ok · `2` uso · `3` modo legacy (o claim en dual)
-· `4` sin slice activo · `5` offline, encolado · `6` rechazado por el servidor (no reintentar) ·
+· `4` sin slice activo · `5` offline (encolado si el tipo tiene camino por la cola; si no, reintento manual al reconectar) · `6` rechazado por el servidor (no reintentar) ·
 `7` sin trabajo.
 
 **Modo `dual`:** el fichero es primario y estos comandos **espejan** cada transición a

package/hooks/build/event-emitter.sh

@@ -14,59 +14,16 @@ source "$HERE/lib/projection.sh"
 MODE="$(runtime_mode)"
 [ "$MODE" = "legacy" ] && exit 0
 
-payload="$(cat 2>/dev/null || true)"
-command -v python3 >/dev/null 2>&1 || exit 0
+# El stdin del hook se consume y se descarta (higiene del pipe; no se usa).
+cat >/dev/null 2>&1 || true
 
-SLICE_ID="$(projection_get active_slice.slice_id "")"
-if [ -n "$SLICE_ID" ]; then
-  TMPP="$(mktemp)" || exit 0
-  printf '%s' "$payload" > "$TMPP"
-  EV="$(PROJECT_ROOT="$(config_root)" python3 - "$TMPP" <<'PY' 2>/dev/null
-import json,os,re,shlex,sys
-try:
-    p=json.load(open(sys.argv[1]))
-except Exception:
-    raise SystemExit(0)
-if not isinstance(p,dict):
-    raise SystemExit(0)
-tool=p.get("tool_name") or ""
-if not tool:
-    raise SystemExit(0)
-ti=p.get("tool_input")
-if not isinstance(ti,dict):
-    ti={}
-out={"tool":tool}
-if tool=="Bash":
-    cmd=str(ti.get("command") or "").strip()
-    # shlex.split (posix=True) respeta comillas: una asignación de entorno inline con
-    # valor citado y espacios (p.ej. `KEY="a b" cmd`) se tokeniza como UN solo token, no
-    # se trocea. Si el comando trae comillas sin cerrar u otro problema de tokenización,
-    # shlex lanza ValueError: no arriesgamos un fragmento de secreto, degradamos a "".
-    try:
-        toks=shlex.split(cmd) if cmd else []
-    except ValueError:
-        toks=[]
-    # Salta asignaciones de variable de entorno inline al frente (p.ej. `VAR=secreto cmd`,
-    # `A=1 B=2 cmd`) para que argv0 sea siempre el binario, nunca un valor que pueda
-    # llevar credenciales (protocolo §8).
-    i=0
-    while i < len(toks) and re.match(r'^[A-Za-z_][A-Za-z0-9_]*=', toks[i]):
-        i += 1
-    out["argv0"]=toks[i] if i < len(toks) else ""
-elif tool=="Task":
-    out["subagent_type"]=str(ti.get("subagent_type") or "")
-else:
-    fp=str(ti.get("file_path") or ti.get("path") or "")
-    root=os.environ.get("PROJECT_ROOT") or ""
-    if root and fp.startswith(root+os.sep):
-        fp=fp[len(root)+1:]
-    out["path"]=fp
-print(json.dumps(out,ensure_ascii=False))
-PY
-)"
-  rm -f "$TMPP"
-  [ -n "$EV" ] && runtime_enqueue_event "tool_use_recorded" "$EV" "$SLICE_ID"
-fi
+# [#44] `tool_use_recorded` NO existe en el catálogo v2 del hub (event_catalog.SCHEMAS):
+# encolarlo era ruido garantizado en outbox/rejected/ al drenar, y este hook era justo su
+# único productor. NO se emite telemetría de uso de herramienta hasta que el equipo del
+# hub decida si añade el tipo al catálogo (decisión pendiente, issue #44); si eso ocurre,
+# se reactiva aquí el armado de metadatos que vivía en este bloque hasta la v0.10.x
+# (git history: solo herramienta, ruta relativa y argv0 — jamás el comando completo ni el
+# fuente, protocolo §8). En legacy este hook ya salía arriba sin encolar: nada cambia.
 
 # Comprobación barata del daemon (stat del pidfile + kill -0, SIN red): un daemon caído a
 # mitad de sesión no debe quedar muerto durante horas hasta el próximo SessionStart.

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

@@ -261,8 +261,18 @@ RUNTIME_OUTBOX_MAX_BYTES=5242880
 RUNTIME_OUTBOX_MAX_AGE_S=259200
 # [EP-OR-08-C] Los hechos de dominio que emiten las skills (slice-ops.sh) tampoco se evictan:
 # perder un `slice_archived` o un `wiring_item_updated` dejaría la proyección del servidor
-# mintiendo. El volumen evictable sigue siendo `tool_use_recorded` y `progress_note_recorded`.
-RUNTIME_OUTBOX_PROTECTED="checkpoint_created verdict_reported slice_submitted handoff_recorded telemetry_gap branch_drift slice_archived wiring_checklist_seeded wiring_item_updated escalation_raised scaffold_confirmed design_source_declared project_kind_declared foundation_declared harness_phase_changed front_integration_reported"
+# mintiendo. El volumen evictable es `progress_noted` (y su alias 0.10.x).
+# [#38] Los hechos máquina de proyecto viajan como UN solo tipo del catálogo v2
+# (`project_fact_updated`); los cinco alias legados (`scaffold_confirmed`,
+# `design_source_declared`, `project_kind_declared`, `foundation_declared`,
+# `harness_phase_changed`) ya no se encolan y salieron de la lista.
+# [#44] La lista lleva los NOMBRES DEL CATÁLOGO v2 del hub (event_catalog.SCHEMAS):
+# proteger de la evicción un tipo que el hub va a rechazar era absurdo. Salen
+# `branch_drift` y `front_integration_reported` (no existen en el catálogo; el despacho
+# 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"
 
 runtime_outbox_dir() {
   echo "$(config_root)/.claude/state/outbox"
@@ -301,9 +311,12 @@ PY
 }
 
 # runtime_outbox_enforce_cap — cota 5MB/72h. Descarta primero los eventos NO protegidos
-# (más viejos primero); jamás descarta checkpoint/verdict/submit/handoff/telemetry_gap/
-# branch_drift. Si hubo descartes, encola un telemetry_gap describiéndolos. Imprime en
-# stdout el conteo de descartados (última línea).
+# (más viejos primero); jamás descarta un tipo de RUNTIME_OUTBOX_PROTECTED. Si hubo
+# descartes, encola un telemetry_gap con el payload EXACTO del catálogo v2 [#44]
+# (TelemetryGap: {dropped>=1, window_h>0, reason<=2000}; extra="forbid" — el
+# {dropped_count, dropped_types} de 0.10.x era rechazo garantizado): `dropped` es el
+# conteo, `window_h` la ventana de la cota en horas y `reason` el motivo con los tipos
+# descartados. Imprime en stdout el conteo de descartados (última línea).
 runtime_outbox_enforce_cap() {
   local dir; dir="$(runtime_outbox_dir)"
   [ -d "$dir" ] || { echo 0; return 0; }
@@ -360,19 +373,33 @@ if dropped:
             existing_gap_path=p
             existing_gap=d
             break
+    window_h=max_age/3600.0
+    def resumen(tipos):
+        counts={}
+        for t in tipos:
+            k=t or "desconocido"
+            counts[k]=counts.get(k,0)+1
+        return ", ".join("%s x%d" % kv for kv in sorted(counts.items()))
+    encabezado="evicción por cota de la outbox (%d bytes / %.0f h)" % (max_bytes, window_h)
     if existing_gap_path:
         payload=existing_gap.get("payload") or {}
-        payload["dropped_count"]=payload.get("dropped_count",0)+len(dropped)
-        payload["dropped_types"]=payload.get("dropped_types",[])+dropped
+        # Compat 0.10.x: un gap ya encolado puede traer {dropped_count, dropped_types};
+        # se normaliza aquí al payload del catálogo antes de acumular.
+        prev_n=payload.get("dropped", payload.get("dropped_count", 0)) or 0
+        prev_types=payload.get("dropped_types") or []
+        prev_reason=payload.get("reason") if isinstance(payload.get("reason"),str) else ""
+        base=prev_reason or (("%s: %s" % (encabezado, resumen(prev_types))) if prev_types else "")
+        texto=("%s; %s" % (base, resumen(dropped))) if base else ("%s: %s" % (encabezado, resumen(dropped)))
         gap=existing_gap
-        gap["payload"]=payload
+        gap["payload"]={"dropped": prev_n+len(dropped), "window_h": window_h, "reason": texto[:2000]}
         fname=existing_gap_path
         fd,tmp=tempfile.mkstemp(dir=dir_,prefix=".outbox.",suffix=".tmp")
     else:
         cid=str(uuid.uuid4())
         ts=datetime.datetime.now(datetime.timezone.utc)
         gap={"client_event_id":cid,"type":"telemetry_gap",
-             "payload":{"dropped_count":len(dropped),"dropped_types":dropped},
+             "payload":{"dropped":len(dropped),"window_h":window_h,
+                        "reason":("%s: %s" % (encabezado, resumen(dropped)))[:2000]},
              "enqueued_at":ts.strftime("%Y-%m-%dT%H:%M:%S.%fZ")}
         fname=os.path.join(dir_, ts.strftime("%Y%m%d%H%M%S%f")+"-"+cid+".json")
         fd,tmp=tempfile.mkstemp(dir=dir_,prefix=".outbox.",suffix=".tmp")
@@ -416,44 +443,177 @@ runtime_dispatch_outbox() {
   while IFS= read -r f; do files+=("$f"); done < <(find "$dir" -maxdepth 1 -name '*.json' ! -name '.dispatch-state.json' | sort)
   [ ${#files[@]} -eq 0 ] && return 0
 
+  # [#37] El hub (`EventBatchIn`) exige el sobre {"events": [...]} — el array pelado era
+  # 422 en cada intento y la cola no drenaba jamás. Cada elemento va con `event_type`
+  # (`EventIn`); la clave interna de la outbox sigue siendo `type` y se traduce AQUÍ, al
+  # armar el cuerpo: los ficheros ya encolados en consumidores (0.10.x, clave `type`)
+  # drenan sin migración y el formato en disco no cambia (lo leen otros clientes).
+  # [#44] En este MISMO punto de salida vive la capa de compat de nombres/payloads: los
+  # productores ya encolan los nombres del catálogo v2, pero un consumidor 0.10.x dejó
+  # ficheros con los nombres viejos (`verdict_reported`, `checkpoint_created`,
+  # `escalation_raised`, `progress_note_recorded`) y payloads que `extra="forbid"`
+  # rechazaría — se traducen tipo Y claves al armar el cuerpo. Los tipos SIN equivalente
+  # en el catálogo (`tool_use_recorded`, `branch_drift`, `front_integration_reported`) se
+  # apartan localmente a rejected/ sin gastar red: mandarlos era rechazo garantizado.
   local batch
-  batch="$(python3 - "${files[@]}" <<'PY'
-import json,sys
+  batch="$(python3 - "$dir/rejected" "${files[@]}" <<'PY'
+import json,sys,os
+rejected_dir=sys.argv[1]
+SIN_EQUIVALENTE={"tool_use_recorded","branch_drift","front_integration_reported"}
+def traducir(t,p,slice_id):
+    p=dict(p)
+    if t=="verdict_reported":
+        # Un veredicto de RELEASE 0.10.x (payload con release_line, sin slice) no tiene
+        # camino por /events: se deja pasar tal cual y el hub lo rechaza con razón — la
+        # forma de slice se traduce a gate_verdict {gate, verdict, evidence…}.
+        t="gate_verdict"
+        if "status" in p and "verdict" not in p:
+            p["verdict"]=p.pop("status")
+        v=p.get("verdict")
+        if isinstance(v,str) and v.lower() in ("pass","fail"):
+            p["verdict"]=v.upper()
+        p={k:v for k,v in p.items() if k in ("gate","verdict","evidence","cause","details_ref")}
+    elif t=="checkpoint_created":
+        t="checkpoint_recorded"
+        if "note" in p and "summary" not in p:
+            p["summary"]=p.pop("note")
+        sid=p.pop("slice_id",None)
+        if sid and not slice_id:
+            slice_id=sid
+        p={k:v for k,v in p.items() if k in ("branch","commit_sha","summary")}
+    elif t=="escalation_raised":
+        t="slice_escalated"
+        pref=""
+        if p.get("gate"): pref+="[gate: %s] " % p["gate"]
+        if p.get("phase"): pref+="[fase: %s] " % p["phase"]
+        cause=p.get("cause") or (pref+str(p.get("reason") or ""))
+        p={"cause": (cause.strip() or "escalada sin causa registrada")[:2000]}
+    elif t=="progress_note_recorded":
+        t="progress_noted"
+        p={k:v for k,v in p.items() if k=="note"}
+    elif t in ("slice_submitted","slice_archived"):
+        p={}  # el catálogo no admite ningún campo (extra="forbid")
+    elif t=="wiring_checklist_seeded":
+        items=[]
+        for it in p.get("items") or []:
+            if isinstance(it,dict) and it.get("item_id"):
+                items.append({"item_id":it["item_id"],"kind":it.get("kind") or "","ref":it.get("ref") or ""})
+        p={"items":items}
+    elif t=="telemetry_gap" and "dropped" not in p and "dropped_count" in p:
+        tipos=p.get("dropped_types") or []
+        p={"dropped":p.get("dropped_count") or 0,"window_h":72.0,
+           "reason":("evicción por cota de la outbox del cliente; tipos descartados: "
+                     +", ".join(str(x) for x in tipos))[:2000]}
+    return t,p,slice_id
 items=[]
-for p in sys.argv[1:]:
-    try: items.append(json.load(open(p)))
-    except Exception: pass
-print(json.dumps(items))
+for path in sys.argv[2:]:
+    try:
+        d=json.load(open(path))
+    except Exception:
+        continue
+    t=d.get("event_type") or d.get("type") or ""
+    if t in SIN_EQUIVALENTE:
+        try:
+            os.makedirs(rejected_dir,exist_ok=True)
+            os.replace(path,os.path.join(rejected_dir,os.path.basename(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:
+            pass
+        continue
+    t,p,slice_id=traducir(t,d.get("payload") or {},d.get("slice_id"))
+    ev={"client_event_id": d.get("client_event_id") or "",
+        "event_type": t,
+        "payload": p}
+    if slice_id:
+        ev["slice_id"]=slice_id
+    items.append(ev)
+print(json.dumps({"events": items}, ensure_ascii=False))
 PY
 )"
 
+  # Si todo lo pendiente eran tipos sin equivalente (ya apartados), no hay nada que enviar.
+  local n_items
+  n_items="$(printf '%s' "$batch" | python3 -c 'import json,sys;print(len(json.load(sys.stdin).get("events") or []))' 2>/dev/null || echo 0)"
+  if [ "$n_items" = "0" ]; then
+    rm -f "$state_file"
+    return 0
+  fi
+
   local resp status
   resp="$(runtime_post "/events" "$batch")"
   status="$(runtime_http_status)"
 
   if [ "$status" = "200" ]; then
-    python3 - "$resp" "${files[@]}" <<'PY'
+    # [#37] Ack REAL del hub: {accepted:[cid], duplicates:[cid], rejected:[{client_event_id,
+    # reason}]}. Se conserva la lectura de la forma antigua {"results":[…]} (stubs/beta).
+    # Aceptado o duplicado => entregado, se borra. Rechazado POR ELEMENTO (fuera de catálogo
+    # o payload inválido) => reenviarlo es inútil: se aparta a rejected/ con su razón en
+    # stderr. Sin mención => se conserva para el próximo despacho (nunca se asume aceptado
+    # en silencio: perder un checkpoint/verdict/submit sin confirmación real viola la cota).
+    python3 - "$resp" "$dir/rejected" "${files[@]}" <<'PY'
 import json,sys,os
 resp=json.loads(sys.argv[1])
-paths=sys.argv[2:]
-results={r.get("client_event_id"):r.get("status") for r in resp.get("results",[])}
+rejected_dir=sys.argv[2]
+paths=sys.argv[3:]
+status={}
+reasons={}
+if isinstance(resp,dict) and "results" in resp:
+    for r in resp.get("results") or []:
+        status[r.get("client_event_id")]=r.get("status")
+elif isinstance(resp,dict):
+    for cid in resp.get("accepted") or []:
+        status[cid]="accepted"
+    for cid in resp.get("duplicates") or []:
+        status[cid]="accepted"
+    for r in resp.get("rejected") or []:
+        cid=r.get("client_event_id")
+        status[cid]="rejected"
+        reasons[cid]=r.get("reason") or "sin razón"
 for p in paths:
     try:
         cid=json.load(open(p)).get("client_event_id")
     except Exception:
         continue
-    # Sin mención en `results` => se conserva para el próximo despacho (nunca se asume
-    # aceptado en silencio: perder un checkpoint/verdict/submit sin confirmación real
-    # viola el contrato de la cota, Task 8).
-    st=results.get(cid)
-    if st in ("accepted","rejected"):
+    st=status.get(cid)
+    if st=="accepted":
         try: os.unlink(p)
         except OSError: pass
+    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)
+        try:
+            os.makedirs(rejected_dir,exist_ok=True)
+            os.replace(p, os.path.join(rejected_dir, os.path.basename(p)))
+        except OSError:
+            pass
 PY
     rm -f "$state_file"
     return 0
   fi
 
+  # [#37] Un 4xx del LOTE (salvo 408/429) es un rechazo del contrato, no red caída:
+  # reintentarlo para siempre solo repite el mismo error y el usuario cree que reportó.
+  # Se loggea el cuerpo, el lote entero se aparta a rejected/ y NO se agenda backoff.
+  # 408 (timeout) y 429 (rate-limit) siguen siendo transitorios, igual que 5xx y 000.
+  case "$status" in
+    408|429) : ;;
+    4*)
+      local rejected_dir f
+      rejected_dir="$dir/rejected"
+      mkdir -p "$rejected_dir"
+      echo "⛔ el hub rechazó el lote de eventos (HTTP $status): $resp" >&2
+      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
+      for f in "${files[@]}"; do
+        mv "$f" "$rejected_dir/" 2>/dev/null
+      done
+      rm -f "$state_file"
+      return 1
+      ;;
+  esac
+
   local schedule idx max_idx delay
   read -ra schedule <<< "$RUNTIME_OUTBOX_BACKOFF_SCHEDULE"
   idx=$attempt