@saulwade/swl-ses 2.6.1 → 2.8.0

package/scripts/lib/w4-pin-origen.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * `pinOrigen` — identidad OIDC ESPERADA del workflow protegido de `swl-eval`
+ * que firma los `CertificationVerdict` (T-09, REQ-32-09, ADR-0053 pieza 5,
+ * ADR-0056 § pinOrigen bajo gobernanza).
+ *
+ * ES UNA CONSTANTE COMMITEADA, NUNCA UN INPUT DE RUNTIME. La revisión
+ * adversarial de T-09 mostró que si el candidato pudiera fijar `pinOrigen` en
+ * ejecución, la raíz de confianza criptográfica colapsaría a una auto-aserción
+ * del evaluado (`seguridad-agentes.md § Anti-gaming`). Por eso vive aquí,
+ * congelado; cambiarlo es un CAMBIO DE SEGURIDAD que exige PR revisado
+ * (gobernanza.md § alto riesgo), no una edición silenciosa.
+ *
+ * FORMAS DE STRING — PENDIENTES DE GOLDEN BUNDLE: `repo`/`workflow`/`ref`
+ * usan las formas de las extensiones del certificado Sigstore de GitHub
+ * Actions (`sourceRepositoryURI`, `buildSignerURI`, `sourceRepositoryRef`),
+ * que `w4-attestation-adapter.js#mapearIdentidad` extrae. Las formas EXACTAS
+ * se anclan contra un bundle real en el tramo real (ver
+ * DT-T06-BINDING-C1-DELEGADO-A-ADAPTADOR-T09). El test viviente
+ * `tests/lib/w4-pin-origen.test.js` asevera que el pin y el mapeo del
+ * adaptador coinciden en forma — cuando exista el golden bundle, ese test se
+ * ancla además contra la identidad OIDC real.
+ */
+
+// Config del adaptador (`--owner`, `--signer-workflow`). El owner canónico es
+// la ORG `saul-wade` (donde vive swl-eval); difiere de CODEOWNERS
+// `@saulwadeleon` (el usuario) — resuelto por escrito en ADR-0056.
+const OWNER = 'saul-wade';
+const REPO = 'saul-wade/swl-eval';
+const RUTA_WORKFLOW = '.github/workflows/certificacion.yml';
+const REF = 'refs/heads/main';
+
+// Valor para `gh attestation verify --signer-workflow`, que EXIGE el formato
+// completo `[host/]<owner>/<repo>/<path>/<to>/<workflow>` (verificado en gh
+// v2.89.0) — no basta la ruta del workflow. Sin el prefijo owner/repo, gh no
+// casa la identidad y TODO veredicto real caería en VERDICT_SIGNATURE_INVALID.
+const SIGNER_WORKFLOW = `${REPO}/${RUTA_WORKFLOW}`;
+
+// Identidad OIDC esperada, en las formas que produce mapearIdentidad().
+const PIN_ORIGEN = Object.freeze({
+  repo: `https://github.com/${REPO}`,
+  workflow: `https://github.com/${REPO}/${RUTA_WORKFLOW}@${REF}`,
+  ref: REF,
+});
+
+module.exports = {
+  PIN_ORIGEN,
+  OWNER,
+  REPO,
+  RUTA_WORKFLOW,
+  SIGNER_WORKFLOW,
+  REF,
+};

package/scripts/lib/w4-publicar-request.js

