@saulwade/swl-ses 2.6.0 → 2.8.0

package/scripts/instalador.js

@@ -16,7 +16,13 @@
 const fs = require('fs');
 const path = require('path');
 
-const { obtenerRuntime, calcularRutas, resumenDeteccion, detectarInstalacionesDuales } = require('./lib/detectar-runtime');
+const {
+  calcularRutas,
+  detectarInstalacionesDuales,
+  obtenerEtiquetaConformidad,
+  obtenerRuntime,
+  resumenDeteccion,
+} = require('./lib/detectar-runtime');
 const { preguntarSiNo, ES_TTY } = require('./lib/ui');
 const { resolverPerfil, generarPlan } = require('./lib/manifiestos');
 const { crearEstado, registrarArchivo, registrarComponente, guardarEstado, cargarEstado } = require('./lib/estado');
@@ -41,6 +47,7 @@ const { canonicalHash } = require('./lib/canonical-hash');
 const { auditarEscritura } = require('./lib/audit-evolved');
 const { detectarStack, filtrarReglasPorStack } = require('./lib/detectar-stack');
 const { actualizarGitignore, entradasParaRuntime, limpiarTracked, leerManifest, escribirManifest } = require('./lib/gitignore-manifest');
+const { limpiarBasuraGlobal } = require('./lib/limpiar-basura-global');
 
 const RAIZ_PKG = path.resolve(__dirname, '..');
 const VERSION = require('../package.json').version;
@@ -199,9 +206,11 @@ async function install(opciones) {
     process.exit(1);
   }
 
-  if (runtime.soporte === 'parcial') {
-    console.log(`Nota: Runtime "${target}" (${runtime.nombre}) tiene soporte parcial — solo agentes y reglas.\n`);
-  }
+  const etiquetaConformidad = obtenerEtiquetaConformidad(target);
+  console.log(
+    `Conformidad: ${runtime.nombre} (${target}) = ${etiquetaConformidad}. ` +
+    'La disponibilidad del instalador no equivale a certificación del harness.\n'
+  );
 
   // 1b. Detectar conflicto dual-scope: instalar en un scope cuando el opuesto
   // ya tiene SWL instalado causa duplicación visible de comandos en la UI.
@@ -352,6 +361,18 @@ async function install(opciones) {
     }
   }
 
+  // Scope global: purgar directorios basura sembrados en el HOME por versiones
+  // previas: ~/.planning/ scaffold (doctor confundía el HOME con un proyecto por
+  // ~/_userland) y ~/_userland/ vacío. Conservador: solo el .planning con la
+  // huella del scaffold y el _userland sin plugins reales, nunca contenido del
+  // usuario. Ver scripts/lib/limpiar-basura-global.js.
+  if (esGlobal) {
+    const basura = limpiarBasuraGlobal();
+    if (basura.eliminados.length > 0) {
+      console.log(`\n[global] Basura purgada del HOME: ${basura.eliminados.join(', ')}.`);
+    }
+  }
+
   // 4. Detectar _userland/
   const userlandAgentes = path.join(process.cwd(), '_userland', 'agentes');
   const userlandHabilidades = path.join(process.cwd(), '_userland', 'habilidades');
@@ -1132,6 +1153,17 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     return { instalado: false, razon: `Target "${runtime.id}" no soporta "${archivo.tipo}"` };
   }
 
