@saulwade/swl-ses 2.6.0 → 2.8.0

package/scripts/lib/w4-attestation-adapter.js

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * Adaptador REAL del puerto `attestationVerifier` que inyecta
+ * `w4-verificar-veredicto.js` (T-09, REQ-32-09, ADR-0056). Envuelve
+ * `gh attestation verify <artefacto> --bundle <bundle> --owner <owner>
+ * --signer-workflow <wf> --format json` — el EFECTO (spawn de `gh` + disco)
+ * vive aquí; el núcleo del verificador permanece puro.
+ *
+ * Contrato del puerto (ADR-0056, tres argumentos):
+ *   `(bundle: Buffer, expectedArtifactDigest: string sha256hex,
+ *     artifactBytes: string)`  ->  Promise<{ identidadOIDC:{repo,workflow,ref},
+ *                                             firmaValida:boolean }>
+ *
+ * `gh` real (v2.89.0) EXIGE el artefacto en disco (no existe `--digest`): el
+ * adaptador escribe `artifactBytes` a un temporal 0600 y se lo pasa a `gh`,
+ * que computa su sha256 y lo compara contra el sujeto atestiguado por Sigstore.
+ *
+ * Fail-closed (C4): cualquier borde de fallo — input malformado, cross-check
+ * de digest fallido, exit != 0 de `gh`, JSON inválido, campo de identidad
+ * faltante — LANZA; el núcleo lo captura y cae a `VERDICT_SIGNATURE_INVALID`.
+ * Nunca retorna `firmaValida:true` sin identidad OIDC completa.
+ *
+ * Defensa en profundidad (ADR-0053 pieza 5 / ADR-0056): se pasa `--owner` Y
+ * `--signer-workflow` a `gh` para que el propio `gh` rechace attestations de un
+ * workflow distinto del pineado, ademas de la comparación estricta del núcleo.
+ *
+ * NOTA DE BINDING (dev vs real, ADR-0053 § Honestidad): el mapeo exacto de los
+ * campos del certificado Sigstore de GitHub Actions a `{repo,workflow,ref}` y
+ * sus formas de string se anclan contra un GOLDEN BUNDLE real en el tramo real
+ * (T-13); hasta entonces `mapearIdentidad` usa los nombres de extensión
+ * documentados de Fulcio/GitHub. Ver DT-T06-BINDING-C1-DELEGADO-A-ADAPTADOR-T09.
+ */
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const GH_MAX_BUFFER = 8 * 1024 * 1024; // 8 MiB — igual que ci-reader.js
+const GH_TIMEOUT_MS_DEFAULT = 20000;
+const SHA256_HEX = /^[a-f0-9]{64}$/u;
+
+function ejecutorGhReal(ghPath, timeoutMs) {
+  return (args) => execFileSync(ghPath, args, {
+    encoding: 'utf8',
+    maxBuffer: GH_MAX_BUFFER,
+    timeout: timeoutMs,
+    windowsHide: true,
+  });
+}
+
+function esBufferCrudo(valor) {
+  if (!valor || typeof valor !== 'object') return false;
+  const proto = Object.getPrototypeOf(valor);
+  return (proto === Buffer.prototype || proto === Uint8Array.prototype) && valor.byteLength > 0;
+}
+
+function normalizarTextoNoVacio(valor) {
+  return typeof valor === 'string' && valor.length > 0 ? valor : null;
+}
+
+/**
+ * Extrae `{repo, workflow, ref}` del JSON de `gh attestation verify
+ * --format json` (un arreglo de resultados de verificación). Lee el
+ * certificado Sigstore del primer resultado y mapea las extensiones de
+ * GitHub Actions. Lanza si el arreglo está vacío o falta cualquier campo.
+ */
+function mapearIdentidad(salidaJson) {
+  const resultados = Array.isArray(salidaJson) ? salidaJson : null;
+  if (!resultados || resultados.length === 0) throw new Error('gh: salida de verificación vacía');
+  const primero = resultados[0];
+  const cert = primero
+    && primero.verificationResult
+    && primero.verificationResult.signature
+    && primero.verificationResult.signature.certificate;
+  if (!cert || typeof cert !== 'object') throw new Error('gh: certificado ausente en la salida');
+
+  const repo = normalizarTextoNoVacio(cert.sourceRepositoryURI);
+  const ref = normalizarTextoNoVacio(cert.sourceRepositoryRef);
+  // El workflow firmante puede venir como buildSignerURI o SubjectAlternativeName
+  // según la versión del cert; se toma el primero presente (documentado, no inferido).
+  const workflow = normalizarTextoNoVacio(cert.buildSignerURI)
+    || normalizarTextoNoVacio(cert.subjectAlternativeName);
+  if (!repo || !ref || !workflow) {
+    throw new Error('gh: certificado sin repo/ref/workflow completos');
+  }
+  return { repo, workflow, ref };
+}
+
+function escribirTemporal(fsDeps, dir, nombre, contenido) {
+  const destino = path.join(dir, nombre);
+  fsDeps.writeFileSync(destino, contenido, { mode: 0o600 });
+  return destino;
+}
+
+/**
+ * Construye el verificador real. `owner` y `signerWorkflow` son OBLIGATORIOS e
+ * inyectados (jamás hardcodeados). `ejecutor`/`fsDeps` son inyectables para
+ * pruebas — por defecto usan `gh` real y `fs`.
+ *
+ * @param {{owner:string, signerWorkflow:string, ghPath?:string,
+ *   timeoutMs?:number, ejecutor?:(args:string[])=>string, fsDeps?:object}} opciones
+ */
+function crearAttestationVerifierReal(opciones = {}) {
+  const owner = normalizarTextoNoVacio(opciones.owner);
+  const signerWorkflow = normalizarTextoNoVacio(opciones.signerWorkflow);
+  if (!owner) throw new Error('crearAttestationVerifierReal: owner requerido');
+  if (!signerWorkflow) throw new Error('crearAttestationVerifierReal: signerWorkflow requerido');
+  const ghPath = normalizarTextoNoVacio(opciones.ghPath) || 'gh';
+  const timeoutMs = Number.isFinite(opciones.timeoutMs) ? opciones.timeoutMs : GH_TIMEOUT_MS_DEFAULT;
+  const fsDeps = opciones.fsDeps || fs;
+  const ejecutor = opciones.ejecutor || ejecutorGhReal(ghPath, timeoutMs);
+
+  return async function attestationVerifier(bundle, expectedArtifactDigest, artifactBytes) {
+    if (!esBufferCrudo(bundle)) throw new Error('adaptador: bundle debe ser bytes crudos no vacíos');
+    if (!SHA256_HEX.test(expectedArtifactDigest || '')) throw new Error('adaptador: digest esperado inválido');
+    if (typeof artifactBytes !== 'string' || artifactBytes.length === 0) {
+      throw new Error('adaptador: artifactBytes debe ser string no vacío');
+    }
+    // Cross-check barato antes de tocar `gh`: los bytes recibidos DEBEN hashear
+    // al digest que el núcleo derivó del contenido (C1).
+    const digestBytes = crypto.createHash('sha256').update(artifactBytes, 'utf8').digest('hex');
+    if (digestBytes !== expectedArtifactDigest) {
+      throw new Error('adaptador: sha256(artifactBytes) no coincide con expectedArtifactDigest');
+    }
+
+    const dirTmp = fsDeps.mkdtempSync(path.join(os.tmpdir(), 'swl-w4-attest-'));
+    try {
+      const rutaArtefacto = escribirTemporal(fsDeps, dirTmp, 'verdict-sin-firma.ijson', artifactBytes);
+      const rutaBundle = escribirTemporal(fsDeps, dirTmp, 'attestation.sigstore.json', bundle);
+      const args = [
+        'attestation', 'verify', rutaArtefacto,
+        '--bundle', rutaBundle,
+        '--owner', owner,
+        '--signer-workflow', signerWorkflow,
+        '--digest-alg', 'sha256',
+        '--format', 'json',
+      ];
+      const salida = ejecutor(args); // lanza si exit != 0
+      const identidadOIDC = mapearIdentidad(JSON.parse(salida));
+      return { identidadOIDC, firmaValida: true };
+    } finally {
+      try {
+        fsDeps.rmSync(dirTmp, { recursive: true, force: true });
+      } catch {
+        // limpieza best-effort; no enmascara el resultado de la verificación.
+      }
+    }
+  };
+}
+
+module.exports = {
+  crearAttestationVerifierReal,
+  mapearIdentidad,
+  GH_TIMEOUT_MS_DEFAULT,
+};