@@ -0,0 +1,132 @@
+'use strict';
+
+/**
+ * Builder PURO del `CertificationRequest` que `swl-ses` (candidato) publica
+ * hacia `swl-eval` (juez) — T-09, REQ-32-09, ADR-0053 § Contrato. Sin efectos:
+ * no lee disco, no hace red, no consulta el reloj. Los efectos (derivar el
+ * commit de git, el `tarballDigest` de `npm pack`, escribir el JSON) viven en
+ * el CLI `scripts/publicar-certification-request.js`.
+ *
+ * `entryPoint` por defecto apunta a la superficie del CANDIDATO
+ * (`runHarnessBajoPrueba`), que el juez instancia DESDE EL TARBALL bajo prueba
+ * (nunca desde una copia pineada — ADR-0056 § vendor sin superficie del
+ * candidato). La validación es la autoritativa de `validateCertificationRequest`
+ * (incluye unicidad de matrix y NFKC, no expresables en JSON Schema puro).
+ */
+
+const { validateCertificationRequest } = require('./w4-harness-bajo-prueba');
+
+const SCHEMA_VERSION = '1.0.0';
+const KIND = 'swl-certification-request';
+const GIT_SHA = /^[a-f0-9]{40}$/u;
+const SHA256 = /^[a-f0-9]{64}$/u;
+
+const ENTRYPOINT_DEFECTO = Object.freeze({
+  module: 'scripts/lib/w4-superficie-candidato.js',
+  function: 'runHarnessBajoPrueba',
+});
+
+function crearError(codigo, mensaje) {
+  const error = new Error(mensaje);
+  error.codigo = codigo;
+  return error;
+}
+
+function fallar(codigo, mensaje) {
+  throw crearError(codigo, mensaje);
+}
+
+/**
+ * Arma y valida el `CertificationRequest`. Lanza `CERTIFICATION_REQUEST_INVALID`
+ * si cualquier campo no cumple el contrato. Retorna el request deeply frozen.
+ *
+ * @param {{commit:string, tarballDigest:string, matrix:Array<{runtime,os,model}>,
+ *   entryPoint?:{module:string, function:string}}} opciones
+ */
+function construirRequest(opciones = {}) {
+  const { commit, tarballDigest, matrix, entryPoint = ENTRYPOINT_DEFECTO } = opciones;
+  return validateCertificationRequest({
+    kind: KIND,
+    schemaVersion: SCHEMA_VERSION,
+    candidate: { commit, tarballDigest },
+    matrix,
+    entryPoint,
+  });
+}
+
+/**
+ * Deriva el `requestEsperado` de anti-replay (C2) que consume
+ * `verificarVeredicto`: exactamente `{commit, tarballDigest, matrix}` con cada
+ * entrada `{runtime, os, model}`. Re-valida el request por robustez.
+ */
+function construirRequestEsperado(request) {
+  const validado = validateCertificationRequest(request);
+  return {
+    commit: validado.candidate.commit,
+    tarballDigest: validado.candidate.tarballDigest,
+    matrix: validado.matrix.map((entrada) => ({
+      runtime: entrada.runtime, os: entrada.os, model: entrada.model,
+    })),
+  };
+}
+
+/**
+ * Provee el mecanismo que cierra el Hueco A de la revisión adversarial de T-09
+ * (C-3): verifica el binding commit↔tarballDigest re-empaquetando el tarball
+ * DESDE el commit certificado (efecto inyectado `reempaquetar`) y aseverando que
+ * su sha256 coincide con el `tarballDigest` del request. El cierre extremo-a-
+ * extremo requiere que el workflow del juez en `swl-eval` invoque esta primitiva
+ * contra el tarball descargado (fuera de este repo, gateado); aquí sólo vive la
+ * primitiva reusable, fail-closed. Sin ella, un dispatcher podría atar un
+ * `tarballDigest` benigno a un `commit` malicioso y el veredicto lo firmaría
+ * igual (el schema valida ambos campos por separado, nunca su correspondencia).
+ * Fail-closed: cualquier error de `reempaquetar` o cualquier mismatch lanza;
+ * nunca aprueba por omisión.
+ *
+ * @param {string} commit git HEAD (40 hex) del candidato certificado.
+ * @param {string} tarballDigestEsperado sha256 (64 hex) declarado en el request.
+ * @param {(commit:string)=>string} reempaquetar puerto de efecto: reconstruye el
+ *   tarball desde el commit y devuelve su sha256 hex. Reproducible por diseño —
+ *   npm >=7 normaliza mtimes, así que el mismo commit con la misma versión de npm
+ *   produce el mismo digest; la costura de reproducibilidad se ancla en el tramo
+ *   real (misma imagen de runner) igual que el golden bundle de DT-T06-BINDING.
+ * @returns {true} si el binding es válido; de lo contrario lanza.
+ */
+function verificarBindingCommitTarball(commit, tarballDigestEsperado, reempaquetar) {
+  if (typeof commit !== 'string' || !GIT_SHA.test(commit)) {
+    fallar('TARBALL_COMMIT_BINDING_INVALID', 'commit inválido');
+  }
+  if (typeof tarballDigestEsperado !== 'string' || !SHA256.test(tarballDigestEsperado)) {
+    fallar('TARBALL_COMMIT_BINDING_INVALID', 'tarballDigest inválido');
+  }
+  if (typeof reempaquetar !== 'function') {
+    fallar('TARBALL_COMMIT_BINDING_INVALID', 'reempaquetar debe ser una función');
+  }
+  let digestReal;
+  try {
+    digestReal = reempaquetar(commit);
+  } catch (error) {
+    // Fail-closed: si el tarball no se puede reconstruir desde el commit, el
+    // binding NO está probado — nunca se acepta por omisión.
+    throw crearError(
+      'TARBALL_COMMIT_BINDING_UNVERIFIABLE',
+      `no se pudo re-empaquetar desde ${commit}: ${error.message}`
+    );
+  }
+  if (typeof digestReal !== 'string' || !SHA256.test(digestReal)) {
+    fallar('TARBALL_COMMIT_BINDING_UNVERIFIABLE', 'reempaquetar no devolvió un sha256 válido');
+  }
+  if (digestReal !== tarballDigestEsperado) {
+    fallar('TARBALL_COMMIT_BINDING_MISMATCH', `el tarball del request no proviene de ${commit}`);
+  }
+  return true;
+}
+
+module.exports = {
+  construirRequest,
+  construirRequestEsperado,
+  verificarBindingCommitTarball,
+  ENTRYPOINT_DEFECTO,
+  SCHEMA_VERSION,
+  KIND,
+};