+  // Base de los backups de actualización. En install GLOBAL no se ancla a
+  // process.cwd(): si el usuario corre `install --global` desde su HOME, cwd es
+  // el HOME y los backups aterrizaban en ~/.planning/backups (bug 2026-07-15,
+  // sembraba un ~/.planning espurio). Se co-ubican con el scope global
+  // (~/.claude/.planning/backups) — el restore usa la rutaBackup absoluta
+  // guardada en el estado, así que reubicar la base es seguro. En install de
+  // proyecto, los backups viven en el proyecto (comportamiento correcto).
+  const rutaBackupBase = opciones.esGlobal
+    ? path.join(require('os').homedir(), '.claude')
+    : process.cwd();
+
   let dirDestino;
 
   switch (archivo.tipo) {
@@ -1317,7 +1349,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
 
       if (strategy.strategy === 'conflict') {
         // Población A — evolución del usuario. NUNCA overwrite: backup + merge (diff).
-        const backup = crearBackup(process.cwd(), cmpDestino, versionBackup);
+        const backup = crearBackup(rutaBackupBase, cmpDestino, versionBackup);
         if (!backup.respaldado) {
           console.log(`  ⚠ Backup falló (${backup.error || 'desconocido'}) para ${nombreArchivo} — merge abortado, original preservado`);
           auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'A', accion: 'preserve', hashAntes, evidencia: `backup falló: ${backup.error || 'desconocido'}` });
@@ -1377,7 +1409,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         }
 
         // Componente-archivo (agentes/comandos/reglas): backup del archivo + fall-through.
