@trycore/spec-build-harness 0.8.5 → 0.11.0

package/dist/lib/normalize.js

@@ -0,0 +1,1123 @@
+// normalize.ts — normaliza el build-state.json legacy a la forma de eventos
+// del catálogo v2 que exige POST /orchestrator/projects/{id}/import/bundle
+// (docs/superpowers/specs/2026-08-20-cliente-migrate-normalizacion-eventos-design.md).
+//
+// Catálogo v2 e invariantes embebidos desde trycore-ia-hub/backend/app/modules/
+// orchestrator/ (event_catalog.py, domain.py, release_domain.py,
+// release_gate_domain.py, front_domain.py, project_facts_domain.py,
+// import_service.py), re-verificados 2026-08-28 contra el import real del primer piloto real
+// (issue #40). Si el catálogo del hub cambia, esta copia se desincroniza — no
+// hay forma de importarlo en build-time entre repos distintos.
+export const PHASE_ORDER = [
+    'dor', 'change', 'red', 'green', 'refactor', 'smoke', 'api', 'data', 'dod', 'pr', 'archived',
+];
+/** Gates del inner loop que el reducer del slice acepta (hub domain.py:130-133);
+ * cualquier otro nombre revienta con «gate desconocido» (domain.py:422). */
+export const SLICE_GATES = [
+    'dor', 'coherence_link', 'tdd', 'journey_smoke', 'fidelity',
+    'api', 'data', 'wiring_verified', 'dod',
+];
+/** Los seis gates del Release Gate (hub release_gate_domain.py:20-22). El
+ * import del hub no los valida por nombre, pero `estado_de_gates` solo itera
+ * estos seis: un gate ajeno sería una fila muerta que nadie audita. */
+export const RELEASE_GATES = [
+    'security', 'smell', 'ux', 'coherence', 'stack_arch', 'integration',
+];
+/** `_MAX_NOTE` del catálogo del hub (event_catalog.py:37): todo campo de texto
+ * libre (note/evidence/cause/reason/summary/motivo) rechaza con
+ * `string_too_long` por encima de 2000 caracteres. */
+export const MAX_NOTE = 2000;
+const TRUNCATION_MARKER = ' … [truncado por migración]';
+/** Trunca una nota al límite del hub conservando un marcador de truncado
+ * (defecto 5 del primer piloto real: 6 entradas rechazadas por `string_too_long`). */
+export function truncateNote(text) {
+    if (text.length <= MAX_NOTE)
+        return text;
+    return text.slice(0, MAX_NOTE - TRUNCATION_MARKER.length) + TRUNCATION_MARKER;
+}
+// Evidencia ACUÑADA de migración: el invariante 3 del hub (domain.py:424-425 y
+// 452-453) exige evidence en todo veredicto/wiring passing, también en el
+// histórico (validar_secuencia usa el reducer real, import_domain.py:126-172).
+// El build-state.json legacy solo guarda booleanos, así que la evidencia
+// declara honestamente su origen en vez de inventar una ejecución.
+export const MIGRATION_GATE_EVIDENCE = 'veredicto original true en build-state.json del harness legacy; detalle en la nota del slice (evidencia acuñada por trycore-build migrate)';
+export const MIGRATION_WIRING_EVIDENCE = 'status passing en build-state.json del harness legacy, sin evidencia textual registrada (acuñada por trycore-build migrate)';
+export const MIGRATION_RELEASE_EVIDENCE = 'veredicto original true en releases[] de build-state.json del harness legacy (evidencia acuñada por trycore-build migrate)';
+/** Tipos que ESTE normalizador emite por agregado (subset de lo que valida el
+ * hub). Lo usa `validateNormalizedBundle` como red contra bugs del emisor. */
+export const EVENT_TYPES_BY_AGGREGATE = {
+    slice: new Set([
+        'slice_opened', 'phase_advanced', 'gate_verdict', 'wiring_checklist_seeded',
+        'wiring_item_updated', 'progress_noted', 'slice_archived', 'slice_parked',
+        'slice_escalated', 'slice_cancelled',
+    ]),
+    release: new Set(['release_opened', 'release_gate_verdict', 'release_closed']),
+    front: new Set(['front_opened', 'front_member_added', 'front_drained', 'front_closed']),
+};
+const SECOND_MS = 1000;
+const EPOCH_ISO = new Date(0).toISOString();
+function toIso(value, fallback) {
+    if (typeof value === 'string') {
+        const d = new Date(value);
+        if (!Number.isNaN(d.getTime()))
+            return d.toISOString();
+    }
+    return fallback;
+}
+function ensureStrictlyIncreasing(events) {
+    let prevMs = -Infinity;
+    return events.map((ev) => {
+        let ms = new Date(ev.occurred_at).getTime();
+        if (Number.isNaN(ms) || ms <= prevMs)
+            ms = prevMs === -Infinity ? Date.parse(EPOCH_ISO) : prevMs + SECOND_MS;
+        prevMs = ms;
+        return { ...ev, occurred_at: new Date(ms).toISOString() };
+    });
+}
+function firstNonBlankString(...values) {
+    for (const v of values) {
+        if (typeof v === 'string' && v.trim() !== '')
+            return v;
+    }
+    return null;
+}
+function hasArchivedAs(entry) {
+    return typeof entry.archived_as === 'string' && entry.archived_as.trim() !== '';
+}
+function closingKind(entry) {
+    // Defecto 3 (EP-039): `archived_as` presente ⇒ el slice CERRÓ aunque falte
+    // `phase` — sin el cierre completo queda «en construcción» en el hub,
+    // reclamable por la cola e irreversible tras el import (el guard
+    // anti-superposición, import_domain.py:175-192, rechaza re-importarlo).
+    if (entry.phase === 'archived' || hasArchivedAs(entry))
+        return 'archived';
+    // Defecto 4 (EP-037): el estado legacy aparca con `phase: "parked"`; el hub
+    // lo modela como status con su evento propio `slice_parked` (event_catalog.py:156-158).
+    if (entry.phase === 'parked' || entry.status === 'parked')
+        return 'parked';
+    if (entry.status === 'cancelled' || entry.phase === 'cancelled')
+        return 'cancelled';
+    return null;
+}
+/** Hasta qué índice de fase avanza esta entrada. `archived`/`archived_as`
+ * avanzan hasta `pr`: `slice_archived` exige estar en pr (domain.py:499-500). */
+function pipelineTargetIdx(entry) {
+    const phase = typeof entry.phase === 'string' ? entry.phase : null;
+    if (phase && PHASE_ORDER.includes(phase)) {
+        return phase === 'archived' ? PHASE_ORDER.indexOf('pr') : PHASE_ORDER.indexOf(phase);
+    }
+    if (hasArchivedAs(entry))
+        return PHASE_ORDER.indexOf('pr');
+    return -1;
+}
+function openingEvent(entry, epicCode) {
+    return {
+        event_type: 'slice_opened',
+        payload: { epic_code: epicCode },
+        occurred_at: toIso(entry.updated_at, EPOCH_ISO),
+    };
+}
+function phaseAdvancedEvents(entry, state) {
+    const target = pipelineTargetIdx(entry);
+    if (target <= state.phaseIdx)
+        return [];
+    const anchor = toIso(entry.updated_at, EPOCH_ISO);
+    const events = [];
+    for (let i = state.phaseIdx + 1; i <= target; i++) {
+        events.push({ event_type: 'phase_advanced', payload: { to: PHASE_ORDER[i] }, occurred_at: anchor });
+    }
+    state.phaseIdx = target;
+    return events;
+}
+function degradedGateNote(gate, reason, anchor) {
+    return {
+        event_type: 'progress_noted',
+        payload: {
+            note: truncateNote(`[migración] gate "${gate}"=true en build-state.json legacy no importable como veredicto: ${reason} — conservado como nota`),
+        },
+        occurred_at: anchor,
+    };
+}
+function gateVerdictEvents(entry, epicCode, state, warnings) {
+    const gates = entry.gates && typeof entry.gates === 'object' ? entry.gates : {};
+    const anchor = toIso(entry.updated_at, EPOCH_ISO);
+    const events = [];
+    // Orden CANÓNICO del catálogo, no el del objeto legacy: wiring_verified va
+    // antes que dod en SLICE_GATES, que es justo lo que el invariante 4 exige.
+    for (const gate of SLICE_GATES) {
+        if (gates[gate] !== true)
+            continue;
+        if (gate === 'dod' && !state.gatesTrue.has('wiring_verified')) {
+            // Invariante 4 del hub (domain.py:427-428): dod PASS sin wiring_verified
+            // cerrado rechaza la ENTRADA entera. Se degrada solo el veredicto, sin
+            // acuñar un wiring_verified que nunca corrió (eso sería forjar un
+            // veredicto, no acuñar evidencia).
+            events.push(degradedGateNote('dod', 'wiring_verified nunca cerró en este slice (invariante 4 del hub)', anchor));
+            warnings.push(`history[${epicCode}]: dod=true sin wiring_verified — degradado a progress_noted (invariante 4 del hub); el gate dod queda abierto en el hub`);
+            continue;
+        }
+        events.push({
+            event_type: 'gate_verdict',
+            payload: { gate, verdict: 'PASS', evidence: MIGRATION_GATE_EVIDENCE },
+            occurred_at: anchor,
+        });
+        state.gatesTrue.add(gate);
+    }
+    // Defecto 8: gates legacy fuera del catálogo (caso real: `change`) revientan
+    // con «gate desconocido» (domain.py:422). Se degradan a progress_noted
+    // preservando el dato — nada se pierde, nada se forja.
+    for (const [gate, value] of Object.entries(gates)) {
+        if (value !== true || SLICE_GATES.includes(gate))
+            continue;
+        events.push(degradedGateNote(gate, 'no existe en el catálogo de gates del slice del hub', anchor));
+        warnings.push(`history[${epicCode}]: gate legacy "${gate}" fuera del catálogo del hub (${SLICE_GATES.join(', ')}) — degradado a progress_noted`);
+    }
+    return events;
+}
+/** Defecto 7 (EP-038): los estados legacy nombran el ítem con `item_id`, `id`
+ * o `item` según la era; item_id vacío revienta en el reducer (domain.py:450). */
+function resolveWiringItemId(item) {
+    return String(firstNonBlankString(item.item_id, item.id, item.item) ?? '').trim();
+}
+function wiringEvents(entry, epicCode, state, warnings, unmapped) {
+    const checklist = Array.isArray(entry.wiring_checklist) ? entry.wiring_checklist : [];
+    if (checklist.length === 0)
+        return [];
+    const anchor = toIso(entry.updated_at, EPOCH_ISO);
+    const events = [];
+    const resolved = [];
+    checklist.forEach((rawItem, j) => {
+        const item = typeof rawItem === 'object' && rawItem !== null ? rawItem : {};
+        const id = resolveWiringItemId(item);
+        if (!id) {
+            warnings.push(`history[${epicCode}]: wiring_checklist[${j}] sin item_id/id/item resolvible — cae a unmapped (el hub exige item_id, domain.py:450)`);
+            unmapped.push({ source_key: `history[${epicCode}].wiring_checklist[${j}]`, original: rawItem, occurred_at: anchor });
+            return;
+        }
+        resolved.push({ id, item });
+    });
+    // La siembra solo declara ítems NUEVOS de la secuencia fusionada: re-sembrar
+    // un ítem lo devolvería a failing en el fold del hub (domain.py:471-484)
+    // pisando un passing anterior. Al menos un ítem (event_catalog.py:125).
+    const fresh = resolved.filter(({ id }) => !state.seededItemIds.has(id));
+    if (fresh.length > 0) {
+        events.push({
+            event_type: 'wiring_checklist_seeded',
+            payload: {
+                items: fresh.map(({ id, item }) => ({
+                    item_id: id,
+                    kind: String(item.kind ?? 'unknown'),
+                    ref: String(item.ref ?? ''),
+                })),
+            },
+            occurred_at: anchor,
+        });
+        fresh.forEach(({ id }) => state.seededItemIds.add(id));
+    }
+    for (const { id, item } of resolved) {
+        if (typeof item.status !== 'string')
+            continue;
+        const payload = { item_id: id, status: item.status };
+        const originalEvidence = firstNonBlankString(item.evidence);
+        if (item.status === 'passing') {
+            // Invariante 3 sobre wiring (domain.py:452-453): passing ⇒ evidence.
+            payload.evidence = originalEvidence ? truncateNote(originalEvidence) : MIGRATION_WIRING_EVIDENCE;
+        }
+        else if (originalEvidence) {
+            payload.evidence = truncateNote(originalEvidence);
+        }
+        events.push({ event_type: 'wiring_item_updated', payload, occurred_at: anchor });
+    }
+    return events;
+}
+function progressNotedEvents(entry) {
+    const log = Array.isArray(entry.progress_log) ? entry.progress_log : [];
+    const fallback = toIso(entry.updated_at, EPOCH_ISO);
+    return log
+        .filter((p) => typeof p === 'object' && p !== null && typeof p.note === 'string')
+        .map((p) => ({
+        event_type: 'progress_noted',
+        // Defecto 5: notas >2000 revientan con string_too_long (_MAX_NOTE,
+        // event_catalog.py:37 y 134-135) — se truncan con marcador.
+        payload: { note: truncateNote(p.note) },
+        occurred_at: toIso(p.at, fallback),
+    }));
+}
+function closingEvents(entry, state) {
+    const anchor = toIso(entry.updated_at, EPOCH_ISO);
+    const kind = closingKind(entry);
+    if (kind === 'archived') {
+        // slice_archived exige phase pr (domain.py:499-500); si el cuerpo no llegó
+        // (p. ej. archived_as sin phase con datos raros), se completa aquí.
+        const events = [];
+        const prIdx = PHASE_ORDER.indexOf('pr');
+        for (let i = state.phaseIdx + 1; i <= prIdx; i++) {
+            events.push({ event_type: 'phase_advanced', payload: { to: PHASE_ORDER[i] }, occurred_at: anchor });
+        }
+        state.phaseIdx = Math.max(state.phaseIdx, prIdx);
+        events.push({ event_type: 'slice_archived', payload: {}, occurred_at: anchor });
+        return events;
+    }
+    if (kind === 'parked') {
+        // slice_parked exige reason no vacía (domain.py:372-373) y ≤2000
+        // (event_catalog.py:156-158).
+        const reason = firstNonBlankString(entry.reason, entry.parked_reason, entry.notes)
+            ?? 'sin motivo registrado en build-state.json legacy (migración)';
+        return [{ event_type: 'slice_parked', payload: { reason: truncateNote(reason) }, occurred_at: anchor }];
+    }
+    if (kind === 'cancelled') {
+        // Cancelar exige pasar por ESCALATED (domain.py:393-394): el estado legacy
+        // cancelaba directo, así que se emite la escalada intermedia con su causa.
+        const cause = firstNonBlankString(entry.reason, entry.notes)
+            ?? 'cancelado en el harness legacy sin causa registrada (migración)';
+        return [
+            { event_type: 'slice_escalated', payload: { cause: truncateNote(cause) }, occurred_at: anchor },
+            { event_type: 'slice_cancelled', payload: {}, occurred_at: anchor },
+        ];
+    }
+    return [];
+}
+/**
+ * Fusiona todas las entradas de `history[]` de UNA épica en una sola secuencia
+ * continua: un único slice_opened al inicio, un único cierre al final (de la
+ * entrada de MAYOR índice, nunca por updated_at — spec §6.1). El reducer del
+ * servidor prohíbe reabrir un slice tras un cierre, así que las entradas
+ * intermedias solo aportan su cuerpo (fases/gates/wiring/progreso), sin abrir
+ * ni cerrar; las fases NUNCA se re-avanzan (orden estricto, domain.py:404-406).
+ */
+export function normalizeHistoryGroup(epicCode, entries, warnings = [], unmapped = []) {
+    const objs = entries.filter((e) => typeof e === 'object' && e !== null && !Array.isArray(e));
+    if (objs.length === 0)
+        return null;
+    const state = { phaseIdx: 0, gatesTrue: new Set(), seededItemIds: new Set() };
+    const events = [openingEvent(objs[0], epicCode)];
+    objs.forEach((entry, i) => {
+        if (hasArchivedAs(entry) && entry.phase !== 'archived') {
+            warnings.push(`history[${epicCode}]: archived_as presente sin phase "archived" — se emite el cierre completo (fases hasta pr + slice_archived); sin él, el slice quedaría reclamable en el hub y el import es irreversible (guard anti-superposición)`);
+        }
+        events.push(...phaseAdvancedEvents(entry, state));
+        events.push(...gateVerdictEvents(entry, epicCode, state, warnings));
+        events.push(...wiringEvents(entry, epicCode, state, warnings, unmapped));
+        events.push(...progressNotedEvents(entry));
+        if (i === objs.length - 1)
+            events.push(...closingEvents(entry, state));
+    });
+    return { epic_code: epicCode, events: ensureStrictlyIncreasing(events), normalized: true };
+}
+/**
+ * Agrupa history[] por épica preservando el ORDEN DE ÍNDICE de aparición
+ * (nunca por updated_at — spec §6.1) y fusiona cada grupo en una entrada.
+ * La clave legacy `epic` se mapea con warning explícito (dentro de una entrada
+ * de history solo puede significar el código de épica — riesgo de falso
+ * positivo acotado y visible); sin clave reconocible cae a unmapped con warning.
+ */
+export function normalizeHistory(historyRaw) {
+    const groups = new Map();
+    const order = [];
+    const unmapped = [];
+    const warnings = [];
+    historyRaw.forEach((raw, i) => {
+        const obj = typeof raw === 'object' && raw !== null && !Array.isArray(raw) ? raw : null;
+        let epicCode = obj && typeof obj.epica === 'string' && obj.epica !== '' ? obj.epica : null;
+        if (!epicCode && obj && typeof obj.epic === 'string' && obj.epic !== '') {
+            epicCode = obj.epic;
+            warnings.push(`history[${i}]: clave legacy "epic" — la clave esperada es "epica"; entrada mapeada a la épica "${obj.epic}"`);
+        }
+        if (!epicCode) {
+            warnings.push(`history[${i}]: sin clave "epica" (ni la legacy "epic") reconocible — la entrada cae a unmapped`);
+            unmapped.push({ source_key: `history[${i}]`, original: raw, occurred_at: toIso(obj?.updated_at, EPOCH_ISO) });
+            return;
+        }
+        if (!groups.has(epicCode)) {
+            groups.set(epicCode, []);
+            order.push(epicCode);
+        }
+        groups.get(epicCode).push(obj);
+    });
+    const entries = [];
+    for (const epicCode of order) {
+        const merged = normalizeHistoryGroup(epicCode, groups.get(epicCode), warnings, unmapped);
+        if (merged)
+            entries.push(merged);
+    }
+    return { entries, unmapped, warnings };
+}
+/** Plantilla del ACTA del workaround del piloto: honesta sobre el origen y
+ * sobre por qué los gates quedan sin declarar. */
+export const PRE_HARNESS_ACTA = 'ACTA de migración (pre-arnés): épica construida antes de instalar el arnés; '
+    + 'verificación agregada (suite en verde + comportamiento en producción), gates sin declarar '
+    + 'a propósito — la distinción frente a las épicas archivadas con gates cerrados es deliberada. '
+    + 'Declarada por el humano en la lista de trycore-build migrate --pre-harness.';
+/**
+ * Parsea y valida el fichero de --pre-harness: `{"epics": [{"code", "note"?}],
+ * "as_of"?}`. Estricto con las claves (una lista confirmada por un humano no
+ * admite typos silenciosos) y con duplicados. `as_of` opcional ancla los
+ * timestamps sintéticos; sin él se usa epoch — NUNCA el reloj (la
+ * normalización es determinista, misma regla que el resto de este fichero).
+ */
+export function parsePreHarnessList(raw) {
+    const errors = [];
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return { list: null, errors: ['el fichero pre-arnés no es un objeto JSON (forma esperada: {"epics": [{"code": "EP-001", "note": "…"}]})'] };
+    }
+    const obj = raw;
+    for (const key of Object.keys(obj)) {
+        if (key !== 'epics' && key !== 'as_of') {
+            errors.push(`clave desconocida en la raíz: "${key}" (solo se admiten "epics" y "as_of")`);
+        }
+    }
+    if (!Array.isArray(obj.epics)) {
+        errors.push('falta "epics" (array de épicas confirmadas por el humano)');
+        return { list: null, errors };
+    }
+    if (obj.epics.length === 0) {
+        errors.push('la lista "epics" está vacía — declara al menos una épica pre-arnés (o no uses --pre-harness)');
+    }
+    let asOf = EPOCH_ISO;
+    if (obj.as_of !== undefined) {
+        const d = typeof obj.as_of === 'string' ? new Date(obj.as_of) : new Date(NaN);
+        if (Number.isNaN(d.getTime())) {
+            errors.push(`"as_of" no es una fecha ISO válida: ${JSON.stringify(obj.as_of)}`);
+        }
+        else {
+            asOf = d.toISOString();
+        }
+    }
+    const epics = [];
+    const seen = new Set();
+    obj.epics.forEach((rawEpic, i) => {
+        if (typeof rawEpic !== 'object' || rawEpic === null || Array.isArray(rawEpic)) {
+            errors.push(`epics[${i}] no es un objeto (forma esperada: {"code": "EP-001", "note": "…"})`);
+            return;
+        }
+        const epic = rawEpic;
+        for (const key of Object.keys(epic)) {
+            if (key !== 'code' && key !== 'note') {
+                errors.push(`epics[${i}]: clave desconocida "${key}" (solo se admiten "code" y "note")`);
+            }
+        }
+        const code = typeof epic.code === 'string' ? epic.code.trim() : '';
+        if (!code) {
+            errors.push(`epics[${i}]: "code" vacío o ausente`);
+            return;
+        }
+        if (seen.has(code)) {
+            errors.push(`epics[${i}]: código duplicado en la lista: "${code}"`);
+            return;
+        }
+        seen.add(code);
+        let note;
+        if (epic.note !== undefined) {
+            if (typeof epic.note !== 'string' || epic.note.trim() === '') {
+                errors.push(`epics[${i}] (${code}): "note" debe ser texto no vacío — omítela si no aplica`);
+            }
+            else {
+                note = epic.note;
+            }
+        }
+        epics.push({ code, ...(note !== undefined ? { note } : {}) });
+    });
+    if (errors.length > 0)
+        return { list: null, errors };
+    return { list: { epics, asOf }, errors };
+}
+/**
+ * Genera la entrada de historia sintética de UNA épica pre-arnés: el patrón
+ * exacto del workaround — `slice_opened` → `phase_advanced` por cada fase
+ * hasta `pr` → `progress_noted` con el ACTA (incorporando la nota del humano
+ * si viene) → `slice_archived`. SIN `gate_verdict` alguno: declarar gates que
+ * nunca corrieron sería forjar veredictos, no migrar historia. Timestamps
+ * anclados en `anchorIso` y espaciados por `ensureStrictlyIncreasing` —
+ * deterministas, sin reloj.
+ */
+export function normalizePreHarnessEpic(epic, anchorIso) {
+    const events = [
+        { event_type: 'slice_opened', payload: { epic_code: epic.code }, occurred_at: anchorIso },
+    ];
+    const prIdx = PHASE_ORDER.indexOf('pr');
+    for (let i = 1; i <= prIdx; i++) {
+        events.push({ event_type: 'phase_advanced', payload: { to: PHASE_ORDER[i] }, occurred_at: anchorIso });
+    }
+    const acta = epic.note ? `${PRE_HARNESS_ACTA} Nota del humano: ${epic.note}` : PRE_HARNESS_ACTA;
+    events.push({ event_type: 'progress_noted', payload: { note: truncateNote(acta) }, occurred_at: anchorIso });
+    events.push({ event_type: 'slice_archived', payload: {}, occurred_at: anchorIso });
+    return { epic_code: epic.code, events: ensureStrictlyIncreasing(events), normalized: true };
+}
+// ─── releases[] → agregado `release` ──────────────────────────────────────────
+function releaseEvents(release, key, warnings) {
+    const anchor = toIso(release.created_at, EPOCH_ISO);
+    const epicCodes = Array.isArray(release.epicas) ? release.epicas.map(String) : [];
+    const events = [
+        { event_type: 'release_opened', payload: { release_line: key, epic_codes: epicCodes }, occurred_at: anchor },
+    ];
+    const unmapped = [];
+    const gates = release.gates && typeof release.gates === 'object' ? release.gates : {};
+    for (const [gate, verdict] of Object.entries(gates)) {
+        if (!RELEASE_GATES.includes(gate)) {
+            warnings.push(`releases[${key}]: gate "${gate}" fuera del Release Gate del hub (${RELEASE_GATES.join(', ')}) — preservado en unmapped`);
+            unmapped.push({ source_key: `releases[${key}].gates[${gate}]`, original: { gate, value: verdict }, occurred_at: anchor });
+            continue;
+        }
+        const payload = { gate, verdict: verdict === true ? 'PASS' : 'FAIL' };
+        // Defecto 6: el fold del hub degrada PASS-sin-evidencia a BLOQUEANTE
+        // (release_gate_domain.py:93-96), irreparable retroactivamente — misma
+        // acuñación de evidencia de migración que en los gates del slice.
+        if (verdict === true)
+            payload.evidence = MIGRATION_RELEASE_EVIDENCE;
+        events.push({ event_type: 'release_gate_verdict', payload, occurred_at: anchor });
+    }
+    if (release.status === 'failed' || release.status === 'passed') {
+        events.push({
+            event_type: 'release_closed',
+            payload: { status: release.status === 'failed' ? 'FAILED' : 'PASSED', epic_codes: epicCodes },
+            occurred_at: anchor,
+        });
+    }
+    const notes = Array.isArray(release.notes) ? release.notes : [];
+    notes.forEach((note, i) => {
+        unmapped.push({ source_key: `releases[${key}].notes[${i}]`, original: note, occurred_at: anchor });
+    });
+    return { events: ensureStrictlyIncreasing(events), unmapped };
+}
+/** `notes[]` de un release no tiene tipo en el catálogo del agregado `release`
+ * (event_catalog.py no declara ninguno) — se preserva en `unmapped[]` en vez
+ * de descartarse (spec §7: "nada se pierde, nada bloquea"). La clave legacy
+ * `release` se mapea a `release_id` con warning explícito; una entrada sin
+ * ninguna de las dos cae a unmapped con warning, nunca en silencio. */
+export function normalizeReleases(releasesRaw) {
+    const entries = [];
+    const unmapped = [];
+    const warnings = [];
+    releasesRaw.forEach((raw, i) => {
+        const obj = typeof raw === 'object' && raw !== null && !Array.isArray(raw) ? raw : null;
+        let key = obj && typeof obj.release_id === 'string' && obj.release_id !== '' ? obj.release_id : null;
+        if (!key && obj && typeof obj.release === 'string' && obj.release !== '') {
+            key = obj.release;
+            warnings.push(`releases[${i}]: clave legacy "release" — la clave esperada es "release_id"; entrada mapeada a "${obj.release}"`);
+        }
+        if (!obj || !key) {
+            warnings.push(`releases[${i}]: sin clave "release_id" (ni la legacy "release") reconocible — la entrada cae a unmapped`);
+            unmapped.push({ source_key: `releases[${i}]`, original: raw, occurred_at: toIso(obj?.created_at, EPOCH_ISO) });
+            return;
+        }
+        const { events, unmapped: relUnmapped } = releaseEvents(obj, key, warnings);
+        entries.push({ key, events, normalized: true });
+        unmapped.push(...relUnmapped);
+    });
+    return { entries, unmapped, warnings };
+}
+// ─── parallel_front → agregado `front` ────────────────────────────────────────
+export function normalizeFront(frontRaw, warnings = [], unmapped = []) {
+    if (typeof frontRaw !== 'object' || frontRaw === null)
+        return null;
+    const front = frontRaw;
+    const anchor = toIso(front.opened_at, EPOCH_ISO);
+    const members = Array.isArray(front.members) ? front.members : [];
+    const events = [
+        {
+            event_type: 'front_opened',
+            payload: {
+                members: members.map((m) => String(m.epica ?? '')),
+                merge_order: Array.isArray(front.merge_order) ? front.merge_order : [],
+                asignaciones: members.map((m) => ({
+                    epic_code: String(m.epica ?? ''),
+                    worktree: String(m.worktree ?? ''),
+                    assignee: String(m.assignee ?? ''),
+                })),
+            },
+            occurred_at: anchor,
+        },
+    ];
+    if (front.status === 'drained') {
+        events.push({ event_type: 'front_drained', payload: {}, occurred_at: anchor });
+    }
+    else if (front.status === 'closed') {
+        // front_closed exige DRAINING previo Y todos los miembros integrados con
+        // front_member_integrated (front_domain.py:382-398); el estado legacy no
+        // registra esas integraciones y forjarlas inventaría merges. Se importa
+        // hasta DRAINING y el cierre queda preservado en unmapped.
+        events.push({ event_type: 'front_drained', payload: {}, occurred_at: anchor });
+        warnings.push('parallel_front: status "closed" no importable sin las integraciones por miembro que exige el hub (front_domain.py:387-398) — se importa hasta DRAINING; el cierre queda en unmapped');
+        unmapped.push({ source_key: 'parallel_front.status', original: 'closed', occurred_at: anchor });
+    }
+    return { key: 'parallel_front', events: ensureStrictlyIncreasing(events), normalized: true };
+}
+// ─── hechos de proyecto → agregado `project` ──────────────────────────────────
+// Catálogo de hechos del hub (project_facts_domain.py:27-37, FACT_A_COLUMNA):
+// un `fact` fuera de esta lista se rechaza por entrada (import_service.py:449-453).
+const HUB_FACT_RULES = {
+    project_kind: { kind: 'machine_text', max: 20 },
+    harness_phase: { kind: 'machine_text', max: 50 },
+    foundation: { kind: 'boolean' },
+    scaffold_confirmed: { kind: 'boolean' },
+    design_source_confirmed: { kind: 'boolean' },
+    design_source_ref: { kind: 'string_or_null' },
+};
+function confirmedBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'object' && value !== null && typeof value.confirmed === 'boolean') {
+        return value.confirmed;
+    }
+    return null;
+}
+function confirmedAt(value, fallback) {
+    if (typeof value === 'object' && value !== null)
+        return toIso(value.confirmed_at, fallback);
+    return fallback;
+}
+/** Mapea los hechos del build-state.json legacy al catálogo del hub
+ * (FACT_A_COLUMNA): `scaffold.confirmed`→`scaffold_confirmed`,
+ * `design_source.{confirmed,source}`→`design_source_{confirmed,ref}`. Lo que
+ * el hub no conoce (`project_kind_source`) cae a unmapped con warning en vez
+ * de viajar y rechazarse como «hecho de proyecto desconocido». Busca cada
+ * clave en la raíz y, si falta, en `raw.facts` (forma de estados intermedios). */
+export function normalizeFacts(raw, fallbackAt, warnings = [], unmapped = []) {
+    const nested = raw.facts && typeof raw.facts === 'object' && !Array.isArray(raw.facts)
+        ? raw.facts
+        : {};
+    const lookup = (key) => (key in raw ? raw[key] : nested[key]);
+    const has = (key) => key in raw || key in nested;
+    const facts = [];
+    const push = (fact, value, occurredAt) => {
+        facts.push({ fact, value, occurred_at: occurredAt, normalized: true });
+    };
+    const drop = (key, value, reason) => {
+        warnings.push(`facts: "${key}" ${reason} — cae a unmapped`);
+        unmapped.push({ source_key: `facts[${key}]`, original: value, occurred_at: fallbackAt });
+    };
+    for (const key of ['project_kind', 'harness_phase']) {
+        if (!has(key))
+            continue;
+        const value = lookup(key);
+        if (value === null || value === undefined)
+            continue;
+        const max = HUB_FACT_RULES[key].max;
+        if (typeof value !== 'string' || value === '' || value.length > max) {
+            drop(key, value, `no cabe en su columna del hub (texto no vacío de hasta ${max} caracteres, project_facts_domain.py:58-62)`);
+            continue;
+        }
+        push(key, value, fallbackAt);
+    }
+    if (has('foundation')) {
+        const value = lookup('foundation');
+        const confirmed = confirmedBoolean(value);
+        if (confirmed === null) {
+            if (value !== null && value !== undefined) {
+                drop('foundation', value, 'no es booleano ni trae confirmed booleano (el hub exige booleano, project_facts_domain.py:56-57)');
+            }
+        }
+        else {
+            push('foundation', confirmed, confirmedAt(value, fallbackAt));
+        }
+    }
+    if (has('scaffold')) {
+        const value = lookup('scaffold');
+        const confirmed = confirmedBoolean(value);
+        if (confirmed === null) {
+            if (value !== null && value !== undefined)
+                drop('scaffold', value, 'sin confirmed booleano mapeable a scaffold_confirmed');
+        }
+        else {
+            push('scaffold_confirmed', confirmed, confirmedAt(value, fallbackAt));
+        }
+    }
+    if (has('design_source')) {
+        const value = lookup('design_source');
+        const confirmed = confirmedBoolean(value);
+        const at = confirmedAt(value, fallbackAt);
+        if (confirmed !== null)
+            push('design_source_confirmed', confirmed, at);
+        const ref = typeof value === 'object' && value !== null
+            ? firstNonBlankString(value.source, value.ref)
+            : null;
+        if (ref)
+            push('design_source_ref', ref, at);
+        if (confirmed === null && !ref && value !== null && value !== undefined) {
+            drop('design_source', value, 'sin confirmed booleano ni source mapeables');
+        }
+    }
+    if (has('project_kind_source')) {
+        const value = lookup('project_kind_source');
+        if (value !== null && value !== undefined) {
+            drop('project_kind_source', value, 'no existe en el catálogo de hechos del hub (FACT_A_COLUMNA, project_facts_domain.py:27-37)');
+        }
+    }
+    return facts;
+}
+// ─── validación local del emisor (red contra bugs del normalizador) ───────────
+function checkSequence(errors, aggregate, key, events) {
+    if (events.length === 0)
+        errors.push(`${key}: sin eventos`);
+    for (const ev of events) {
+        if (!EVENT_TYPES_BY_AGGREGATE[aggregate].has(ev.event_type)) {
+            errors.push(`${key}: event_type "${ev.event_type}" no existe en el catálogo del agregado "${aggregate}"`);
+        }
+        if (Number.isNaN(new Date(ev.occurred_at).getTime())) {
+            errors.push(`${key}: occurred_at inválido: "${ev.occurred_at}"`);
+        }
+    }
+}
+/** Validación local previa al volcado (spec §9): mismo catálogo que valida el
+ * servidor, sin replicar la forma de payload campo a campo (eso lo cubre
+ * `verifyNormalizedBundle`, que sí re-implementa los invariantes del hub). */
+export function validateNormalizedBundle(bundle) {
+    const errors = [];
+    bundle.history.forEach((h) => checkSequence(errors, 'slice', `history[${h.epic_code}]`, h.events));
+    bundle.releases.forEach((r) => checkSequence(errors, 'release', `releases[${r.key}]`, r.events));
+    bundle.fronts.forEach((f) => checkSequence(errors, 'front', `fronts[${f.key}]`, f.events));
+    return errors;
+}
+// ─── verify: los invariantes del hub, offline (migrate --verify) ──────────────
+//
+// Réplica en seco de lo que el hub aplica en el import (`validar_secuencia`
+// conduce el reducer REAL de cada agregado, import_domain.py:126-172): la misma
+// entrada que rechazaría el servidor debe salir aquí ANTES de entregar el
+// bundle al ADMIN. Cada regla cita el punto del hub que la exige.
+/** Tipos por agregado tal como los declara el hub (event_catalog.py:522-594,
+ * TIPOS_POR_AGREGADO) — la enumeración del catálogo es cerrada. */
+const HUB_TYPES = {
+    slice: new Set([
+        'slice_opened', 'slice_claimed', 'phase_advanced', 'phase_reverted', 'gate_verdict',
+        'wiring_item_updated', 'wiring_checklist_seeded', 'checkpoint_recorded', 'progress_noted',
+        'handoff_recorded', 'slice_submitted', 'slice_archived', 'slice_reflected', 'slice_parked',
+        'slice_resumed', 'slice_escalated', 'slice_requeued', 'slice_cancelled', 'lease_renewed',
+        'lease_expired', 'lease_reaped', 'context_drift_detected', 'context_synced',
+    ]),
+    release: new Set(['release_opened', 'release_gate_verdict', 'release_closed']),
+    front: new Set(['front_opened', 'front_member_added', 'front_member_integrated', 'front_drained', 'front_closed']),
+};
+/** Claves de payload que admite cada schema del catálogo: `extra="forbid"`
+ * (event_catalog.py:52-53) rechaza el evento entero ante una clave no
+ * declarada. Los `null` no viajan (payload_sin_nulos, import_domain.py:120-123). */
+const HUB_PAYLOAD_KEYS = {
+    slice_opened: new Set(['epic_id', 'epic_code', 'retries_budget', 'source']),
+    slice_claimed: new Set(['agent_id', 'manifest_hash']),
+    phase_advanced: new Set(['to', 'source']),
+    phase_reverted: new Set(['to', 'gate', 'source']),
+    gate_verdict: new Set(['gate', 'verdict', 'evidence', 'cause', 'details_ref', 'source']),
+    wiring_item_updated: new Set(['item_id', 'status', 'evidence', 'kind', 'ref', 'source']),
+    wiring_checklist_seeded: new Set(['items', 'source']),
+    checkpoint_recorded: new Set(['branch', 'commit_sha', 'summary', 'source']),
+    progress_noted: new Set(['note', 'source']),
+    handoff_recorded: new Set(['note', 'resume_hint', 'stopped_at', 'source']),
+    slice_submitted: new Set([]),
+    slice_archived: new Set([]),
+    slice_parked: new Set(['reason']),
+    slice_resumed: new Set(['retries_budget']),
+    slice_escalated: new Set(['cause']),
+    slice_requeued: new Set(['retries_budget']),
+    slice_cancelled: new Set([]),
+    release_opened: new Set(['release_line', 'epic_codes']),
+    release_gate_verdict: new Set(['gate', 'verdict', 'evidence']),
+    release_closed: new Set(['status', 'motivo', 'epic_codes']),
+    front_opened: new Set(['members', 'merge_order', 'asignaciones']),
+    front_member_added: new Set(['epic_code', 'merge_order', 'worktree', 'assignee']),
+    front_member_integrated: new Set(['epic_code', 'merge_commit', 'resmoke_ok', 'evidence']),
+    front_drained: new Set([]),
+    front_closed: new Set([]),
+};
+const RELEASE_VERDICTS = new Set(['PASS', 'FAIL', 'PARTIAL', 'TOOL_ERROR']);
+function isBlank(value) {
+    return typeof value !== 'string' || value.trim() === '';
+}
+function checkNoteLimit(add, label, value) {
+    if (typeof value === 'string' && value.length > MAX_NOTE) {
+        add(`${label} supera el límite de ${MAX_NOTE} caracteres del hub (string_too_long; _MAX_NOTE, event_catalog.py:37)`);
+    }
+}
+function checkCommon(add, aggregate, i, ev) {
+    if (!HUB_TYPES[aggregate].has(ev.event_type)) {
+        add(`evento ${i}: "${ev.event_type}" no es un tipo del agregado ${aggregate} (la enumeración del catálogo es cerrada, import_domain.py:144-149)`);
+        return false;
+    }
+    if (Number.isNaN(new Date(ev.occurred_at).getTime())) {
+        add(`evento ${i} (${ev.event_type}): occurred_at inválido: "${ev.occurred_at}"`);
+    }
+    const allowed = HUB_PAYLOAD_KEYS[ev.event_type];
+    if (allowed) {
+        for (const key of Object.keys(ev.payload ?? {})) {
+            if (ev.payload[key] === null)
+                continue;
+            if (!allowed.has(key)) {
+                add(`evento ${i} (${ev.event_type}): clave "${key}" fuera del schema del catálogo (extra="forbid", event_catalog.py:52-53)`);
+            }
+        }
+    }
+    return true;
+}
+function verifySliceSequence(events, add) {
+    if (events.length === 0) {
+        add('sin eventos: el hub no tiene nada que importar');
+        return;
+    }
+    let phase = 'dor';
+    let status = 'ACTIVE';
+    const gatesTrue = new Set();
+    const rejected = new Set();
+    const isTerminal = () => status === 'CANCELLED' || phase === 'archived';
+    events.forEach((ev, i) => {
+        const payload = (ev.payload ?? {});
+        if (!checkCommon(add, 'slice', i, ev))
+            return;
+        const t = ev.event_type;
+        if (i === 0 && t !== 'slice_opened') {
+            add(`evento 0: el primer evento debe ser slice_opened, no ${t} (domain.py:287)`);
+        }
+        if (i > 0 && t === 'slice_opened') {
+            add(`evento ${i}: slice_opened solo puede ser el primer evento (domain.py:299)`);
+            return;
+        }
+        if (t === 'slice_opened' || t === 'lease_reaped')
+            return;
+        if (isTerminal() && t !== 'slice_archived' && t !== 'slice_reflected') {
+            add(`evento ${i} (${t}): ilegal sobre un slice terminal — en terminal solo aplican slice_archived, slice_reflected y lease_reaped (domain.py:318-324)`);
+            return;
+        }
+        switch (t) {
+            case 'phase_advanced': {
+                const to = payload.to;
+                const idx = PHASE_ORDER.indexOf(phase);
+                const next = idx + 1 < PHASE_ORDER.length ? PHASE_ORDER[idx + 1] : null;
+                if (status !== 'ACTIVE')
+                    add(`evento ${i}: solo un slice ACTIVE avanza de fase (status=${status}, domain.py:397-398)`);
+                if (to !== next) {
+                    add(`evento ${i}: orden estricto de fases (invariante 1, domain.py:404-406): ${phase} → ${String(to)} es ilegal; siguiente válida: ${String(next)}`);
+                }
+                if (typeof to === 'string' && PHASE_ORDER.includes(to))
+                    phase = to;
+                break;
+            }
+            case 'phase_reverted': {
+                const to = payload.to;
+                const gate = payload.gate;
+                if (typeof to !== 'string' || !PHASE_ORDER.includes(to) || PHASE_ORDER.indexOf(to) >= PHASE_ORDER.indexOf(phase)) {
+                    add(`evento ${i}: phase_reverted debe retroceder a una fase anterior (domain.py:412-413)`);
+                }
+                else {
+                    phase = to;
+                }
+                if (typeof gate !== 'string' || !rejected.has(gate)) {
+                    add(`evento ${i}: retroceso solo por rechazo de gate explícito (invariante 1, domain.py:414-416): el gate ${JSON.stringify(gate)} no tiene un FAIL registrado`);
+                }
+                break;
+            }
+            case 'gate_verdict': {
+                const gate = String(payload.gate ?? '');
+                const verdict = payload.verdict;
+                if (status !== 'ACTIVE')
+                    add(`evento ${i}: solo un slice ACTIVE procesa gate_verdict (status=${status}, domain.py:397-398)`);
+                if (!SLICE_GATES.includes(gate)) {
+                    add(`evento ${i}: gate desconocido "${gate}" — el reducer del slice solo acepta ${SLICE_GATES.join(', ')} (domain.py:422)`);
+                    break;
+                }
+                checkNoteLimit(add, `evento ${i} (gate_verdict): evidence`, payload.evidence);
+                checkNoteLimit(add, `evento ${i} (gate_verdict): cause`, payload.cause);
+                if (verdict === 'PASS') {
+                    if (isBlank(payload.evidence)) {
+                        add(`evento ${i}: gate_verdict PASS de "${gate}" sin evidence — passing ⇒ evidence obligatoria (invariante 3, domain.py:424-425)`);
+                    }
+                    if (gate === 'dod' && !gatesTrue.has('wiring_verified')) {
+                        add(`evento ${i}: dod PASS sin wiring_verified cerrado — wiring_verified es prerequisito duro de dod (invariante 4, domain.py:427-428)`);
+                    }
+                    gatesTrue.add(gate);
+                    rejected.delete(gate);
+                }
+                else if (verdict === 'FAIL') {
+                    if (gatesTrue.has(gate) && isBlank(payload.cause)) {
+                        add(`evento ${i}: tumbar el gate cerrado "${gate}" exige cause (invariante 2, ratchet, domain.py:432-434)`);
+                    }
+                    gatesTrue.delete(gate);
+                    rejected.add(gate);
+                }
+                else {
+                    add(`evento ${i}: veredicto ${JSON.stringify(verdict)} no promueve el gate "${gate}": parcial o fallo de herramienta es bloqueante (invariante 5, domain.py:441-445)`);
+                }
+                break;
+            }
+            case 'wiring_item_updated': {
+                if (status !== 'ACTIVE')
+                    add(`evento ${i}: solo un slice ACTIVE procesa wiring_item_updated (status=${status}, domain.py:397-398)`);
+                if (isBlank(payload.item_id)) {
+                    add(`evento ${i}: wiring_item_updated exige item_id no vacío (domain.py:450)`);
+                }
+                checkNoteLimit(add, `evento ${i} (wiring_item_updated): evidence`, payload.evidence);
+                if (payload.status === 'passing' && isBlank(payload.evidence)) {
+                    add(`evento ${i}: wiring passing sin evidence — passing ⇒ evidence obligatoria (invariante 3, domain.py:452-453)`);
+                }
+                break;
+            }
+            case 'wiring_checklist_seeded': {
+                const items = Array.isArray(payload.items) ? payload.items : [];
+                if (items.length === 0) {
+                    add(`evento ${i}: wiring_checklist_seeded exige al menos un ítem (event_catalog.py:125)`);
+                }
+                items.forEach((item, j) => {
+                    const it = typeof item === 'object' && item !== null ? item : {};
+                    for (const field of ['item_id', 'kind', 'ref']) {
+                        if (typeof it[field] !== 'string') {
+                            add(`evento ${i}: items[${j}] sin "${field}" (los tres campos son exigidos, event_catalog.py:111-118)`);
+                        }
+                    }
+                });
+                break;
+            }
+            case 'progress_noted': {
+                if (typeof payload.note !== 'string')
+                    add(`evento ${i}: progress_noted exige note (event_catalog.py:134-135)`);
+                checkNoteLimit(add, `evento ${i} (progress_noted): note`, payload.note);
+                break;
+            }
+            case 'handoff_recorded': {
+                if (typeof payload.note !== 'string')
+                    add(`evento ${i}: handoff_recorded exige note (event_catalog.py:138-139)`);
+                checkNoteLimit(add, `evento ${i} (handoff_recorded): note`, payload.note);
+                checkNoteLimit(add, `evento ${i} (handoff_recorded): resume_hint`, payload.resume_hint);
+                checkNoteLimit(add, `evento ${i} (handoff_recorded): stopped_at`, payload.stopped_at);
+                break;
+            }
+            case 'checkpoint_recorded': {
+                if (typeof payload.branch !== 'string' || typeof payload.commit_sha !== 'string') {
+                    add(`evento ${i}: checkpoint_recorded exige branch y commit_sha (event_catalog.py:128-131)`);
+                }
+                checkNoteLimit(add, `evento ${i} (checkpoint_recorded): summary`, payload.summary);
+                break;
+            }
+            case 'slice_parked': {
+                if (status !== 'ACTIVE')
+                    add(`evento ${i}: no se puede aparcar desde ${status} (domain.py:368)`);
+                if (isBlank(payload.reason))
+                    add(`evento ${i}: slice_parked exige reason no vacía (invariante 7, domain.py:372-373)`);
+                checkNoteLimit(add, `evento ${i} (slice_parked): reason`, payload.reason);
+                status = 'PARKED';
+                break;
+            }
+            case 'slice_resumed': {
+                if (status !== 'PARKED')
+                    add(`evento ${i}: slice_resumed solo aplica a un slice PARKED (domain.py:376)`);
+                status = 'ACTIVE';
+                break;
+            }
+            case 'slice_escalated': {
+                if (status !== 'ACTIVE' && status !== 'PARKED')
+                    add(`evento ${i}: no se escala desde ${status} (domain.py:383)`);
+                if (isBlank(payload.cause))
+                    add(`evento ${i}: slice_escalated exige cause no vacía (domain.py:384-385)`);
+                checkNoteLimit(add, `evento ${i} (slice_escalated): cause`, payload.cause);
+                status = 'ESCALATED';
+                break;
+            }
+            case 'slice_requeued': {
+                if (status !== 'ESCALATED')
+                    add(`evento ${i}: slice_requeued solo aplica a ESCALATED (domain.py:388)`);
+                status = 'ACTIVE';
+                break;
+            }
+            case 'slice_cancelled': {
+                if (status !== 'ESCALATED')
+                    add(`evento ${i}: cancelar exige pasar por ESCALATED (domain.py:393-394)`);
+                status = 'CANCELLED';
+                break;
+            }
+            case 'slice_submitted': {
+                if (!gatesTrue.has('dod'))
+                    add(`evento ${i}: submit exige el gate dod cerrado (domain.py:487-488)`);
+                break;
+            }
+            case 'slice_archived': {
+                if (phase !== 'pr')
+                    add(`evento ${i}: archivar exige estar en la fase pr (domain.py:499-500), no en ${phase}`);
+                phase = 'archived';
+                break;
+            }
+            default:
+                // Telemetría/lease/contexto: hechos anotables, no transiciones (domain.py:326-364).
+                break;
+        }
+    });
+}
+function verifyReleaseSequence(events, add) {
+    if (events.length === 0) {
+        add('sin eventos: el hub no tiene nada que importar');
+        return;
+    }
+    let closed = false;
+    events.forEach((ev, i) => {
+        const payload = (ev.payload ?? {});
+        if (!checkCommon(add, 'release', i, ev))
+            return;
+        const t = ev.event_type;
+        if (i === 0) {
+            if (t !== 'release_opened') {
+                add(`evento 0: el primer evento del agregado release debe ser release_opened, no ${t} (release_domain.py:124-127)`);
+            }
+            else if (isBlank(payload.release_line)) {
+                add('evento 0: release_opened exige release_line (event_catalog.py:327; el import deriva de ahí la fila de identidad, import_service.py:349-360)');
+            }
+            return;
+        }
+        if (t === 'release_opened') {
+            add(`evento ${i}: release_opened solo puede ser el primer evento (release_domain.py:151)`);
+            return;
+        }
+        if (closed) {
+            add(`evento ${i} (${t}): ilegal sobre una release ya cerrada (release_domain.py:155-160)`);
+            return;
+        }
+        if (t === 'release_gate_verdict') {
+            const gate = String(payload.gate ?? '');
+            const verdict = payload.verdict;
+            if (!RELEASE_GATES.includes(gate)) {
+                add(`evento ${i}: gate "${gate}" no pertenece al Release Gate (${RELEASE_GATES.join(', ')}, release_gate_domain.py:20-22 y 68-71)`);
+            }
+            if (typeof verdict !== 'string' || !RELEASE_VERDICTS.has(verdict)) {
+                add(`evento ${i}: veredicto ${JSON.stringify(verdict)} desconocido: PASS | FAIL | PARTIAL | TOOL_ERROR (release_gate_domain.py:32 y 72-75)`);
+            }
+            checkNoteLimit(add, `evento ${i} (release_gate_verdict): evidence`, payload.evidence);
+            if (verdict === 'PASS' && isBlank(payload.evidence)) {
+                add(`evento ${i}: release_gate_verdict PASS de "${gate}" sin evidence — el fold del hub lo degrada a BLOQUEANTE, irreparable retroactivamente (release_gate_domain.py:93-96)`);
+            }
+        }
+        else if (t === 'release_closed') {
+            const st = payload.status;
+            if (st !== 'PASSED' && st !== 'FAILED') {
+                add(`evento ${i}: cerrar una release exige PASSED o FAILED, no ${JSON.stringify(st)} (release_domain.py:179-181)`);
+            }
+            checkNoteLimit(add, `evento ${i} (release_closed): motivo`, payload.motivo);
+            closed = true;
+        }
+    });
+}
+function verifyFrontSequence(events, add) {
+    if (events.length === 0) {
+        add('sin eventos: el hub no tiene nada que importar');
+        return;
+    }
+    let frontStatus = 'ACTIVE';
+    const memberCodes = new Set();
+    const integrated = new Set();
+    events.forEach((ev, i) => {
+        const payload = (ev.payload ?? {});
+        if (!checkCommon(add, 'front', i, ev))
+            return;
+        const t = ev.event_type;
+        if (i === 0) {
+            if (t !== 'front_opened') {
+                add(`evento 0: el primer evento del agregado front debe ser front_opened, no ${t} (front_domain.py:296-300)`);
+            }
+            else {
+                (Array.isArray(payload.members) ? payload.members : []).forEach((m) => memberCodes.add(String(m)));
+            }
+            return;
+        }
+        if (t === 'front_opened') {
+            add(`evento ${i}: front_opened solo puede ser el primer evento (front_domain.py:330)`);
+            return;
+        }
+        if (frontStatus === 'CLOSED') {
+            add(`evento ${i} (${t}): ilegal sobre un front cerrado (front_domain.py:331-334)`);
+            return;
+        }
+        if (t === 'front_member_added') {
+            const code = String(payload.epic_code ?? '');
+            if (frontStatus !== 'ACTIVE')
+                add(`evento ${i}: un front ${frontStatus} no admite miembros nuevos (front_domain.py:337-340)`);
+            if (memberCodes.has(code))
+                add(`evento ${i}: ${code} ya es miembro de este front (front_domain.py:342-345)`);
+            memberCodes.add(code);
+        }
+        else if (t === 'front_member_integrated') {
+            const code = String(payload.epic_code ?? '');
+            if (!memberCodes.has(code))
+                add(`evento ${i}: ${code} no es miembro de este front (front_domain.py:367-368)`);
+            checkNoteLimit(add, `evento ${i} (front_member_integrated): evidence`, payload.evidence);
+            if (payload.resmoke_ok === true)
+                integrated.add(code);
+        }
+        else if (t === 'front_drained') {
+            if (frontStatus !== 'ACTIVE')
+                add(`evento ${i}: un front ${frontStatus} no se puede drenar (front_domain.py:382-383)`);
+            frontStatus = 'DRAINING';
+        }
+        else if (t === 'front_closed') {
+            if (frontStatus !== 'DRAINING')
+                add(`evento ${i}: cerrar exige drenar primero (ACTIVE → DRAINING → CLOSED, front_domain.py:387-390)`);
+            const pending = [...memberCodes].filter((c) => !integrated.has(c));
+            if (pending.length > 0)
+                add(`evento ${i}: quedan miembros sin integrar: ${pending.join(', ')} (front_domain.py:391-397)`);
+            frontStatus = 'CLOSED';
+        }
+    });
+}
+function verifyFact(fact, add) {
+    const rule = HUB_FACT_RULES[fact.fact];
+    if (!rule) {
+        add(`hecho de proyecto desconocido: "${fact.fact}" (conocidos: ${Object.keys(HUB_FACT_RULES).sort().join(', ')}; import_service.py:449-453)`);
+        return;
+    }
+    if (Number.isNaN(new Date(fact.occurred_at).getTime())) {
+        add(`occurred_at inválido: "${fact.occurred_at}"`);
+    }
+    const v = fact.value;
+    if (rule.kind === 'boolean' && typeof v !== 'boolean') {
+        add(`"${fact.fact}" es booleano en el hub (project_facts_domain.py:56-57, import_service.py:458-460)`);
+    }
+    else if (rule.kind === 'machine_text' && (typeof v !== 'string' || v === '' || v.length > (rule.max ?? MAX_NOTE))) {
+        add(`"${fact.fact}" es texto no vacío de hasta ${rule.max} caracteres en el hub (project_facts_domain.py:47 y 58-62)`);
+    }
+    else if (rule.kind === 'string_or_null' && !(v === null || typeof v === 'string')) {
+        add(`"${fact.fact}" es texto (o null) en el hub (import_service.py:461-462)`);
+    }
+}
+/**
+ * Valida el bundle YA normalizado contra los invariantes del hub SIN red:
+ * evidence obligatoria en passing (invariante 3), límites `_MAX_NOTE`,
+ * catálogo cerrado de gates y eventos, item_id no vacío, orden estricto de
+ * fases, wiring_verified→dod (invariante 4), máquinas de estados de
+ * slice/release/front y catálogo de hechos de proyecto. Devuelve las
+ * violaciones con su entrada de origen; vacío = el hub no tendría motivo de
+ * rechazo conocido.
+ */
+export function verifyNormalizedBundle(bundle) {
+    const violations = [];
+    const scoped = (source_key) => (message) => {
+        violations.push({ source_key, message });
+    };
+    const seenKeys = new Set();
+    const checkDuplicate = (key) => {
+        // El import rechaza la clave de entrada duplicada (import_service.py:128-137).
+        if (seenKeys.has(key))
+            violations.push({ source_key: key, message: 'clave de entrada duplicada en el bundle (import_service.py:128-137)' });
+        seenKeys.add(key);
+    };
+    for (const h of bundle.history) {
+        const key = `history[${h.epic_code}]`;
+        checkDuplicate(key);
+        verifySliceSequence(h.events, scoped(key));
+    }
+    for (const r of bundle.releases) {
+        const key = `releases[${r.key}]`;
+        checkDuplicate(key);
+        verifyReleaseSequence(r.events, scoped(key));
+    }
+    for (const f of bundle.fronts) {
+        const key = `fronts[${f.key}]`;
+        checkDuplicate(key);
+        verifyFrontSequence(f.events, scoped(key));
+    }
+    for (const fact of bundle.facts) {
+        const key = `facts[${fact.fact}]`;
+        checkDuplicate(key);
+        verifyFact(fact, scoped(key));
+    }
+    (bundle.unmapped ?? []).forEach((u, i) => {
+        // LegacyImported exige source_key de 1..200 caracteres (event_catalog.py:446).
+        if (typeof u.source_key !== 'string' || u.source_key.length < 1 || u.source_key.length > 200) {
+            violations.push({
+                source_key: `unmapped[${i}]`,
+                message: 'source_key debe tener entre 1 y 200 caracteres (LegacyImported, event_catalog.py:446)',
+            });
+        }
+    });
+    return violations;
+}