package/scripts/lib/w4-revocacion.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * Revocación automática de la certificación (F32/T-12, REQ-32-12, ADR-0050).
+ * La etiqueta EXPIRA ante cualquier drift respecto a la matriz certificada
+ * (runtime/modelo/OS, commit del candidato, dataset/`tarballDigest`, o `seed`
+ * del corpus) o ante un canario fallido. Puro: sin `fs`/red/reloj; el efecto
+ * (leer el estado actual) vive en el caller.
+ *
+ * Reusa `evaluarGateCanario` (T-11) para la condición de canario — no
+ * reimplementa el gate. `evaluarRevocacion` NUNCA lanza: retorna
+ * `{revocado, motivos}` (motivos vacío ⇒ no revocado).
+ */
+
+const { evaluarGateCanario } = require('./w4-canario');
+
+function normalizarMatrix(matrix) {
+  return (Array.isArray(matrix) ? matrix : [])
+    .map((entrada) => `${entrada && entrada.runtime}|${entrada && entrada.os}|${entrada && entrada.model}`)
+    .sort();
+}
+
+function matrixDifiere(certificada, actual) {
+  return JSON.stringify(normalizarMatrix(certificada)) !== JSON.stringify(normalizarMatrix(actual));
+}
+
+/**
+ * @param {object} verdict - CertificationVerdict certificado (usa `.request`:
+ *   commit, tarballDigest, matrix — la matriz certificada).
+ * @param {{commit?:string, tarballDigest?:string, matrix?:Array,
+ *   seedFingerprintCertificado?:string, seedFingerprintActual?:string,
+ *   canario?:unknown}} estadoActual - estado observado hoy. Cada campo es
+ *   opcional: sólo se evalúa el drift de los campos provistos (un campo
+ *   ausente no revoca por sí mismo — el caller decide qué observa).
+ * @returns {{revocado:boolean, motivos:string[]}}
+ */
+function evaluarRevocacion(verdict, estadoActual = {}) {
+  const motivos = [];
+  const req = (verdict && typeof verdict === 'object' && verdict.request) || {};
+  const estado = (estadoActual && typeof estadoActual === 'object') ? estadoActual : {};
+
+  if (estado.commit !== undefined && estado.commit !== req.commit) {
+    motivos.push('commit-drift');
+  }
+  if (estado.tarballDigest !== undefined && estado.tarballDigest !== req.tarballDigest) {
+    motivos.push('dataset-drift');
+  }
+  if (estado.matrix !== undefined && matrixDifiere(req.matrix, estado.matrix)) {
+    motivos.push('matrix-drift');
+  }
+  if (estado.seedFingerprintCertificado !== undefined && estado.seedFingerprintActual !== undefined
+      && estado.seedFingerprintCertificado !== estado.seedFingerprintActual) {
+    motivos.push('seed-drift');
+  }
+  if (estado.canario !== undefined && evaluarGateCanario(estado.canario).certifica !== true) {
+    motivos.push('canario-fallido');
+  }
+
+  return { revocado: motivos.length > 0, motivos };
+}
+
+module.exports = { evaluarRevocacion };

package/scripts/lib/w4-runtimes-core3.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Constantes compartidas del corpus Core-3 (F32/W4): la lista canónica de
+ * runtimes soportados por certificación (ADR-0050) y los umbrales mínimos
+ * del gate de canario (T-11, REQ-32-11) que también consume el sub-check
+ * meta-SLO `canaryInput` (T-05, `scripts/lib/w4-scorer-certificacion.js`).
+ *
+ * Única fuente de estos literales — NUNCA replicarlos en otro módulo
+ * (`~/.claude/rules/arquitectura.md § DRY`). Antes de F32/T-11,
+ * `RUNTIMES_CORE3` vivía privado en `w4-scorer-certificacion.js` y los
+ * umbrales 1000/7 estaban inline en su sub-check `canaryInput`; ambos
+ * módulos ahora importan de aquí para que un cambio de umbral o de la
+ * lista de runtimes se propague en un solo lugar.
+ *
+ * Puro: cero `fs`/`net`/reloj/aleatoriedad.
+ */
+
+const RUNTIMES_CORE3 = Object.freeze(['claude-code', 'codex-cli', 'gemini-cli']);
+
+// Identificadores de OS (forma `process.platform`) de la matriz Core-3, en
+// orden estable para la generación de combos del CertificationRequest (T-09).
+// Los validadores que sólo checan pertenencia usan un `Set` derivado de esta
+// lista en su propio módulo; esta es la fuente ordenada canónica.
+const OS_CORE3 = Object.freeze(['win32', 'linux', 'darwin']);
+
+// ADR-0050 § meta-SLO (párrafo tras la tabla de 6 dimensiones): "canary de
+// al menos siete días y 1,000 sesiones de campo por runtime antes de
+// certificar un release mayor del harness". Umbrales inclusivos (>=).
+const SESIONES_MIN_CANARIO = 1000;
+const DIAS_MIN_CANARIO = 7;
+
+module.exports = Object.freeze({
+  RUNTIMES_CORE3,
+  OS_CORE3,
+  SESIONES_MIN_CANARIO,
+  DIAS_MIN_CANARIO,
+});