-        const backup = crearBackup(process.cwd(), cmpDestino, versionBackup);
+        const backup = crearBackup(rutaBackupBase, cmpDestino, versionBackup);
         // H1 (nemesis O5): si el backup falla, NO sobrescribir — preservar original.
         if (!backup.respaldado) {
           console.log(`  ⚠ Backup falló (${backup.error || 'desconocido'}) para ${nombreArchivo} — overwrite abortado, original preservado`);
@@ -1415,7 +1447,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
   // Nivel 2: Backup antes de sobreescribir con --force (el caso B shipped-evolved
   // ya hizo su propio backup arriba; no duplicar).
   if (fs.existsSync(destino) && opciones.force && opciones.versionAnterior && !forzarEscrituraEvolved) {
-    const backup = crearBackup(process.cwd(), destino, opciones.versionAnterior);
+    const backup = crearBackup(rutaBackupBase, destino, opciones.versionAnterior);
     if (backup.respaldado) {
       if (typeof opciones.onProgress === 'function') {
         opciones.onProgress({

package/scripts/lib/activar-hooks-proyecto.js

@@ -1,116 +1,116 @@
-'use strict';
-
-/**
- * activar-hooks-proyecto.js — Camino "solo hooks" (DT-HOOKS-SOLO-PROYECTO).
- *
- * Registra en el `.claude/settings.json` del PROYECTO los hooks del scope
- * GLOBAL ya instalado, sin copiar ningún componente. Cierra el dilema del
- * install local: los hooks solo funcionan registrados a nivel proyecto
- * (ADR-0009), pero el install local completo duplica agentes/comandos en la
- * UI de Claude Code (lee ambos scopes). Con este camino:
- *
- *   - Los comandos del settings apuntan con ruta ABSOLUTA al hooks/ global
- *     (esGlobal: true en registrarHooks) → cero archivos copiados.
- *   - `swl-ses update` del global refresca los hooks de TODOS los proyectos
- *     activados así, gratis (apuntan a los mismos archivos).
- *   - Hooks externos (no-SWL) del settings del proyecto se preservan
- *     (garantía de registrarHooks).
- *
- * Uso: `swl-ses install --target claude --solo-hooks` (en la raíz del
- * proyecto). Requiere instalación global previa del runtime.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const RUNTIMES_SOPORTADOS = new Set(['claude', 'openclaude']);
-
-/**
- * @param {object} opciones
- * @param {string} [opciones.target='claude']     Runtime (claude|openclaude — formato de settings de Claude Code)
- * @param {string} [opciones.dirProyecto=cwd]     Raíz del proyecto destino
- * @param {string} [opciones.hooksDirGlobal]      Override del hooks/ global (tests)
- * @param {object} [opciones.deps]                Inyección para tests: { registrarHooks, registrarOptimizaciones, cargarHooksConfig, scopesReales, obtenerRuntime }
- * @returns {{ok: boolean, error?: string, settingsPath?: string, hooksDirGlobal?: string, registrados?: number, preservados?: number}}
- */
-function activarHooksProyecto(opciones = {}) {
-  const target = opciones.target || 'claude';
-  if (!RUNTIMES_SOPORTADOS.has(target)) {
-    return { ok: false, error: `--solo-hooks soporta por ahora targets con settings formato Claude Code (claude, openclaude); recibido: "${target}".` };
-  }
-
-  const deps = opciones.deps || {};
-  const hs = require('./hooks-settings');
-  const registrarHooks = deps.registrarHooks || hs.registrarHooks;
-  const registrarOptimizaciones = deps.registrarOptimizaciones || hs.registrarOptimizaciones;
-  const cargarHooksConfig = deps.cargarHooksConfig || hs.cargarHooksConfig;
-
-  // 1. Localizar el hooks/ del scope GLOBAL del runtime.
-  let hooksDirGlobal = opciones.hooksDirGlobal;
-  if (!hooksDirGlobal) {
-    try {
-      const dr = require('./detectar-runtime');
-      const obtenerRuntime = deps.obtenerRuntime || dr.obtenerRuntime;
-      const scopesReales = deps.scopesReales || dr.scopesReales;
-      const runtime = obtenerRuntime(target);
-      const global = scopesReales(runtime).find(s => s.esGlobal);
-      if (!global) return { ok: false, error: `No se pudo resolver el scope global del runtime "${target}".` };
-      hooksDirGlobal = path.join(global.dir, 'hooks');
-    } catch (err) {
-      return { ok: false, error: `No se pudo detectar el runtime "${target}": ${err.message}` };
-    }
-  }
-  if (!fs.existsSync(hooksDirGlobal)) {
-    return { ok: false, error: `No hay instalación global con hooks en ${hooksDirGlobal}. Instala primero el global: npx -y @saulwade/swl-ses@latest install --target ${target} --global --perfil completo` };
-  }
-
-  // 2. Hooks disponibles = archivos del global ∩ hooks-config del paquete.
-  const hooksConfig = cargarHooksConfig();
-  const hookFiles = fs.readdirSync(hooksDirGlobal)
-    .filter(f => f.endsWith('.js') && hooksConfig[f]);
-  if (hookFiles.length === 0) {
-    return { ok: false, error: `El hooks/ global (${hooksDirGlobal}) no contiene hooks reconocidos por hooks-config.json — instalación global corrupta o muy antigua; corre update primero.` };
-  }
-
-  // 3. Registrar en el settings.json del PROYECTO, apuntando al global.
-  const dirProyecto = opciones.dirProyecto || process.cwd();
-  const dirClaude = path.join(dirProyecto, '.claude');
-  fs.mkdirSync(dirClaude, { recursive: true });
-  const settingsPath = path.join(dirClaude, 'settings.json');
-
-  const r = registrarHooks({
-    settingsPath,
-    hooksDir: hooksDirGlobal,
-    esGlobal: true, // semántica: comandos con ruta ABSOLUTA al hooksDir (que es el global)
-    hookFiles,
-  });
-
-  let optimizaciones = 0;
-  try {
-    const opt = registrarOptimizaciones(settingsPath);
-    optimizaciones = (opt && opt.registradas) || 0;
-  } catch { /* opcional — no bloquea la activación */ }
-
-  // 4. Sembrar el .gitignore del proyecto: encender la telemetría hace que
-  // los hooks ESCRIBAN (.planning/METRICAS.md, audit*.jsonl, evolution/...)
-  // — sin la sección swl-ses esos archivos runtime aparecen como cambios
-  // pendientes en el editor del usuario (caso real sistema-verificacion-oic,
-  // 2026-07-10: 19 archivos sin trackear tras activar hooks).
-  let gitignorePath = null;
-  try {
-    const { actualizarGitignore } = deps.gitignoreManifest || require('./gitignore-manifest');
-    gitignorePath = actualizarGitignore(dirProyecto);
-  } catch { /* no bloquea la activación — se reporta null */ }
-
-  return {
-    ok: true,
-    settingsPath,
-    hooksDirGlobal,
-    registrados: r.registrados,
-    preservados: r.preservados,
-    optimizaciones,
-    gitignorePath,
-  };
-}
-
-module.exports = { activarHooksProyecto, RUNTIMES_SOPORTADOS };
+'use strict';
+
+/**
+ * activar-hooks-proyecto.js — Camino "solo hooks" (DT-HOOKS-SOLO-PROYECTO).
+ *
+ * Registra en el `.claude/settings.json` del PROYECTO los hooks del scope
+ * GLOBAL ya instalado, sin copiar ningún componente. Cierra el dilema del
+ * install local: los hooks solo funcionan registrados a nivel proyecto
+ * (ADR-0009), pero el install local completo duplica agentes/comandos en la
+ * UI de Claude Code (lee ambos scopes). Con este camino:
+ *
+ *   - Los comandos del settings apuntan con ruta ABSOLUTA al hooks/ global
+ *     (esGlobal: true en registrarHooks) → cero archivos copiados.
+ *   - `swl-ses update` del global refresca los hooks de TODOS los proyectos
+ *     activados así, gratis (apuntan a los mismos archivos).
+ *   - Hooks externos (no-SWL) del settings del proyecto se preservan
+ *     (garantía de registrarHooks).
+ *
+ * Uso: `swl-ses install --target claude --solo-hooks` (en la raíz del
+ * proyecto). Requiere instalación global previa del runtime.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const RUNTIMES_SOPORTADOS = new Set(['claude', 'openclaude']);
+
+/**
+ * @param {object} opciones
+ * @param {string} [opciones.target='claude']     Runtime (claude|openclaude — formato de settings de Claude Code)
+ * @param {string} [opciones.dirProyecto=cwd]     Raíz del proyecto destino
+ * @param {string} [opciones.hooksDirGlobal]      Override del hooks/ global (tests)
+ * @param {object} [opciones.deps]                Inyección para tests: { registrarHooks, registrarOptimizaciones, cargarHooksConfig, scopesReales, obtenerRuntime }
+ * @returns {{ok: boolean, error?: string, settingsPath?: string, hooksDirGlobal?: string, registrados?: number, preservados?: number}}
+ */
+function activarHooksProyecto(opciones = {}) {
+  const target = opciones.target || 'claude';
+  if (!RUNTIMES_SOPORTADOS.has(target)) {
+    return { ok: false, error: `--solo-hooks soporta por ahora targets con settings formato Claude Code (claude, openclaude); recibido: "${target}".` };
+  }
+
+  const deps = opciones.deps || {};
+  const hs = require('./hooks-settings');
+  const registrarHooks = deps.registrarHooks || hs.registrarHooks;
+  const registrarOptimizaciones = deps.registrarOptimizaciones || hs.registrarOptimizaciones;
+  const cargarHooksConfig = deps.cargarHooksConfig || hs.cargarHooksConfig;
+
+  // 1. Localizar el hooks/ del scope GLOBAL del runtime.
+  let hooksDirGlobal = opciones.hooksDirGlobal;
+  if (!hooksDirGlobal) {
+    try {
+      const dr = require('./detectar-runtime');
+      const obtenerRuntime = deps.obtenerRuntime || dr.obtenerRuntime;
+      const scopesReales = deps.scopesReales || dr.scopesReales;
+      const runtime = obtenerRuntime(target);
+      const global = scopesReales(runtime).find(s => s.esGlobal);
+      if (!global) return { ok: false, error: `No se pudo resolver el scope global del runtime "${target}".` };
+      hooksDirGlobal = path.join(global.dir, 'hooks');
+    } catch (err) {
+      return { ok: false, error: `No se pudo detectar el runtime "${target}": ${err.message}` };
+    }
+  }
+  if (!fs.existsSync(hooksDirGlobal)) {
+    return { ok: false, error: `No hay instalación global con hooks en ${hooksDirGlobal}. Instala primero el global: npx -y @saulwade/swl-ses@latest install --target ${target} --global --perfil completo` };
+  }
+
+  // 2. Hooks disponibles = archivos del global ∩ hooks-config del paquete.
+  const hooksConfig = cargarHooksConfig();
+  const hookFiles = fs.readdirSync(hooksDirGlobal)
+    .filter(f => f.endsWith('.js') && hooksConfig[f]);
+  if (hookFiles.length === 0) {
+    return { ok: false, error: `El hooks/ global (${hooksDirGlobal}) no contiene hooks reconocidos por hooks-config.json — instalación global corrupta o muy antigua; corre update primero.` };
+  }
+
+  // 3. Registrar en el settings.json del PROYECTO, apuntando al global.
+  const dirProyecto = opciones.dirProyecto || process.cwd();
+  const dirClaude = path.join(dirProyecto, '.claude');
+  fs.mkdirSync(dirClaude, { recursive: true });
+  const settingsPath = path.join(dirClaude, 'settings.json');
+
+  const r = registrarHooks({
+    settingsPath,
+    hooksDir: hooksDirGlobal,
+    esGlobal: true, // semántica: comandos con ruta ABSOLUTA al hooksDir (que es el global)
+    hookFiles,
+  });
+
+  let optimizaciones = 0;
+  try {
+    const opt = registrarOptimizaciones(settingsPath);
+    optimizaciones = (opt && opt.registradas) || 0;
+  } catch { /* opcional — no bloquea la activación */ }
+
+  // 4. Sembrar el .gitignore del proyecto: encender la telemetría hace que
+  // los hooks ESCRIBAN (.planning/METRICAS.md, audit*.jsonl, evolution/...)
+  // — sin la sección swl-ses esos archivos runtime aparecen como cambios
+  // pendientes en el editor del usuario (caso real sistema-verificacion-oic,
+  // 2026-07-10: 19 archivos sin trackear tras activar hooks).
+  let gitignorePath = null;
+  try {
+    const { actualizarGitignore } = deps.gitignoreManifest || require('./gitignore-manifest');
+    gitignorePath = actualizarGitignore(dirProyecto);
+  } catch { /* no bloquea la activación — se reporta null */ }
+
+  return {
+    ok: true,
+    settingsPath,
+    hooksDirGlobal,
+    registrados: r.registrados,
+    preservados: r.preservados,
+    optimizaciones,
+    gitignorePath,
+  };
+}
+
+module.exports = { activarHooksProyecto, RUNTIMES_SOPORTADOS };

package/scripts/lib/approval-receipts.js

@@ -0,0 +1,190 @@
+'use strict';
+
+/** Verifica approvals Ed25519 ligadas a principal, operación, PLAN y FSM. */
+
+const crypto = require('node:crypto');
+
+const { assertPrincipalCurrent, isVerifiedPrincipal } = require('./principal-verifier');
+const {
+  exactKeys, fail, freezeDeep, getContractValidators, plainObject,
+} = require('./policy-verifier-utils');
+const signed = require('./signed-envelope');
+
+const APPROVALS = new WeakSet();
+const APPROVAL_META = new WeakMap();
+const SHA256 = /^[a-f0-9]{64}$/u;
+const IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const CLAIM_KEYS = [
+  'kind', 'schemaVersion', 'approvalId', 'principalDigest', 'operationDigest',
+  'sessionId', 'runtimeId', 'projectId', 'worktreeDigest', 'capability', 'effectKind',
+  'scopeDigest', 'planDigest', 'fsmVersion', 'issuedAt', 'expiresAt', 'nonce',
+];
+const SCOPED_CLAIM_KEYS = [...CLAIM_KEYS, 'phaseId', 'taskId'];
+const EPOCH_CLAIM_KEYS = [...SCOPED_CLAIM_KEYS, 'g1ApprovalDigest'];
+const OPTION_KEYS = [
+  'trustContext', 'dependencies', 'principal', 'operation', 'planDigest', 'fsmVersion',
+];
+const SCOPED_OPTION_KEYS = [...OPTION_KEYS, 'phaseId', 'taskId'];
+const EPOCH_OPTION_KEYS = [...SCOPED_OPTION_KEYS, 'g1ApprovalDigest'];
+const TASK = /^T-[0-9]{2}$/u;
+
+function validateOptions(options) {
+  const contract = getContractValidators();
+  plainObject(options, 'APPROVAL_OPTIONS_INVALID', 'opciones approval');
+  const isScoped = Object.hasOwn(options, 'phaseId') || Object.hasOwn(options, 'taskId');
+  const hasEpoch = Object.hasOwn(options, 'g1ApprovalDigest');
+  exactKeys(
+    options, hasEpoch ? EPOCH_OPTION_KEYS : (isScoped ? SCOPED_OPTION_KEYS : OPTION_KEYS),
+    'APPROVAL_OPTIONS_INVALID', 'opciones approval'
+  );
+  if (!contract.isKernelDependencies(options.dependencies)) {
+    fail('APPROVAL_OPTIONS_INVALID', 'dependencies inválidas');
+  }
+  if (!isVerifiedPrincipal(options.principal)) {
+    fail('APPROVAL_PRINCIPAL_INVALID', 'principal inválido');
+  }
+  if (!contract.isVerifiedOperation(options.operation)) {
+    fail('APPROVAL_OPERATION_INVALID', 'operación inválida');
+  }
+  if (!SHA256.test(options.planDigest) || !Number.isInteger(options.fsmVersion)
+      || options.fsmVersion < 0) {
+    fail('APPROVAL_OPTIONS_INVALID', 'PLAN o FSM inválido');
+  }
+  if (isScoped && (!IDENTIFIER.test(options.phaseId) || !TASK.test(options.taskId))) {
+    fail('APPROVAL_OPTIONS_INVALID', 'alcance de gate inválido');
+  }
+  if (hasEpoch && !SHA256.test(options.g1ApprovalDigest)) {
+    fail('APPROVAL_OPTIONS_INVALID', 'época G1 inválida');
+  }
+}
+
+function validateShape(claims) {
+  plainObject(claims, 'APPROVAL_INVALID', 'claims approval');
+  const isScoped = ['1.1.0', '1.2.0'].includes(claims.schemaVersion);
+  const keys = claims.schemaVersion === '1.2.0' ? EPOCH_CLAIM_KEYS
+    : (isScoped ? SCOPED_CLAIM_KEYS : CLAIM_KEYS);
+  exactKeys(claims, keys,
+    'APPROVAL_INVALID', 'claims approval');
+  if (claims.kind !== 'authorization-approval'
+      || !['1.0.0', '1.1.0', '1.2.0'].includes(claims.schemaVersion)) {
+    fail('APPROVAL_INVALID', 'approval futura o inválida');
+  }
+  for (const field of ['approvalId', 'sessionId', 'runtimeId', 'projectId', 'nonce']) {
+    if (!IDENTIFIER.test(claims[field])) fail('APPROVAL_INVALID', `${field} inválido`);
+  }
+  for (const field of ['principalDigest', 'operationDigest', 'worktreeDigest',
+    'scopeDigest', 'planDigest']) {
+    if (!SHA256.test(claims[field])) fail('APPROVAL_INVALID', `${field} inválido`);
+  }
+  if (!IDENTIFIER.test(claims.capability) || !IDENTIFIER.test(claims.effectKind)
+      || !Number.isInteger(claims.fsmVersion) || claims.fsmVersion < 0) {
+    fail('APPROVAL_INVALID', 'capability, effect o FSM inválido');
+  }
+  if (isScoped && (!IDENTIFIER.test(claims.phaseId) || !TASK.test(claims.taskId))) {
+    fail('APPROVAL_INVALID', 'alcance de gate inválido');
+  }
+  if (claims.schemaVersion === '1.2.0' && !SHA256.test(claims.g1ApprovalDigest)) {
+    fail('APPROVAL_INVALID', 'época G1 inválida');
+  }
+}
+
+function validateBindings(claims, options) {
+  const requestedSchema = Object.hasOwn(options, 'g1ApprovalDigest') ? '1.2.0'
+    : (Object.hasOwn(options, 'phaseId') ? '1.1.0' : '1.0.0');
+  if (claims.schemaVersion !== requestedSchema) {
+    fail('APPROVAL_BINDING_INVALID', 'schema no satisface las garantías solicitadas');
+  }
+  const expected = {
+    principalDigest: options.principal.principalDigest,
+    operationDigest: options.operation.operationDigest,
+    sessionId: options.principal.sessionId, runtimeId: options.principal.runtimeId,
+    projectId: options.principal.projectId, worktreeDigest: options.principal.worktreeDigest,
+    capability: options.operation.capability, effectKind: options.operation.effectKind,
+    scopeDigest: options.operation.scope.digest, planDigest: options.planDigest,
+    fsmVersion: options.fsmVersion,
+  };
+  if (['1.1.0', '1.2.0'].includes(requestedSchema)) {
+    expected.phaseId = options.phaseId;
+    expected.taskId = options.taskId;
+  }
+  if (requestedSchema === '1.2.0') {
+    expected.g1ApprovalDigest = options.g1ApprovalDigest;
+  }
+  if (Object.entries(expected).some(([key, value]) => claims[key] !== value)) {
+    fail('APPROVAL_BINDING_INVALID', 'approval ligada a otro contexto');
+  }
+}
+
+function validateTime(claims, now) {
+  signed.validarTimestampIso(claims.issuedAt, 'approval issuedAt');
+  signed.validarTimestampIso(claims.expiresAt, 'approval expiresAt');
+  if (claims.issuedAt > now || claims.expiresAt < now || claims.issuedAt >= claims.expiresAt) {
+    fail('APPROVAL_EXPIRED', 'approval fuera de vigencia');
+  }
+}
+
+function createReceipt(envelope, options) {
+  const digestInput = {
+    issuer: envelope.issuer, subject: envelope.subject,
+    signerPublicKeyDigest: envelope.signerPublicKeyDigest,
+    trustEpoch: envelope.trustEpoch, trustDigest: envelope.trustDigest,
+    claims: envelope.claims,
+  };
+  const approvalDigest = crypto.createHash('sha256')
+    .update(signed.canonicalizarIJson(digestInput), 'utf8').digest('hex');
+  const receipt = freezeDeep({
+    kind: 'verified-approval', ...structuredClone(envelope.claims),
+    approverId: envelope.subject, issuer: envelope.issuer,
+    keyId: envelope.keyId, rootKeyDigest: envelope.rootKeyDigest,
+    signerPublicKeyDigest: envelope.signerPublicKeyDigest,
+    trustEpoch: envelope.trustEpoch, trustDigest: envelope.trustDigest,
+    approvalDigest,
+  });
+  APPROVALS.add(receipt);
+  APPROVAL_META.set(receipt, Object.freeze({
+    envelope, principal: options.principal,
+    integrityLedger: options.dependencies.integrityLedger,
+  }));
+  return receipt;
+}
+
+function assertApprovalCurrent(approval, authority) {
+  if (!APPROVALS.has(approval)) fail('APPROVAL_INVALID', 'approval no verificada');
+  const metadata = APPROVAL_META.get(approval);
+  if (!metadata.integrityLedger.isAuthorityReceipt(authority)) {
+    fail('APPROVAL_AUTHORITY_INVALID', 'autoridad no verificada');
+  }
+  assertPrincipalCurrent(metadata.principal, authority);
+  signed.revalidarEnvelopeVerificado(metadata.envelope, authority.observedAt);
+  validateTime(approval, authority.observedAt);
+  return true;
+}
+
+function verifyApproval(rawBytes, options) {
+  validateOptions(options);
+  const authority = options.dependencies.integrityLedger.readAuthority();
+  const envelope = signed.verificarEnvelope(rawBytes, {
+    trustContext: options.trustContext, expectedType: 'approval',
+    requiredScope: `approve:${options.operation.capability}`, now: authority.observedAt,
+  });
+  if (envelope.trustEpoch !== authority.trustEpoch
+      || envelope.trustDigest !== authority.trustDigest
+      || envelope.rootKeyDigest !== authority.rootKeyDigest) {
+    fail('APPROVAL_TRUST_INVALID', 'approval ligada a trust distinto');
+  }
+  assertPrincipalCurrent(options.principal, authority);
+  validateShape(envelope.claims);
+  validateBindings(envelope.claims, options);
+  validateTime(envelope.claims, authority.observedAt);
+  return createReceipt(envelope, options);
+}
+
+function isVerifiedApproval(value) {
+  return APPROVALS.has(value);
+}
+
+module.exports = {
+  assertApprovalCurrent,
+  isVerifiedApproval,
+  verifyApproval,
+};

package/scripts/lib/artefactos-python.js

@@ -1,43 +1,43 @@
-'use strict';
-
-/**
- * artefactos-python.js — fuente única de verdad para los artefactos
- * Python que NO deben distribuirse en el paquete npm.
- *
- * Por qué existe:
- *   Tanto `scripts/limpiar-artefactos-python.js` (prepack) como
- *   `scripts/publicar.js` (copiarDir hacia tmpDir del mirror GH)
- *   necesitan saber qué directorios y extensiones excluir. Tener la
- *   lista hardcodeada en cada archivo es violación DRY de conocimiento
- *   — agregar `.pyd` o `.mypy_cache_v2` exigiría editar dos archivos
- *   y mantenerlos sincronizados.
- */
-
-const DIRS_ARTEFACTOS_PYTHON = Object.freeze(new Set([
-  '__pycache__',
-  '.pytest_cache',
-  '.mypy_cache',
-  '.ruff_cache',
-]));
-
-const EXTS_ARTEFACTOS_PYTHON = Object.freeze(new Set([
-  '.pyc',
-  '.pyo',
-]));
-
-function esDirArtefacto(nombre) {
-  return DIRS_ARTEFACTOS_PYTHON.has(nombre);
-}
-
-function esArchivoArtefacto(nombre) {
-  const dot = nombre.lastIndexOf('.');
-  if (dot < 0) return false;
-  return EXTS_ARTEFACTOS_PYTHON.has(nombre.slice(dot).toLowerCase());
-}
-
-module.exports = {
-  DIRS_ARTEFACTOS_PYTHON,
-  EXTS_ARTEFACTOS_PYTHON,
-  esDirArtefacto,
-  esArchivoArtefacto,
-};
+'use strict';
+
+/**
+ * artefactos-python.js — fuente única de verdad para los artefactos
+ * Python que NO deben distribuirse en el paquete npm.
+ *
+ * Por qué existe:
+ *   Tanto `scripts/limpiar-artefactos-python.js` (prepack) como
+ *   `scripts/publicar.js` (copiarDir hacia tmpDir del mirror GH)
+ *   necesitan saber qué directorios y extensiones excluir. Tener la
+ *   lista hardcodeada en cada archivo es violación DRY de conocimiento
+ *   — agregar `.pyd` o `.mypy_cache_v2` exigiría editar dos archivos
+ *   y mantenerlos sincronizados.
+ */
+
+const DIRS_ARTEFACTOS_PYTHON = Object.freeze(new Set([
+  '__pycache__',
+  '.pytest_cache',
+  '.mypy_cache',
+  '.ruff_cache',
+]));
+
+const EXTS_ARTEFACTOS_PYTHON = Object.freeze(new Set([
+  '.pyc',
+  '.pyo',
+]));
+
+function esDirArtefacto(nombre) {
+  return DIRS_ARTEFACTOS_PYTHON.has(nombre);
+}
+
+function esArchivoArtefacto(nombre) {
+  const dot = nombre.lastIndexOf('.');
+  if (dot < 0) return false;
+  return EXTS_ARTEFACTOS_PYTHON.has(nombre.slice(dot).toLowerCase());
+}
+
+module.exports = {
+  DIRS_ARTEFACTOS_PYTHON,
+  EXTS_ARTEFACTOS_PYTHON,
+  esDirArtefacto,
+  esArchivoArtefacto,
+};