package/scripts/lib/w4-canario.js

@@ -0,0 +1,337 @@
+'use strict';
+
+/**
+ * Gate de canario de campo (ADR-0050 § meta-SLO, F32/T-11, REQ-32-11): el
+ * lado JUEZ que consume evidencia de campo ya agregada por runtime y exige
+ * SIMULTÁNEAMENTE >=1,000 sesiones y >=7 días reales por runtime, sobre los
+ * tres runtimes Core-3 (`scripts/lib/w4-runtimes-core3.js`).
+ *
+ * Fail-closed sin compensación en tres ejes, todos AND — cero promedio,
+ * ponderación o suma:
+ *   (1) por runtime: `sesiones>=1000 && dias>=7 && procedencia==='real'`.
+ *       Un mínimo sin el otro (días sin volumen, o volumen sin días) NO
+ *       certifica — nunca se promedian volumen y días.
+ *   (2) entre runtimes: `certifica = RUNTIMES_CORE3.every(d => d.pass)`.
+ *       Dos runtimes perfectos NUNCA compensan un tercero fallido.
+ *   (3) procedencia: sólo el literal exacto `'real'` habilita `pass`;
+ *       `'sintetica'`, ausente o cualquier otro valor reprueba — las
+ *       sesiones sintéticas no sustituyen el mínimo temporal ni el volumen
+ *       de campo (ADR-0050 § meta-SLO).
+ *
+ * FRONTERA DE HONESTIDAD (mismo patrón que `w4-claims.js` § T-09): este
+ * módulo sólo LEE la marca `procedencia` que trae la evidencia de campo —
+ * los *datos* reales dependen de W6/W7, explícitamente NO autorizados en
+ * F32 (32-PLAN.md § Tanda W4-M). T-11 no puede cerrar un canario real por
+ * sí sola. Ningún dato marcado `'sintetica'`, ausente, o sin marca de
+ * origen genuina produce `certifica:true` — el resultado honesto por
+ * defecto es `certifica:false` + `evidenciaInsuficiente:true`.
+ *
+ * Anti-gaming (`~/.claude/rules/seguridad-agentes.md § Anti-gaming`): ni
+ * `evaluarGateCanario` ni el ingestor `normalizarEvidenciaCampo` exponen un
+ * parámetro para inyectar `procedencia:'real'` fabricada por el propio
+ * evaluado — la marca la porta la evidencia de campo, copiada tal cual la
+ * declaró el pipeline de origen. El vector residual (un CALLER de
+ * `normalizarEvidenciaCampo` que suministre registros con
+ * `procedencia:'real'` sintética) NO lo cierra este módulo: lo contiene el
+ * pipeline protegido W6/W7, que es quien debe garantizar que la marca sea
+ * genuina antes de entregarle registros a este ingestor. Se documenta como
+ * frontera, no se cierra aquí, y NUNCA se convierte en un `pass` fabricado
+ * por este módulo.
+ *
+ * Puro: cero `fs`, cero `net`/`dns`, cero reloj de pared, cero
+ * aleatoriedad. `evaluarGateCanario` NUNCA lanza — todo borde de fallo
+ * (evidencia malformada, tipo inesperado, excepción interna) retorna
+ * `certifica:false` (fail-closed), igual que `w4-scorer-certificacion.js`.
+ */
+
+const {
+  RUNTIMES_CORE3,
+  SESIONES_MIN_CANARIO: SESIONES_MIN,
+  DIAS_MIN_CANARIO: DIAS_MIN,
+} = require('./w4-runtimes-core3');
+
+const SCHEMA_VERSION = '1.0.0';
+const KIND_EVIDENCIA = 'swl-field-evidence';
+const PROCEDENCIA_REAL = 'real';
+const PROCEDENCIA_SINTETICA = 'sintetica';
+const PROCEDENCIAS_VALIDAS = Object.freeze([PROCEDENCIA_REAL, PROCEDENCIA_SINTETICA]);
+
+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 congelarProfundo(valor) {
+  if (valor && typeof valor === 'object' && !Object.isFrozen(valor)) {
+    Object.values(valor).forEach(congelarProfundo);
+    Object.freeze(valor);
+  }
+  return valor;
+}
+
+// ---------------------------------------------------------------------------
+// § 1 Lectura defensiva de campos — nunca delega en un wrapper genérico:
+// floats, strings coercibles, NaN, Infinity y negativos jamás pasan `>=`
+// por coerción implícita de JS (evita que un no-entero por encima del
+// umbral evada el gate).
+// ---------------------------------------------------------------------------
+
+function leerEntero(valor) {
+  if (typeof valor !== 'number') return null;
+  if (!Number.isFinite(valor)) return null;
+  if (!Number.isInteger(valor)) return null;
+  if (valor < 0) return null;
+  return valor;
+}
+
+function leerProcedencia(valor) {
+  return PROCEDENCIAS_VALIDAS.includes(valor) ? valor : null;
+}
+
+// ---------------------------------------------------------------------------
+// § 2 Evaluación por runtime — regla dura: `ausente===true` fuerza
+// `pass:false` SIEMPRE, sin importar qué calculen las tres condiciones.
+// ---------------------------------------------------------------------------
+
+function construirMotivoRuntime(runtime, datos) {
+  const { ausente, cumpleVolumen, cumpleDias, cumpleProcedenciaReal, sesiones, dias, procedencia } = datos;
+  if (ausente) {
+    return `${runtime}: evidencia ausente o inválida (sesiones=${sesiones ?? 'inválido/ausente'}, `
+      + `dias=${dias ?? 'inválido/ausente'}, procedencia=${procedencia ?? 'inválida/ausente'})`;
+  }
+  if (cumpleVolumen && cumpleDias && cumpleProcedenciaReal) {
+    return `${runtime}: cumple (sesiones=${sesiones}>=${SESIONES_MIN}, dias=${dias}>=${DIAS_MIN}, procedencia=real)`;
+  }
+  const fallas = [];
+  if (!cumpleVolumen) fallas.push(`VOLUMEN insuficiente (sesiones=${sesiones}<${SESIONES_MIN})`);
+  if (!cumpleDias) fallas.push(`DÍAS insuficientes (dias=${dias}<${DIAS_MIN})`);
+  if (!cumpleProcedenciaReal) fallas.push(`PROCEDENCIA no es 'real' (procedencia=${procedencia})`);
+  return `${runtime}: no cumple — ${fallas.join('; ')}`;
+}
+
+/**
+ * Evalúa un runtime individual del gate. `ausente` cubre tanto la clave
+ * `porRuntime[runtime]` faltante como cualquier campo malformado dentro de
+ * ella (equivalencia "inválido == ausente": un `sesiones`/`dias` no-entero
+ * o una `procedencia` fuera de `{'real','sintetica'}` deja el runtime sin
+ * evidencia suficiente para decidir, no sólo "por debajo del umbral").
+ */
+function evaluarRuntime(runtime, entradaCruda) {
+  const entrada = esObjetoPlano(entradaCruda) ? entradaCruda : null;
+  const sesiones = entrada ? leerEntero(entrada.sesiones) : null;
+  const dias = entrada ? leerEntero(entrada.dias) : null;
+  const procedencia = entrada ? leerProcedencia(entrada.procedencia) : null;
+  const ausente = entrada === null || sesiones === null || dias === null || procedencia === null;
+
+  const cumpleVolumen = sesiones !== null && sesiones >= SESIONES_MIN;
+  const cumpleDias = dias !== null && dias >= DIAS_MIN;
+  const cumpleProcedenciaReal = procedencia === PROCEDENCIA_REAL;
+  const pass = ausente ? false : (cumpleVolumen && cumpleDias && cumpleProcedenciaReal);
+
+  const datos = { ausente, cumpleVolumen, cumpleDias, cumpleProcedenciaReal, sesiones, dias, procedencia };
+  return congelarProfundo({
+    runtime, sesiones, dias, procedencia,
+    cumpleVolumen, cumpleDias, cumpleProcedenciaReal, ausente, pass,
+    motivo: construirMotivoRuntime(runtime, datos),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// § 3 Agregador — itera SIEMPRE la constante de longitud fija RUNTIMES_CORE3
+// (nunca `Object.keys(porRuntime)`): un runtime faltante no puede
+// "desaparecer" del arreglo y colar un `.every()` vacuamente verdadero
+// sobre 2 elementos en vez de 3.
+// ---------------------------------------------------------------------------
+
+function esEvidenciaCampoValida(evidenciaCampo) {
+  return esObjetoPlano(evidenciaCampo)
+    && evidenciaCampo.kind === KIND_EVIDENCIA
+    && esObjetoPlano(evidenciaCampo.porRuntime);
+}
+
+function resultadoDesdeDetalle(detallePorRuntime) {
+  const certifica = detallePorRuntime.every((d) => d.pass);
+  const evidenciaInsuficiente = detallePorRuntime.some((d) => d.ausente);
+  const razonFallo = certifica
+    ? null
+    : detallePorRuntime.filter((d) => !d.pass).map((d) => d.motivo).join(' | ');
+  return congelarProfundo({ certifica, evidenciaInsuficiente, detallePorRuntime, razonFallo });
+}
+
+/**
+ * `evaluarGateCanario(evidenciaCampo) -> ResultadoGateCanario`. Función
+ * PURA, salida deeply-frozen, NUNCA lanza: cualquier entrada malformada —
+ * incluida una excepción inesperada durante la evaluación — se trata como
+ * evidencia ausente para los 3 runtimes (fail-closed absoluto).
+ */
+function evaluarGateCanario(evidenciaCampo) {
+  try {
+    const porRuntime = esEvidenciaCampoValida(evidenciaCampo) ? evidenciaCampo.porRuntime : {};
+    const detallePorRuntime = RUNTIMES_CORE3.map((runtime) => evaluarRuntime(runtime, porRuntime[runtime]));
+    return resultadoDesdeDetalle(detallePorRuntime);
+  } catch (_error) {
+    const detallePorRuntime = RUNTIMES_CORE3.map((runtime) => evaluarRuntime(runtime, null));
+    return resultadoDesdeDetalle(detallePorRuntime);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// § 4 Ingestor — agrega registros de campo crudos por runtime. NUNCA
+// fabrica `procedencia:'real'`: sólo la copia si el pipeline de origen la
+// declaró de forma consistente en TODOS los registros de ese runtime.
+// ---------------------------------------------------------------------------
+
+/**
+ * Resuelve la `procedencia` agregada de un runtime a partir de sus
+ * registros crudos. Ambigua (marcas mixtas) o ausente en cualquier
+ * registro => `null` (sin declarar) — jamás se "adivina" ni se completa
+ * con `'real'` por mayoría ni por defecto.
+ */
+function procedenciaConsensuada(registros) {
+  if (registros.length === 0) return null;
+  const marcas = new Set(registros.map((r) => r.procedencia));
+  if (marcas.size !== 1) return null;
+  const [unica] = marcas;
+  return PROCEDENCIAS_VALIDAS.includes(unica) ? unica : null;
+}
+
+function agregarRegistrosRuntime(registros) {
+  const sesiones = registros.length;
+  const diasDistintos = new Set(
+    registros.map((r) => r.dia).filter((dia) => typeof dia === 'string' && dia.length > 0)
+  );
+  const entrada = { sesiones, dias: diasDistintos.size };
+  const procedencia = procedenciaConsensuada(registros);
+  if (procedencia !== null) entrada.procedencia = procedencia;
+  return entrada;
+}
+
+/**
+ * `normalizarEvidenciaCampo(registrosCrudos) -> evidenciaCampo`. Único
+ * parámetro — sin superficie para que un caller inyecte `procedencia`
+ * fabricada vía un segundo argumento de "opciones" (anti-gaming: la marca
+ * sólo puede venir dentro de cada registro, tal como la declaró W6/W7).
+ * `sesiones` = conteo de registros del runtime; `dias` = días calendario
+ * DISTINTOS con actividad (nunca un span sintético entre `desde`/`hasta`).
+ */
+function normalizarEvidenciaCampo(registrosCrudos) {
+  const registros = Array.isArray(registrosCrudos) ? registrosCrudos : [];
+  const porRuntime = {};
+  for (const runtime of RUNTIMES_CORE3) {
+    const propios = registros.filter((r) => esObjetoPlano(r) && r.runtime === runtime);
+    porRuntime[runtime] = agregarRegistrosRuntime(propios);
+  }
+  return congelarProfundo({ kind: KIND_EVIDENCIA, schemaVersion: SCHEMA_VERSION, porRuntime });
+}
+
+// ---------------------------------------------------------------------------
+// § 5 validateResultadoGateCanario — validación sin efectos del shape de
+// salida (plantilla: `validateScoringReport` de `w4-scorer-certificacion.js`).
+// A diferencia de `evaluarGateCanario`, ESTA función SÍ lanza ante shape
+// inválido — es un validador de contrato, no el juez fail-closed.
+// ---------------------------------------------------------------------------
+
+const RESULTADO_KEYS = Object.freeze(['certifica', 'evidenciaInsuficiente', 'detallePorRuntime', 'razonFallo']);
+const DETALLE_KEYS = Object.freeze([
+  'runtime', 'sesiones', 'dias', 'procedencia',
+  'cumpleVolumen', 'cumpleDias', 'cumpleProcedenciaReal', 'ausente', 'pass', 'motivo',
+]);
+const DETALLE_CAMPOS_BOOLEANOS = Object.freeze([
+  'cumpleVolumen', 'cumpleDias', 'cumpleProcedenciaReal', 'ausente', 'pass',
+]);
+
+function validarClaves(valor, esperadas, etiqueta) {
+  if (!esObjetoPlano(valor)) fallar('GATE_CANARIO_INVALID', `${etiqueta} inválido`);
+  const actuales = Object.keys(valor).sort();
+  const objetivo = [...esperadas].sort();
+  if (JSON.stringify(actuales) !== JSON.stringify(objetivo)) {
+    fallar('GATE_CANARIO_INVALID', `${etiqueta} inválido`);
+  }
+}
+
+function validarEnteroOpcional(valor, etiqueta) {
+  if (valor !== null && !(Number.isInteger(valor) && valor >= 0)) {
+    fallar('GATE_CANARIO_INVALID', `${etiqueta} inválido`);
+  }
+}
+
+function validarDetalleRuntime(detalle, etiqueta) {
+  validarClaves(detalle, DETALLE_KEYS, etiqueta);
+  if (typeof detalle.runtime !== 'string' || !RUNTIMES_CORE3.includes(detalle.runtime)) {
+    fallar('GATE_CANARIO_INVALID', `${etiqueta}.runtime inválido`);
+  }
+  validarEnteroOpcional(detalle.sesiones, `${etiqueta}.sesiones`);
+  validarEnteroOpcional(detalle.dias, `${etiqueta}.dias`);
+  if (detalle.procedencia !== null && !PROCEDENCIAS_VALIDAS.includes(detalle.procedencia)) {
+    fallar('GATE_CANARIO_INVALID', `${etiqueta}.procedencia inválido`);
+  }
+  for (const campo of DETALLE_CAMPOS_BOOLEANOS) {
+    if (typeof detalle[campo] !== 'boolean') fallar('GATE_CANARIO_INVALID', `${etiqueta}.${campo} inválido`);
+  }
+  if (typeof detalle.motivo !== 'string' || detalle.motivo.length === 0) {
+    fallar('GATE_CANARIO_INVALID', `${etiqueta}.motivo inválido`);
+  }
+  if (detalle.ausente && detalle.pass !== false) {
+    fallar('GATE_CANARIO_INVALID', `${etiqueta}: ausente implica pass:false`);
+  }
+}
+
+/**
+ * Valida un `ResultadoGateCanario` sin efectos. Lanza `GATE_CANARIO_INVALID`
+ * si el valor no cumple el shape o sus invariantes cruzadas (`certifica`
+ * coherente con `detallePorRuntime`, `razonFallo` presente sólo cuando
+ * `certifica:false`); retorna un valor deeply-frozen equivalente si es válido.
+ */
+function validateResultadoGateCanario(value) {
+  validarClaves(value, RESULTADO_KEYS, 'resultadoGateCanario');
+  if (typeof value.certifica !== 'boolean') fallar('GATE_CANARIO_INVALID', 'certifica inválido');
+  if (typeof value.evidenciaInsuficiente !== 'boolean') {
+    fallar('GATE_CANARIO_INVALID', 'evidenciaInsuficiente inválido');
+  }
+  if (!Array.isArray(value.detallePorRuntime) || value.detallePorRuntime.length !== RUNTIMES_CORE3.length) {
+    fallar('GATE_CANARIO_INVALID', 'detallePorRuntime inválido');
+  }
+  value.detallePorRuntime.forEach((d, i) => validarDetalleRuntime(d, `detallePorRuntime[${i}]`));
+  const runtimesRecibidos = value.detallePorRuntime.map((d) => d.runtime);
+  if (JSON.stringify(runtimesRecibidos) !== JSON.stringify(RUNTIMES_CORE3)) {
+    fallar('GATE_CANARIO_INVALID', 'detallePorRuntime debe cubrir RUNTIMES_CORE3 en orden canónico');
+  }
+  if (value.razonFallo !== null && (typeof value.razonFallo !== 'string' || value.razonFallo.length === 0)) {
+    fallar('GATE_CANARIO_INVALID', 'razonFallo inválido');
+  }
+
+  const certificaEsperado = value.detallePorRuntime.every((d) => d.pass);
+  if (value.certifica !== certificaEsperado) fallar('GATE_CANARIO_INVALID', 'certifica no coincide con detallePorRuntime');
+  const evidenciaInsuficienteEsperada = value.detallePorRuntime.some((d) => d.ausente);
+  if (value.evidenciaInsuficiente !== evidenciaInsuficienteEsperada) {
+    fallar('GATE_CANARIO_INVALID', 'evidenciaInsuficiente no coincide con detallePorRuntime');
+  }
+  if (value.certifica && value.razonFallo !== null) fallar('GATE_CANARIO_INVALID', 'certifica:true exige razonFallo null');
+  if (!value.certifica && value.razonFallo === null) {
+    fallar('GATE_CANARIO_INVALID', 'certifica:false exige razonFallo no-null');
+  }
+
+  return congelarProfundo(JSON.parse(JSON.stringify(value)));
+}
+
+module.exports = {
+  DIAS_MIN,
+  PROCEDENCIA_REAL,
+  PROCEDENCIA_SINTETICA,
+  RUNTIMES_CORE3,
+  SESIONES_MIN,
+  evaluarGateCanario,
+  normalizarEvidenciaCampo,
+  validateResultadoGateCanario,
+};

package/scripts/lib/w4-claims.js

@@ -0,0 +1,182 @@
+'use strict';
+
+/**
+ * Generador del claim público de certificación (ADR-0053, F32/T-10,
+ * REQ-32-10). Envuelve `verificarVeredicto` (T-06/T-09) — NUNCA reimplementa
+ * la lógica de firma/origen/request — y sólo proyecta un claim sanitizado
+ * cuando la verificación GENUINA confirma `ok:true && certifica:true`.
+ *
+ * Contrato anti-gaming (`~/.claude/rules/seguridad-agentes.md § Anti-gaming`,
+ * "el agente evaluado NUNCA produce ni edita la evidencia que lo aprueba"):
+ * la firma acepta EXACTAMENTE `(verdict, opcionesVerificacion)` — el mismo
+ * shape que exige `verificarVeredicto`. No existe parámetro para un
+ * resultado ya-verificado, un score crudo ni un `{ok:true}` fabricado a
+ * mano: el maker no tiene superficie donde inyectar evidencia
+ * pre-computada. `generarClaim` re-corre la verificación completa en cada
+ * llamada — nunca confía en nada que el caller afirme sobre el veredicto.
+ *
+ * Vector residual documentado (no cerrado por este módulo): el CALLER de
+ * `generarClaim` controla `opcionesVerificacion` (`attestationVerifier` +
+ * `pinOrigen`). Un maker con acceso local podría invocar este módulo con un
+ * stub que retorne `firmaValida:true` e `identidadOIDC` igual a un
+ * `pinOrigen` que él mismo suministra — ese vector NO lo cierra T-10, lo
+ * contiene el entorno protegido de T-09 (environment `certificacion`,
+ * deployment branch policy, secret sólo a nivel environment, aprobación
+ * humana separada — 32-PLAN.md § Tanda W4-K, H-3/H-4/H-7). T-09 está
+ * bloqueada en el momento de escribir este módulo; la integración real que
+ * cierra el vector residual queda pendiente de su propio gate, no del de
+ * T-10. El claim aquí producido hereda la misma frontera de honestidad C3a
+ * que `verificarVeredicto`: ningún `ok:true` obtenido con un
+ * `attestationVerifier` simulado constituye "origen verificado" en el
+ * sentido de ADR-0053. Misma dependencia que la DT ya registrada
+ * `DT-T06-BINDING-C1-DELEGADO-A-ADAPTADOR-T09`
+ * (`.planning/DEUDA-TECNICA.md`) — no se abre una DT nueva para T-10.
+ *
+ * `claimDigest` es INTEGRIDAD-EN-TRÁNSITO, no autenticación: es un sha256
+ * auto-referencial que cualquiera puede recomputar sobre el propio claim
+ * (detecta corrupción/alteración accidental en tránsito). La autenticación
+ * real del claim es `verdictDigest`, que ata el claim al `CertificationVerdict`
+ * ya verificado por attestation Sigstore dentro de `verificarVeredicto`. Este
+ * módulo NO firma el sobre del claim para consumo de terceros — esa firma
+ * (envelope signing para publicación downstream) es responsabilidad de W6/T-11.
+ *
+ * Puro: cero fs, cero red, cero reloj — hereda esa pureza de
+ * `verificarVeredicto`/`validateCertificationVerdict`. Nunca lanza: todo
+ * borde de fallo, incluida cualquier excepción inesperada en la proyección
+ * final, retorna `{ok:false, codigo}` (fail-closed).
+ */
+
+const crypto = require('node:crypto');
+
+const verificadorModulo = require('./w4-verificar-veredicto');
+const { evaluarRevocacion } = require('./w4-revocacion');
+const { canonicalizarIJson } = require('./signed-envelope');
+
+const CLAIM_VERSION = '1.0.0';
+
+const CODIGOS = Object.freeze({
+  VERIFICACION_FALLIDA: 'CLAIM_VERIFICACION_FALLIDA',
+  NO_CERTIFICA: 'CLAIM_NO_CERTIFICA',
+  REVOCADO: 'CLAIM_REVOCADO',
+});
+
+// Whitelist estructural (AD-1): el claim se construye campo-por-campo desde
+// `resultado.verdict`/`resultado.identidadOIDC` — nunca por spread/copy —
+// para que un campo nuevo agregado al schema del veredicto NUNCA se filtre
+// al claim público por evolución silenciosa del schema. Esta lista es la
+// única fuente de verdad del conjunto de claves emitidas.
+const CLAIM_KEYS = [
+  'kind', 'claimVersion', 'certifica', 'runId', 'commit', 'tarballDigest',
+  'matrix', 'dimensiones', 'metaSlo', 'firmante', 'emitidoEn', 'verdictDigest',
+  'claimDigest',
+];
+
+function congelarProfundo(valor) {
+  if (valor && typeof valor === 'object' && !Object.isFrozen(valor)) {
+    Object.values(valor).forEach(congelarProfundo);
+    Object.freeze(valor);
+  }
+  return valor;
+}
+
+function rechazo(codigo, causa) {
+  return Object.freeze(causa === undefined ? { ok: false, codigo } : { ok: false, codigo, causa });
+}
+
+// Proyección campo-por-campo de una entrada de dimensión SANITIZADA: sólo
+// {dimension, slo, pass} — deliberadamente SIN `medido` (el badge publica
+// pass/slo, no los números crudos que serían fingerprint del corpus).
+function proyectarDimension(dimensionVerdict) {
+  return {
+    dimension: dimensionVerdict.dimension,
+    slo: dimensionVerdict.slo,
+    pass: dimensionVerdict.pass,
+  };
+}
+
+function proyectarClaimSinDigest(verdict, identidadOIDC) {
+  return {
+    kind: 'swl-certification-claim',
+    claimVersion: CLAIM_VERSION,
+    certifica: true, // materializado explícito tras la puerta de emisión, no copiado del input.
+    runId: verdict.runId,
+    commit: verdict.request.commit,
+    tarballDigest: verdict.request.tarballDigest,
+    matrix: verdict.request.matrix.map((entrada) => ({
+      runtime: entrada.runtime, os: entrada.os, model: entrada.model,
+    })),
+    dimensiones: verdict.dimensiones.map(proyectarDimension),
+    metaSlo: proyectarDimension(verdict.metaSlo),
+    firmante: { repo: identidadOIDC.repo, workflow: identidadOIDC.workflow, ref: identidadOIDC.ref },
+    emitidoEn: verdict.emitidoEn,
+    verdictDigest: verificadorModulo.digestVerdictSinFirma(verdict),
+  };
+}
+
+/**
+ * Genera el claim público de certificación a partir de un `CertificationVerdict`
+ * crudo. Nunca lanza; ver el docstring del módulo para el contrato anti-gaming
+ * completo.
+ *
+ * @param {unknown} verdict - CertificationVerdict crudo, tal cual lo emitió
+ *   `w4-veredicto.js#emitirVeredicto`. NUNCA un resultado pre-verificado.
+ * @param {{pinOrigen: unknown, requestEsperado: unknown,
+ *   attestationVerifier: Function, bundle: unknown}} opcionesVerificacion -
+ *   mismo shape exacto que exige `verificarVeredicto`.
+ * @returns {Promise<{ok:true, claim: object} | {ok:false, codigo:string, causa?:string}>}
+ */
+async function generarClaim(verdict, opcionesVerificacion) {
+  // AD-3: guarda fail-closed sobre el CUERPO COMPLETO — la llamada a
+  // `verificarVeredicto` (que internamente usa `crypto.createHash` sin su
+  // propio try/catch para el digest del bundle, C7) Y el paso de
+  // proyección/digest del claim. El invariante "NUNCA lanza" no admite
+  // excepciones de borde en ninguno de los dos pasos.
+  try {
+    const resultado = await verificadorModulo.verificarVeredicto(verdict, opcionesVerificacion);
+
+    // `resultado.codigo` propagado en `causa` es DIAGNÓSTICO INTERNO / telemetría
+    // (para logs de CI y debugging del propio pipeline), NUNCA dato publicable a
+    // un consumidor no confiable. El caller actual de este módulo es CI confiable;
+    // al cruzar cualquier frontera hacia publicación downstream (W6/T-11) esta
+    // causa granular (VERDICT_ORIGIN_MISMATCH, VERDICT_SIGNATURE_INVALID, etc.)
+    // debe colapsarse a un código genérico — exponerla tal cual a un atacante
+    // forma un oráculo de verificación que le permite afinar iterativamente sus
+    // intentos de forja (qué chequeo exacto falló, en qué orden).
+    if (resultado.ok !== true) return rechazo(CODIGOS.VERIFICACION_FALLIDA, resultado.codigo);
+    if (resultado.certifica !== true) return rechazo(CODIGOS.NO_CERTIFICA);
+
+    // T-12: revocación automática. Si el caller provee `estadoActual`, un drift
+    // (commit/matrix/dataset/seed) o un canario fallido revoca la etiqueta —
+    // el claim NO se emite aunque el veredicto sea auténtico y certifique.
+    // Sin `estadoActual` no se evalúa revocación (el caller decide qué observa).
+    if (opcionesVerificacion && opcionesVerificacion.estadoActual !== undefined) {
+      const revocacion = evaluarRevocacion(resultado.verdict, opcionesVerificacion.estadoActual);
+      if (revocacion.revocado) return rechazo(CODIGOS.REVOCADO, revocacion.motivos.join(','));
+    }
+
+    const claimSinDigest = proyectarClaimSinDigest(resultado.verdict, resultado.identidadOIDC);
+    const claimDigest = crypto.createHash('sha256')
+      .update(canonicalizarIJson(claimSinDigest), 'utf8')
+      .digest('hex');
+    // Self-check de consistencia INTERNA de refactor: compara CLAIM_KEYS (la
+    // whitelist declarada) contra las claves que `proyectarClaimSinDigest`
+    // realmente construyó — detecta que ambas listas diverjan por un cambio
+    // futuro no sincronizado. NO es un gate de seguridad contra input externo
+    // (el input externo ya pasó por AD-1: proyección campo-por-campo, nunca spread).
+    const claveEsperadaConjunto = JSON.stringify([...CLAIM_KEYS].sort());
+    const claveObtenidaConjunto = JSON.stringify([...Object.keys(claimSinDigest), 'claimDigest'].sort());
+    if (claveEsperadaConjunto !== claveObtenidaConjunto) {
+      return rechazo(CODIGOS.VERIFICACION_FALLIDA, 'CLAIM_PROYECCION_INESPERADA');
+    }
+    return Object.freeze({ ok: true, claim: congelarProfundo({ ...claimSinDigest, claimDigest }) });
+  } catch {
+    return rechazo(CODIGOS.VERIFICACION_FALLIDA, 'CLAIM_PROYECCION_INESPERADA');
+  }
+}
+
+module.exports = {
+  CODIGOS,
+  CLAIM_VERSION,
+  CLAIM_KEYS,
+  generarClaim,
+};