@saulwade/swl-ses 2.6.1 → 2.8.0

package/scripts/lib/w4-superficie-candidato.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * Superficie del CANDIDATO bajo prueba (F32/T-01, escindida de
+ * `w4-harness-bajo-prueba.js` por ADR-0056:100-106 y
+ * `DT-MOTOR-REPLAY-SRP-MUTACIONES-PINEADAS`).
+ *
+ * Este módulo contiene EXCLUSIVAMENTE la superficie de decisión de `swl-ses`
+ * (`runHarnessBajoPrueba`, que envuelve `verifyOperation()`). Se separó del
+ * validador del request del juez (`validateCertificationRequest`, que se queda
+ * en `w4-harness-bajo-prueba.js`) para que el juez de `swl-eval` pueda resolver
+ * la superficie DESDE EL TARBALL bajo prueba sin arrastrar maquinaria del juez
+ * — cerrando la mezcla de responsabilidades que la revisión adversarial de T-09
+ * señaló (el juez certifica el código que se envía, no una copia pineada).
+ *
+ * Es la superficie que el motor de replay ejercita contra cada caso del corpus
+ * a través del adaptador de candidato: en modo dev la envuelve
+ * `crearCandidatoSinteticoDev`; en el tramo real la resolvería
+ * `crearCandidatoReal` desde `CANDIDATO_ROOT`.
+ */
+
+const { verifyOperation } = require('./policy-contract');
+
+/**
+ * Superficie pura que el juez de `swl-eval` invoca sobre el candidato de
+ * `swl-ses`: envuelve `verifyOperation()` (ya puro) sin duplicar su
+ * validación ni construir un contrato nuevo (REQ-32-02). Nunca lanza —
+ * devuelve un resultado discriminado y sanitizado para que un proceso
+ * remoto no reciba un Error nativo con detalle interno de la pila.
+ */
+function runHarnessBajoPrueba(rawOperationBytes) {
+  try {
+    const operation = verifyOperation(rawOperationBytes);
+    return Object.freeze({
+      ok: true,
+      operationDigest: operation.operationDigest,
+      capability: operation.capability,
+      effectKind: operation.effectKind,
+    });
+  } catch (error) {
+    // verifyOperation() garantiza .codigo en todo error que lanza (crearError()
+    // lo fija siempre); no se agrega un fallback defensivo no verificable.
+    return Object.freeze({ ok: false, codigo: error.codigo });
+  }
+}
+
+module.exports = {
+  runHarnessBajoPrueba,
+};

package/scripts/lib/w4-veredicto.js

@@ -0,0 +1,452 @@
+'use strict';
+
+/**
+ * Emisor del `CertificationVerdict` (ADR-0053 § Contrato swl-ses <-> swl-eval,
+ * F32/T-06, REQ-32-06).
+ *
+ * `emitirVeredicto(scoringReport, certificationRequest, insumos)` mapea un
+ * `ScoringReport` (T-05, `scripts/lib/w4-scorer-certificacion.js`) y un
+ * `CertificationRequest` (T-01, `scripts/lib/w4-harness-bajo-prueba.js`) a un
+ * `CertificationVerdict` sanitizado (`schemas/w4-certification-verdict.schema.json`):
+ * nunca el payload crudo del corpus, PII ni tokens — sólo SLO/medido/pass por
+ * dimensión, metadatos escalares y conteos agregados. `certifica` se copia
+ * LITERAL del `ScoringReport` (nunca se recomputa ni se "eleva" a partir de
+ * las dimensiones sanitizadas — esa es la única fuente de verdad de
+ * `certificarDimensiones()` en T-05).
+ *
+ * Puro: cero `fs`, cero red, cero reloj de pared. `emitidoEn` se recibe ya
+ * validado como argumento (`insumos.emitidoEn`) — este módulo nunca consulta
+ * `Date.now()`.
+ *
+ * C5 (sanitización enforzada también por el schema, no sólo aquí): el
+ * `medido` crudo de un `DimensionScore` puede traer booleanos
+ * (`paridadContractual`), objetos anidados (`ciclosConsecutivosPorRuntime`) o
+ * arreglos de categorías (`categoriasSinEvidenciaDeDefensaReal`). `aplanarMedido()`
+ * lo reduce a `null` o a un mapa plano de una sola profundidad cuyas claves
+ * son rutas con punto y cuyos valores son SIEMPRE `number` — nunca strings,
+ * booleanos ni arreglos crudos. Los booleanos se codifican 1/0; los arreglos
+ * se reducen a su longitud (un conteo, nunca los nombres de categoría
+ * crudos — esos, cuando importan, viajan reducidos en `failures[]`).
+ *
+ * C6: `firma.dev.nota` es un literal FIJO (`NOTA_DEV`) que este módulo nunca
+ * construye dinámicamente — el schema lo fija como `const` y el verificador
+ * (`w4-verificar-veredicto.js`) rechaza cualquier otro valor delegando en
+ * `validateCertificationVerdict()`.
+ */
+
+const { validateScoringReport, NOMBRES_DIMENSIONES } = require('./w4-scorer-certificacion');
+const { validateCertificationRequest } = require('./w4-harness-bajo-prueba');
+const { CATEGORIAS } = require('./w4-corpus-generador');
+const { validarTimestampIso } = require('./signed-envelope');
+
+const SCHEMA_VERSION = '1.0.0';
+const NOMBRE_META_SLO = 'meta-SLO';
+
+// C6: literal fijo — DEBE ser idéntico, carácter por carácter, al `const` de
+// schemas/w4-certification-verdict.schema.json#/$defs/firmaDev/properties/nota.
+const NOTA_DEV = 'verificador dev, adaptador de attestation simulado — este veredicto nunca certifica ni implica origen verificado (ADR-0053 C6)';
+
+const SHA256 = /^[a-f0-9]{64}$/u;
+const IDENTIFICADOR = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const CASO_ID = /^(?:mutation|injection)-[a-z][a-z-]*-[0-9]{6}$/u;
+const CATEGORIA_SET = new Set(CATEGORIAS);
+const NOMBRE_DIMENSION_SET = new Set(NOMBRES_DIMENSIONES);
+
+const INSUMOS_KEYS_DEV = ['runId', 'emitidoEn', 'corpusAgregados', 'failures', 'modo'];
+const INSUMOS_KEYS_REAL = [...INSUMOS_KEYS_DEV, 'bundleDigest'];
+const CORPUS_AGREGADOS_KEYS = [
+  'totalCasos', 'selladosHumano', 'mutationsTotal', 'promptInjectionsTotal', 'pass', 'fail', 'porCategoria',
+];
+const CATEGORIA_AGG_KEYS = ['total', 'fail'];
+const FAILURE_KEYS = ['casoId', 'categoria', 'dimension'];
+
+const VERDICT_KEYS = [
+  'kind', 'schemaVersion', 'runId', 'request', 'certifica', 'dimensiones',
+  'metaSlo', 'metadata', 'corpusAgregados', 'failures', 'firma', 'emitidoEn',
+];
+const REQUEST_KEYS = ['commit', 'tarballDigest', 'matrix'];
+const MATRIX_ENTRY_KEYS = ['runtime', 'os', 'model'];
+const DIMENSION_VERDICT_KEYS = ['dimension', 'slo', 'medido', 'pass'];
+const METADATA_KEYS = ['cobertura', 'mutation', 'cve', 'rollback'];
+const RUNTIMES_CORE3 = new Set(['claude-code', 'codex-cli', 'gemini-cli']);
+const OS_CORE3 = new Set(['win32', 'linux', 'darwin']);
+
+function crearError(codigo, mensaje) {
+  const error = new Error(mensaje);
+  error.codigo = codigo;
+  return error;
+}
+
+function fallar(codigo, mensaje) {
+  throw crearError(codigo, mensaje);
+}
+
+function esObjetoPlano(valor) {
+  return Boolean(valor) && typeof valor === 'object' && !Array.isArray(valor)
+    && Object.getPrototypeOf(valor) === Object.prototype
+    && Object.getOwnPropertySymbols(valor).length === 0;
+}
+
+function validarClaves(valor, esperadas, etiqueta, codigo = 'VERDICT_EMISION_INVALIDA') {
+  if (!esObjetoPlano(valor)) fallar(codigo, `${etiqueta} inválido`);
+  const actuales = Object.keys(valor).sort();
+  const objetivo = [...esperadas].sort();
+  if (JSON.stringify(actuales) !== JSON.stringify(objetivo)) fallar(codigo, `${etiqueta} inválido`);
+}
+
+function congelarProfundo(valor) {
+  if (valor && typeof valor === 'object' && !Object.isFrozen(valor)) {
+    Object.values(valor).forEach(congelarProfundo);
+    Object.freeze(valor);
+  }
+  return valor;
+}
+
+// ---------------------------------------------------------------------------
+// C5 — sanitización de 'medido': siempre número, null, u objeto plano de números.
+// ---------------------------------------------------------------------------
+
+function aplanarNumero(valor) {
+  if (typeof valor === 'number' && Number.isFinite(valor)) return valor;
+  if (typeof valor === 'boolean') return valor ? 1 : 0;
+  if (Array.isArray(valor)) return valor.length;
+  return 0;
+}
+
+function aplanarMedido(valor, prefijo = '') {
+  if (valor === null || valor === undefined) return prefijo ? {} : null;
+  if (typeof valor === 'number' || typeof valor === 'boolean' || Array.isArray(valor)) {
+    return { [prefijo || 'valor']: aplanarNumero(valor) };
+  }
+  if (esObjetoPlano(valor)) {
+    const acumulado = {};
+    for (const [clave, sub] of Object.entries(valor)) {
+      Object.assign(acumulado, aplanarMedido(sub, prefijo ? `${prefijo}.${clave}` : clave));
+    }
+    return acumulado;
+  }
+  return prefijo ? {} : null;
+}
+
+function sanitizarMedidoTope(valor) {
+  const aplanado = aplanarMedido(valor);
+  if (aplanado === null) return null;
+  return Object.keys(aplanado).length === 0 ? null : congelarProfundo(aplanado);
+}
+
+function crearDimensionVerdict(score) {
+  return congelarProfundo({
+    dimension: score.dimension,
+    slo: score.slo,
+    medido: sanitizarMedidoTope(score.medido),
+    pass: score.pass,
+  });
+}
+
+function extraerScalarMap(valor) {
+  if (!esObjetoPlano(valor)) return null;
+  const salida = {};
+  for (const [clave, v] of Object.entries(valor)) {
+    if (typeof v === 'number' || typeof v === 'boolean' || typeof v === 'string') salida[clave] = v;
+  }
+  return salida;
+}
+
+function construirMetadata(metaSlo) {
+  const medido = esObjetoPlano(metaSlo.medido) ? metaSlo.medido : {};
+  return congelarProfundo({
+    cobertura: extraerScalarMap(medido.cobertura),
+    mutation: extraerScalarMap(medido.mutation),
+    cve: extraerScalarMap(medido.cve),
+    rollback: extraerScalarMap(medido.rollback),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Validación de insumos del emisor — nunca confía en la forma del caller.
+// ---------------------------------------------------------------------------
+
+function validarEnteroNoNegativo(valor, etiqueta) {
+  if (!Number.isInteger(valor) || valor < 0) fallar('VERDICT_EMISION_INVALIDA', `${etiqueta} inválido`);
+}
+
+function validarCorpusAgregados(valor) {
+  validarClaves(valor, CORPUS_AGREGADOS_KEYS, 'corpusAgregados');
+  ['totalCasos', 'selladosHumano', 'mutationsTotal', 'promptInjectionsTotal', 'pass', 'fail']
+    .forEach((clave) => validarEnteroNoNegativo(valor[clave], `corpusAgregados.${clave}`));
+  if (valor.pass + valor.fail !== valor.totalCasos) {
+    fallar('VERDICT_EMISION_INVALIDA', 'corpusAgregados.pass + fail debe igualar totalCasos');
+  }
+  if (!esObjetoPlano(valor.porCategoria)) fallar('VERDICT_EMISION_INVALIDA', 'corpusAgregados.porCategoria inválido');
+  const porCategoria = {};
+  for (const [categoria, agregado] of Object.entries(valor.porCategoria)) {
+    if (!CATEGORIA_SET.has(categoria)) {
+      fallar('VERDICT_EMISION_INVALIDA', `corpusAgregados.porCategoria con categoría desconocida: ${categoria}`);
+    }
+    validarClaves(agregado, CATEGORIA_AGG_KEYS, `corpusAgregados.porCategoria.${categoria}`);
+    validarEnteroNoNegativo(agregado.total, `corpusAgregados.porCategoria.${categoria}.total`);
+    validarEnteroNoNegativo(agregado.fail, `corpusAgregados.porCategoria.${categoria}.fail`);
+    if (agregado.fail > agregado.total) {
+      fallar('VERDICT_EMISION_INVALIDA', `corpusAgregados.porCategoria.${categoria}.fail excede total`);
+    }
+    porCategoria[categoria] = { total: agregado.total, fail: agregado.fail };
+  }
+  return congelarProfundo({
+    totalCasos: valor.totalCasos,
+    selladosHumano: valor.selladosHumano,
+    mutationsTotal: valor.mutationsTotal,
+    promptInjectionsTotal: valor.promptInjectionsTotal,
+    pass: valor.pass,
+    fail: valor.fail,
+    porCategoria,
+  });
+}
+
+function validarFailures(lista) {
+  if (!Array.isArray(lista)) fallar('VERDICT_EMISION_INVALIDA', 'failures inválido');
+  return congelarProfundo(lista.map((entrada, indice) => {
+    validarClaves(entrada, FAILURE_KEYS, `failures[${indice}]`);
+    if (typeof entrada.casoId !== 'string' || !CASO_ID.test(entrada.casoId)) {
+      fallar('VERDICT_EMISION_INVALIDA', `failures[${indice}].casoId inválido`);
+    }
+    if (!CATEGORIA_SET.has(entrada.categoria)) {
+      fallar('VERDICT_EMISION_INVALIDA', `failures[${indice}].categoria inválido`);
+    }
+    if (!NOMBRE_DIMENSION_SET.has(entrada.dimension)) {
+      fallar('VERDICT_EMISION_INVALIDA', `failures[${indice}].dimension inválido`);
+    }
+    return { casoId: entrada.casoId, categoria: entrada.categoria, dimension: entrada.dimension };
+  }));
+}
+
+// Compara la matriz DECLARADA en el request contra la matriz efectivamente
+// scoreada (matrixEntries del ScoringReport, derivada de replayReports) como
+// MULTICONJUNTO por runtime|os|model (reusa `claveMatrixEntry`, definido abajo).
+// Cierra el hueco de que el badge anuncie una matriz distinta a la evaluada: el
+// candidato declara la matriz en su request, pero la fuente de verdad de lo
+// certificado es lo que realmente se replayó/scoreó, no lo que el candidato dice.
+function mismasMatrices(declarada, evaluada) {
+  const a = declarada.map(claveMatrixEntry).sort();
+  const b = evaluada.map(claveMatrixEntry).sort();
+  return a.length === b.length && a.every((clave, indice) => clave === b[indice]);
+}
+
+// ---------------------------------------------------------------------------
+// emitirVeredicto — ScoringReport + CertificationRequest + insumos -> Verdict
+// ---------------------------------------------------------------------------
+
+function emitirVeredicto(scoringReport, certificationRequest, insumos) {
+  // Re-validación: el emisor no confía en la forma de lo que recibe, aunque
+  // venga de módulos hermanos ya validados en su propio boundary.
+  const reporte = validateScoringReport(scoringReport);
+  const solicitud = validateCertificationRequest(certificationRequest);
+
+  if (!esObjetoPlano(insumos) || (insumos.modo !== 'dev' && insumos.modo !== 'real')) {
+    fallar('VERDICT_EMISION_INVALIDA', 'insumos.modo debe ser "dev" o "real"');
+  }
+  const clavesEsperadas = insumos.modo === 'real' ? INSUMOS_KEYS_REAL : INSUMOS_KEYS_DEV;
+  validarClaves(insumos, clavesEsperadas, 'insumos');
+
+  if (typeof insumos.runId !== 'string' || !IDENTIFICADOR.test(insumos.runId)) {
+    fallar('VERDICT_EMISION_INVALIDA', 'insumos.runId inválido');
+  }
+  validarTimestampIso(insumos.emitidoEn, 'insumos.emitidoEn');
+
+  const corpusAgregados = validarCorpusAgregados(insumos.corpusAgregados);
+  const failures = validarFailures(insumos.failures);
+
+  // Binding matriz declarada ↔ evaluada: la matriz que el badge certificará
+  // (request.matrix) debe coincidir exactamente con la que realmente se scoreó
+  // (reporte.matrixEntries). Sin esto, un candidato podría declarar una matriz y
+  // hacer certificar otra. Fail-closed antes de emitir.
+  if (!mismasMatrices(solicitud.matrix, reporte.matrixEntries)) {
+    fallar('VERDICT_EMISION_INVALIDA', 'request.matrix no coincide con la matriz efectivamente scoreada (matrixEntries)');
+  }
+
+  const dimensiones = reporte.dimensiones.map(crearDimensionVerdict);
+  const metaSlo = crearDimensionVerdict(reporte.metaSlo);
+  const metadata = construirMetadata(reporte.metaSlo);
+
+  let firma;
+  if (insumos.modo === 'dev') {
+    firma = Object.freeze({ modo: 'dev', tipo: 'no-certificante', nota: NOTA_DEV });
+  } else {
+    if (typeof insumos.bundleDigest !== 'string' || !SHA256.test(insumos.bundleDigest)) {
+      fallar('VERDICT_EMISION_INVALIDA', 'insumos.bundleDigest inválido');
+    }
+    firma = Object.freeze({ modo: 'real', tipo: 'certificante', bundleDigest: insumos.bundleDigest });
+  }
+
+  const verdict = congelarProfundo({
+    kind: 'swl-certification-verdict',
+    schemaVersion: SCHEMA_VERSION,
+    runId: insumos.runId,
+    request: {
+      commit: solicitud.candidate.commit,
+      tarballDigest: solicitud.candidate.tarballDigest,
+      matrix: solicitud.matrix.map((entrada) => ({ ...entrada })),
+    },
+    certifica: reporte.certifica, // COPIA LITERAL — nunca se recomputa ni se eleva.
+    dimensiones,
+    metaSlo,
+    metadata,
+    corpusAgregados,
+    failures,
+    firma,
+    emitidoEn: insumos.emitidoEn,
+  });
+
+  return validateCertificationVerdict(verdict);
+}
+
+// ---------------------------------------------------------------------------
+// validateCertificationVerdict — validador oficial sin efectos.
+// ---------------------------------------------------------------------------
+
+function validarMatrixEntry(entry, etiqueta) {
+  validarClaves(entry, MATRIX_ENTRY_KEYS, etiqueta, 'CERTIFICATION_VERDICT_INVALID');
+  if (typeof entry.runtime !== 'string' || !RUNTIMES_CORE3.has(entry.runtime)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.runtime inválido`);
+  }
+  if (typeof entry.os !== 'string' || !OS_CORE3.has(entry.os)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.os inválido`);
+  }
+  if (typeof entry.model !== 'string' || !IDENTIFICADOR.test(entry.model)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.model inválido`);
+  }
+}
+
+// Mismo criterio de identidad que claveMatrixEntry() de
+// w4-verificar-veredicto.js (sin NFKC aquí: en este boundary runtime/os/model
+// ya pasaron por validarMatrixEntry — enum + IDENTIFICADOR ASCII — así que la
+// normalización Unicode no aporta nada adicional).
+function claveMatrixEntry(entrada) {
+  return `${entrada.runtime}|${entrada.os}|${entrada.model}`;
+}
+
+function validarRequestVerdict(request) {
+  validarClaves(request, REQUEST_KEYS, 'request', 'CERTIFICATION_VERDICT_INVALID');
+  if (typeof request.commit !== 'string' || !/^[a-f0-9]{40}$/u.test(request.commit)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'request.commit inválido');
+  }
+  if (typeof request.tarballDigest !== 'string' || !SHA256.test(request.tarballDigest)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'request.tarballDigest inválido');
+  }
+  if (!Array.isArray(request.matrix) || request.matrix.length === 0) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'request.matrix inválido');
+  }
+  request.matrix.forEach((entry, i) => validarMatrixEntry(entry, `request.matrix[${i}]`));
+
+  // Drift schema-vs-validador: el schema declara `request.matrix` con
+  // `uniqueItems: true` — se enforza también aquí (mismo criterio de clave
+  // que el verificador).
+  const clavesVistas = new Set();
+  for (const entry of request.matrix) {
+    const clave = claveMatrixEntry(entry);
+    if (clavesVistas.has(clave)) {
+      fallar('CERTIFICATION_VERDICT_INVALID', 'request.matrix con entradas duplicadas');
+    }
+    clavesVistas.add(clave);
+  }
+}
+
+function esEscalarValido(valor) {
+  // Un número escalar del veredicto debe ser FINITO: NaN/Infinity se serializan a
+  // `null` en I-JSON y corromperían silenciosamente el dato (fail-open de C5).
+  if (typeof valor === 'number') return Number.isFinite(valor);
+  return typeof valor === 'boolean' || typeof valor === 'string';
+}
+
+function esMedidoValido(valor) {
+  if (valor === null) return true;
+  if (typeof valor === 'number') return Number.isFinite(valor);
+  if (!esObjetoPlano(valor)) return false;
+  return Object.values(valor).every((v) => typeof v === 'number' && Number.isFinite(v));
+}
+
+function validarDimensionVerdict(valor, etiqueta, nombreEsperado) {
+  validarClaves(valor, DIMENSION_VERDICT_KEYS, etiqueta, 'CERTIFICATION_VERDICT_INVALID');
+  if (nombreEsperado ? valor.dimension !== nombreEsperado : !NOMBRE_DIMENSION_SET.has(valor.dimension)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.dimension inválido`);
+  }
+  if (typeof valor.slo !== 'string' || valor.slo.length === 0) {
+    fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.slo inválido`);
+  }
+  if (!esMedidoValido(valor.medido)) fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.medido inválido`);
+  if (typeof valor.pass !== 'boolean') fallar('CERTIFICATION_VERDICT_INVALID', `${etiqueta}.pass inválido`);
+}
+
+function validarMetadataVerdict(metadata) {
+  validarClaves(metadata, METADATA_KEYS, 'metadata', 'CERTIFICATION_VERDICT_INVALID');
+  for (const clave of METADATA_KEYS) {
+    const bloque = metadata[clave];
+    if (bloque === null) continue;
+    if (!esObjetoPlano(bloque)) fallar('CERTIFICATION_VERDICT_INVALID', `metadata.${clave} inválido`);
+    for (const valor of Object.values(bloque)) {
+      if (!esEscalarValido(valor)) {
+        fallar('CERTIFICATION_VERDICT_INVALID', `metadata.${clave} contiene un valor no escalar o no finito`);
+      }
+    }
+  }
+}
+
+function validarFirmaVerdict(firma) {
+  if (!esObjetoPlano(firma) || (firma.modo !== 'dev' && firma.modo !== 'real')) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'firma.modo inválido');
+  }
+  if (firma.modo === 'dev') {
+    validarClaves(firma, ['modo', 'tipo', 'nota'], 'firma', 'CERTIFICATION_VERDICT_INVALID');
+    if (firma.tipo !== 'no-certificante') fallar('CERTIFICATION_VERDICT_INVALID', 'firma.tipo inválido');
+    if (firma.nota !== NOTA_DEV) fallar('CERTIFICATION_VERDICT_INVALID', 'firma.nota inválido');
+    return;
+  }
+  validarClaves(firma, ['modo', 'tipo', 'bundleDigest'], 'firma', 'CERTIFICATION_VERDICT_INVALID');
+  if (firma.tipo !== 'certificante') fallar('CERTIFICATION_VERDICT_INVALID', 'firma.tipo inválido');
+  if (typeof firma.bundleDigest !== 'string' || !SHA256.test(firma.bundleDigest)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'firma.bundleDigest inválido');
+  }
+}
+
+/**
+ * Valida un `CertificationVerdict` (ADR-0053, REQ-32-06) sin efectos: no lee
+ * disco, no hace red, no consulta el reloj. Lanza `CERTIFICATION_VERDICT_INVALID`
+ * si el valor no cumple `schemas/w4-certification-verdict.schema.json` o sus
+ * `runtimeOnlyChecks`; retorna un valor deeply frozen equivalente si es válido.
+ */
+function validateCertificationVerdict(value) {
+  validarClaves(value, VERDICT_KEYS, 'certificationVerdict', 'CERTIFICATION_VERDICT_INVALID');
+  if (value.kind !== 'swl-certification-verdict') fallar('CERTIFICATION_VERDICT_INVALID', 'kind inválido');
+  if (value.schemaVersion !== SCHEMA_VERSION) fallar('CERTIFICATION_VERDICT_INVALID', 'schemaVersion inválida');
+  if (typeof value.runId !== 'string' || !IDENTIFICADOR.test(value.runId)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'runId inválido');
+  }
+
+  validarRequestVerdict(value.request);
+
+  if (typeof value.certifica !== 'boolean') fallar('CERTIFICATION_VERDICT_INVALID', 'certifica inválido');
+
+  if (!Array.isArray(value.dimensiones) || value.dimensiones.length !== 6) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'dimensiones inválido');
+  }
+  value.dimensiones.forEach((d, i) => validarDimensionVerdict(d, `dimensiones[${i}]`));
+  const nombresRecibidos = [...value.dimensiones.map((d) => d.dimension)].sort();
+  const nombresEsperados = [...NOMBRES_DIMENSIONES].sort();
+  if (JSON.stringify(nombresRecibidos) !== JSON.stringify(nombresEsperados)) {
+    fallar('CERTIFICATION_VERDICT_INVALID', 'dimensiones no cubre exactamente las 6 de ADR-0050 sin duplicados ni faltantes');
+  }
+
+  validarDimensionVerdict(value.metaSlo, 'metaSlo', NOMBRE_META_SLO);
+  validarMetadataVerdict(value.metadata);
+  validarCorpusAgregados(value.corpusAgregados);
+  validarFailures(value.failures);
+  validarFirmaVerdict(value.firma);
+  validarTimestampIso(value.emitidoEn, 'emitidoEn');
+
+  return congelarProfundo(JSON.parse(JSON.stringify(value)));
+}
+
+module.exports = {
+  NOTA_DEV,
+  emitirVeredicto,
+  validateCertificationVerdict,
+};