@dotrino/identity 0.71.0 → 0.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.71.0",
+  "version": "0.73.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/src/node.js

@@ -102,6 +102,10 @@ export class Identity {
   constructor (options = {}) {
     this._dir = options.dir || DEFAULT_DIR
     this._atRest = options.atRest || null
+    // CANDADO DE LA MAESTRA: `{ seal(jwkStr), open(blob) }`. Quien lo provee (el daemon
+    // del vault) es el único que tiene la llave que sale de la contraseña. Sin candado,
+    // la maestra se guarda como siempre — un perfil sin contraseña no cambia.
+    this._keyLock = options.keyLock || null
     this._core = null
     this._listeners = new Map()
   }
@@ -121,6 +125,7 @@ export class Identity {
     if (this._core) return this
     this._core = await createIdentityCore({
       kv: fileKv(path.join(this._dir, 'identity.json'), this._atRest),
+      keyLock: this._keyLock,
       peers: filePeers(path.join(this._dir, 'peers.json')),
       makeSync: null,
       // Aquí las cuentas las lleva quien hospeda (el daemon del vault tiene su propio
@@ -137,6 +142,14 @@ export class Identity {
 
   get me () { return this._core?.me || null }
 
+  // ----- candado de la maestra -----
+  /** `true` si la maestra está sellada: esta identidad NO puede firmar nada. */
+  get masterLocked () { return !!this._core?.masterLocked }
+  /** Sella la maestra que ya existe (se llama al abrir el perfil, con la llave en la mano). */
+  sealMasterKey () { return this._core?.sealMasterKey?.() }
+  /** Vuelve a cargar el par tras abrir el candado, sin reabrir la identidad. */
+  reloadMasterKey () { return this._core?.reloadMasterKey?.() }
+
   _h (method, params = {}) {
     if (!this._core) throw new Error('Identity not ready — call ready()/connect() first')
     return this._core.handlers[method](params)

package/vault/acta.js

@@ -37,7 +37,7 @@
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
-export const ACTA_V = 4
+export const ACTA_V = 5
 
 /**
  * Versiones de acta que se ACEPTAN al leer. La 1 sigue entrando porque una v1 en el disco
@@ -57,7 +57,11 @@ export const ACTA_V = 4
  * entiende; la PRIMERA vez que esa cuenta cambie algo, la nueva sale ya en v3 y el campo
  * desaparece solo.
  */
-const ACTA_LEIBLES = Object.freeze([1, 2, 3, 4])
+// v5 mete DENTRO del acta el eslabón publicable de la cadena de selladores, firmado
+// aparte (ver `sealerLinkOf`): así se publica solo eso y no el acta entera, que llevaba
+// los aparatos con sus nombres. Una v4 se sigue leyendo, pero no tiene eslabón y por tanto
+// no puede publicar: su cuenta no aparece en el registro hasta que selle una v5 nueva.
+const ACTA_LEIBLES = Object.freeze([1, 2, 3, 4, 5])
 /** Desde esta versión, el acta lleva su eslabón de la cadena de selladores. */
 const V_CON_CADENA = 4
 /** ¿Esta acta lleva el eslabón? Las anteriores se leen igual; no pueden encadenar. */
@@ -187,6 +191,124 @@ export async function actaHash (acta) {
   return hex(await crypto.subtle.digest('SHA-256', enc(canonicalStringify(actaBody(acta)))))
 }
 
+/**
+ * EL ESLABÓN DE LA CADENA DE SELLADORES: lo ÚNICO que se publica.
+ *
+ * El problema que resuelve (dueño, 2026-08-31). Publicar «los eslabones donde cambia quién
+ * sella» sonaba a publicar poco, pero un eslabón ERA un acta entera: se fue a un repo
+ * público con los `label` y los `cn` de cada aparato y el llavero. Recortar el acta no
+ * vale, porque su firma cubre el acta entera y dejaría de verificar.
+ *
+ * La salida es del dueño y es mejor que tener dos documentos que puedan discrepar: se
+ * construye el eslabón, **se firma**, se mete en el acta, y **se firma el acta encima**.
+ * Resultado: uno solo, firmado dos veces.
+ *
+ *   · quien tiene el acta la verifica y con eso el eslabón de dentro queda validado —
+ *     no hay nada aparte en lo que confiar;
+ *   · quien solo tiene el registro verifica la firma del eslabón, que es de la misma
+ *     llave y dice lo mismo. Discrepar es imposible por construcción.
+ *
+ * ENCADENA CONTRA EL ESLABÓN ANTERIOR, no contra el acta anterior. El `sealerAnchor` del
+ * acta apunta al hash del ACTA previa, y quien solo lee el registro no la tiene ni puede
+ * calcularla — la cadena publicada tiene que sostenerse sola.
+ *
+ * Lo que lleva es lo mínimo para responder «¿esta llave sigue pudiendo sellar?»: nada de
+ * miembros, ni etiquetas, ni cajones, ni llavero.
+ */
+export const SEALER_LINK_V = 1
+
+/** El cuerpo firmable del eslabón (todo menos su propia firma). */
+export const sealerLinkBody = (link) => { const { sig, ...body } = link || {}; return body }
+
+/** Hash del eslabón. Es a esto a lo que apunta el `prev` del siguiente. */
+export async function sealerLinkHash (link) {
+  return hex(await crypto.subtle.digest('SHA-256', enc(canonicalStringify(sealerLinkBody(link)))))
+}
+
+/** El eslabón que hay que publicar de esta acta, o `null` si no cambió el sellador. */
+export const sealerLinkOf = (acta) => (acta?.sealerChanged && acta?.sealerLink) || null
+
+/**
+ * ¿Es este eslabón coherente con el acta que lo lleva? Es lo que hace verdad la frase «ya
+ * está validado dentro del acta»: la firma del acta cubre el eslabón, pero eso solo prueba
+ * que está ahí — que DIGA lo mismo que el acta hay que comprobarlo.
+ */
+export function checkSealerLink (acta) {
+  const l = acta?.sealerLink
+  if (!l) return acta?.sealerChanged && acta?.v >= 5 ? 'eslabon-ausente' : null
+  if (l.v !== SEALER_LINK_V) return 'eslabon-version'
+  if (typeof l.sig !== 'string') return 'eslabon-sin-firma'
+  if (l.profileId !== acta.profileId) return 'eslabon-otro-perfil'
+  // EL ACTA VIGENTE ARRASTRA EL ÚLTIMO ESLABÓN, que casi nunca es de ella: los selladores
+  // cambian poquísimo y las actas cambian con cada emparejamiento. Así que solo cuando
+  // ESTA acta es el eslabón se le exige que coincida en `seq` y en quién lo firmó; si lo
+  // hereda, basta con que venga de antes.
+  if (acta.sealerChanged) {
+    if (l.seq !== acta.seq) return 'eslabon-otro-seq'
+    if (l.by !== acta.sealedBy) return 'eslabon-otro-sellador'
+  } else if (!(l.seq < acta.seq)) {
+    return 'eslabon-del-futuro'
+  }
+  // Y en los dos casos tiene que DECIR LO MISMO que el acta sobre quién sella: si no
+  // cambiaron, el heredado los sigue describiendo. Esto es lo que impide que el acta y su
+  // eslabón cuenten cosas distintas — que es todo el punto de meterlo dentro.
+  const dice = [...(l.sealers || [])].slice().sort().join('|')
+  const segunElActa = sealersOf(acta).slice().sort().join('|')
+  if (dice !== segunElActa) return 'eslabon-no-cuadra'
+  return null
+}
+
+/** Firma del eslabón por quien sella. Se hace ANTES de firmar el acta que lo lleva. */
+export async function verifySealerLink (link) {
+  if (!link || link.v !== SEALER_LINK_V) return { ok: false, reason: 'eslabon-version' }
+  if (!isPub(link.profileId) || !isPub(link.by)) return { ok: false, reason: 'eslabon-forma' }
+  if (!Array.isArray(link.sealers) || !link.sealers.length || !link.sealers.every(isPub)) return { ok: false, reason: 'eslabon-selladores' }
+  if (typeof link.seq !== 'number' || link.seq < 1) return { ok: false, reason: 'eslabon-seq' }
+  if (typeof link.sig !== 'string') return { ok: false, reason: 'eslabon-sin-firma' }
+  const ok = await verifyDeviceSig({ publickey: link.by, data: sealerLinkBody(link), signature: link.sig })
+  return ok ? { ok: true } : { ok: false, reason: 'eslabon-firma-invalida' }
+}
+
+/**
+ * VERIFICA LA CADENA PUBLICADA — la que vive en el registro, sin actas de por medio.
+ *
+ * Es la hermana de `verifySealerChain`, que hace lo mismo con actas enteras para quien las
+ * tiene. Lo que comprueba, y por qué basta:
+ *   1. el primero es el GÉNESIS: `seq 1`, sin `prev`, y firmado por `profileId` — el ancla,
+ *      que no se puede fabricar sin la llave que da nombre al perfil;
+ *   2. cada siguiente lo firmó alguien a quien el ANTERIOR autorizaba;
+ *   3. y apunta al anterior por `seq` + hash, así que no se cuela uno de otra rama.
+ *
+ * Lo que NO resuelve, y no lo esconde: la frescura. Quien guardó una cadena vieja sigue
+ * aceptando a un sellador retirado; para eso está mirar el registro, no más firmas.
+ */
+export async function verifySealerLinkChain (chain, { expectedProfileId = null } = {}) {
+  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
+  const [raiz] = chain
+  if (raiz?.seq !== 1 || raiz?.prev != null) return { ok: false, reason: 'no-empieza-en-genesis' }
+  if (raiz.by !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
+  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  const vr = await verifySealerLink(raiz)
+  if (!vr.ok) return { ok: false, reason: 'genesis:' + vr.reason }
+
+  for (let i = 1; i < chain.length; i++) {
+    const previo = chain[i - 1]
+    const actual = chain[i]
+    if (actual?.profileId !== raiz.profileId) return { ok: false, reason: `eslabon-${i}:otro-perfil` }
+    if (!(actual.seq > previo.seq)) return { ok: false, reason: `eslabon-${i}:seq-no-crece` }
+    const v = await verifySealerLink(actual)
+    if (!v.ok) return { ok: false, reason: `eslabon-${i}:` + v.reason }
+    const a = actual.prev
+    if (!a || a.seq !== previo.seq || a.hash !== await sealerLinkHash(previo)) {
+      return { ok: false, reason: `eslabon-${i}:no-encadena` }
+    }
+    // Y lo que da la autoridad: quien lo firmó podía sellar SEGÚN EL ESLABÓN ANTERIOR.
+    if (!previo.sealers.includes(actual.by)) return { ok: false, reason: `eslabon-${i}:sellador-no-autorizado` }
+  }
+  const ultimo = chain[chain.length - 1]
+  return { ok: true, profileId: raiz.profileId, seq: ultimo.seq, sealers: [...ultimo.sealers] }
+}
+
 /** Id legible de un miembro (mismo formato que el deviceId del emparejamiento). */
 export async function memberId (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -265,6 +387,9 @@ export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', c
     // `true` porque el génesis ESTABLECE el primer conjunto de selladores: es el eslabón
     // 1 de la cadena, y por eso la siguiente acta tiene que apuntarle a él.
     sealerChanged: true,
+    // EL ESLABÓN 1 de la cadena publicable, todavía SIN FIRMAR: lo firma `sealActa` con la
+    // misma llave, y después firma el acta que lo lleva. Es lo único que sale al registro.
+    sealerLink: { v: SEALER_LINK_V, profileId: pub, seq: 1, by: pub, sealers: [pub], prev: null, iat: now },
     members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS, 'sealer'], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
@@ -355,8 +480,20 @@ export function checkShape (acta) {
 export async function sealActa ({ acta, privateKey, privateJwk }) {
   const shape = checkShape(acta)
   if (shape) throw new Error('invalid record: ' + shape)
-  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: actaBody(acta) })
-  const sealed = { ...acta, sig: signature }
+  // PRIMERO EL ESLABÓN, DESPUÉS EL ACTA. Este es el orden que hace que no puedan discrepar:
+  // se firma el eslabón, se mete en el acta, y la firma del acta lo cubre. Quien tiene el
+  // acta lo da por bueno con verificarla; quien solo tiene el registro verifica su firma.
+  // Si ya viene firmado no se vuelve a firmar: se está arrastrando el de un acta anterior.
+  let conEslabon = acta
+  if (acta.sealerLink && !acta.sealerLink.sig) {
+    if (acta.sealerLink.by !== acta.sealedBy) throw new Error('invalid record: the chain link names a sealer other than the one signing')
+    const { signature: firmaEslabon } = await signWithDevice({
+      privateKey, privateJwk, publickey: acta.sealedBy, data: sealerLinkBody(acta.sealerLink)
+    })
+    conEslabon = { ...acta, sealerLink: { ...acta.sealerLink, sig: firmaEslabon } }
+  }
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: conEslabon.sealedBy, data: actaBody(conEslabon) })
+  const sealed = { ...conEslabon, sig: signature }
   // La TARJETA se firma en el mismo gesto y viaja con el acta: así cualquier miembro puede
   // entregársela a un contacto sin ser el master y sin contarle nada de más.
   sealed.card = await makeProfileCard({ acta: sealed, privateKey, privateJwk })
@@ -457,7 +594,11 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
   if (typeof acta.sig !== 'string') return { ok: false, reason: 'sin-firma' }
   if (expectedProfileId != null && acta.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
   const ok = await verifyDeviceSig({ publickey: acta.sealedBy, data: actaBody(acta), signature: acta.sig })
-  return ok ? { ok: true } : { ok: false, reason: 'firma-invalida' }
+  if (!ok) return { ok: false, reason: 'firma-invalida' }
+  // El eslabón va DENTRO y la firma de arriba lo cubre, pero eso solo prueba que está ahí.
+  // Que diga lo mismo que el acta es lo que hace verdad «ya está validado dentro».
+  const mal = checkSealerLink(acta)
+  return mal ? { ok: false, reason: mal } : { ok: true }
 }
 
 /**
@@ -692,6 +833,24 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
   if (!canSeal(next, by)) {
     throw new Error('the change would leave whoever seals it unable to seal: a record must pass the filter of the one it replaces AND its own')
   }
+  // EL ESLABÓN PUBLICABLE. Si cambió quién sella se acuña uno nuevo —sin firmar, lo firma
+  // `sealActa`— encadenado al que traía el acta anterior. Si no cambió, se arrastra el
+  // mismo: así el acta vigente SIEMPRE lleva el último eslabón, y `prev` apunta al eslabón
+  // anterior de la cadena (no al acta anterior, que quien lee el registro no tiene).
+  if (next.sealerChanged) {
+    const anterior = acta.sealerLink || null
+    next.sealerLink = {
+      v: SEALER_LINK_V,
+      profileId: next.profileId,
+      seq: next.seq,
+      by,
+      sealers: sealersOf(next).slice().sort(),
+      prev: anterior ? { seq: anterior.seq, hash: await sealerLinkHash(anterior) } : null,
+      iat: now
+    }
+  } else if (acta.sealerLink) {
+    next.sealerLink = acta.sealerLink
+  }
   return next
 }
 

package/vault/capabilities.js

@@ -8,12 +8,12 @@
  * Solución (subkeys / capabilities, estilo certs SSH / OAuth device tokens):
  *   - El dispositivo genera SU PROPIA clave `D` (la maestra nunca la ve).
  *   - El vault firma un CERTIFICADO: «la clave D puede `scope` para la identidad P,
- *     hasta `exp`», con un `nonce` que es el mango de revocación.
+ *     mientras el ACTA lo diga», con un `nonce` que es el mango de revocación.
  *   - El dispositivo firma cada acción con `D` y adjunta el cert. Cualquiera
  *     verifica la CADENA `D ← P` + scope + expiración + revocación, offline.
  *
  * Garantía: robar el dispositivo solo permite lo del `scope` (p.ej. publicar
- * ubicación), hasta `exp`, y se puede revocar. La clave maestra queda intacta.
+ * ubicación) mientras el acta lo diga, y se puede revocar. La clave maestra queda intacta.
  *
  * Cripto IDÉNTICA al resto del ecosistema: ECDSA P-256 + SHA-256 sobre
  * `canonicalStringify`, firma en base64 de los 64 bytes crudos (r||s). Módulo
@@ -105,8 +105,20 @@ export async function commitCode ({ code, dpub, sn }) {
 export { avatarSvg, avatarDataUri } from './avatar.js'
 
 /** Cuerpo canónico del certificado (lo que se firma): el cert SIN la firma. */
+/**
+ * Lo que se firma de un certificado. `seq` en vez de `exp` (dueño, 2026-08-31).
+ *
+ * EL PAPEL YA NO CADUCA POR RELOJ: caduca cuando cambia el acta. Antes vencía a los 30
+ * días, y eso obligaba a que alguien con la maestra estuviera disponible cada mes o los
+ * aparatos se quedaban fuera — con una bóveda que pasa casi todo el tiempo cerrada, eso
+ * no iba a pasar nunca.
+ *
+ * Atarlo al `seq` hace las dos cosas de golpe: quitarle un permiso a un aparato surte
+ * efecto AL INSTANTE (el acta sube de `seq` y su papel deja de valer, sin esperar a
+ * ninguna renovación), y nadie tiene que abrir nada por calendario.
+ */
 export function delegationBody (cert) {
-  return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, exp: cert.exp, nonce: cert.nonce }
+  return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, seq: cert.seq, nonce: cert.nonce }
 }
 
 /**
@@ -162,10 +174,10 @@ export async function importDeviceEncKey (encPrivateJwk) {
 /**
  * Firma un certificado de delegación con una `privateKey` (CryptoKey) cuyo pubkey
  * es `iss`. Lo usa el handler del vault (con la clave maestra). Devuelve el cert
- * completo `{ v, iss, sub, scope, iat, exp, nonce, sig }`.
+ * completo `{ v, iss, sub, scope, iat, seq, nonce, sig }`.
  */
-export async function signDelegationWith (privateKey, iss, { sub, scope, iat, exp, nonce }) {
-  const body = { v: 1, iss, sub, scope, iat, exp, nonce }
+export async function signDelegationWith (privateKey, iss, { sub, scope, iat, seq, nonce }) {
+  const body = { v: 1, iss, sub, scope, iat, seq, nonce }
   const sig = await rawSign(privateKey, enc(canonicalStringify(body)))
   return { ...body, sig }
 }
@@ -190,11 +202,11 @@ export async function signWithDevice ({ privateJwk, privateKey, publickey, data
 /**
  * Verifica un CERTIFICADO de delegación (offline; no requiere la clave maestra):
  *   1) firma de la maestra (`iss`) sobre el cuerpo canónico,
- *   2) ventana temporal `iat ≤ now ≤ exp`,
+ *   2) el acta: quien lo emitió puede sellar, y el papel no es de un acta más nueva que la mía,
  *   3) `scope` incluye `expectedScope` (si se pide),
  *   4) `sub` === `expectedSub` (si se pide),
  *   5) `nonce` no revocado (`revoked`: fn(nonce)→bool, Set o mapa).
- * @returns {{ok:boolean, reason?:string, iss?, sub?, scope?, iat?, exp?, nonce?}}
+ * @returns {{ok:boolean, reason?:string, iss?, sub?, scope?, iat?, seq?, nonce?}}
  */
 /**
  * MARGEN DE RELOJ ENTRE DOS APARATOS. Sin esto, emparejar es una lotería.
@@ -215,17 +227,41 @@ export async function signWithDevice ({ privateJwk, privateKey, publickey, data
  */
 export const PEER_SKEW_MS = 120_000
 
-export async function verifyDelegation ({ cert, expectedScope, expectedSub, now = Date.now(), skewMs = 0, revoked } = {}) {
+export async function verifyDelegation ({ cert, expectedScope, expectedSub, actaSeq = null, sealers = null, revoked } = {}) {
   if (!cert || typeof cert !== 'object') return { ok: false, reason: 'no-cert' }
-  const { v, iss, sub, scope, iat, exp, nonce, sig } = cert
+  const { v, iss, sub, scope, iat, seq, nonce, sig } = cert
   if (v !== 1 || typeof iss !== 'string' || typeof sub !== 'string' || typeof sig !== 'string') return { ok: false, reason: 'shape' }
-  if (typeof iat !== 'number' || typeof exp !== 'number' || (typeof scope !== 'string' && !Array.isArray(scope))) return { ok: false, reason: 'shape' }
+  if (typeof iat !== 'number' || typeof seq !== 'number' || (typeof scope !== 'string' && !Array.isArray(scope))) return { ok: false, reason: 'shape' }
   if (!(await rawVerify(iss, enc(canonicalStringify(delegationBody(cert))), sig))) return { ok: false, reason: 'bad-signature' }
-  // `skewMs` tolera la diferencia de reloj entre el EMISOR (vault) y el VERIFICADOR
-  // (p.ej. el bridge de geo, otra máquina). Default 0 = estricto.
-  const sk = Math.max(0, skewMs)
-  if (now < iat - sk) return { ok: false, reason: 'not-yet-valid' }
-  if (now > exp + sk) return { ok: false, reason: 'expired' }
+  // EL ACTA MANDA, Y NO HAY RELOJ (dueño, 2026-08-31). El papel no vence: dice «una
+  // selladora de este perfil, mirando el acta nº `seq`, avaló esta llave». Lo que puede
+  // hacer HOY lo dice el acta de hoy, y eso lo cruza cada mostrador (`memberCanScope`).
+  //
+  // Llegan el `seq` y la LISTA DE SELLADORES, no el acta entera, y no por capricho: este
+  // módulo no sabe de actas —`acta.js` importa de aquí, así que mirar para allá sería un
+  // ciclo— y la regla de quién sella vive en el acta, en un solo sitio. Quien verifica saca
+  // la lista con `sealersOf` y la pasa.
+  //
+  // Sin esos datos no se puede juzgar, y se dice en vez de contestar «vale» a solas:
+  // devolver `ok` sin haber comprobado nada es exactamente cómo un papel viejo seguía
+  // entrando.
+  if (typeof actaSeq !== 'number' || !Array.isArray(sealers)) return { ok: false, reason: 'no-acta' }
+  // SOLO SE RECHAZA EL PAPEL DEL FUTURO. Si el cert nombra un acta MÁS NUEVA que la que
+  // tengo, no puedo juzgarlo: mi política está atrasada y decir que sí sería fiarme de algo
+  // que no he visto. Al revés no: un papel viejo es normal —el aparato estuvo apagado— y lo
+  // que puede hacer ya lo decide mi acta, que es más nueva.
+  //
+  // La alternativa era exigir `seq === actaSeq`, o sea que cada cambio del acta invalidara
+  // TODOS los papeles a la vez. Consigue lo mismo (quitar un permiso surte efecto al
+  // instante, porque eso lo hace el cruce con el acta) y además deja tirado al aparato que
+  // estaba apagado: vuelve, su papel ya no vale, y renovarlo exige una selladora ABIERTA.
+  // O sea que un cambio de acta te obligaría a abrir la bóveda para que tus aparatos
+  // volvieran — justo lo que se acaba de quitar de en medio.
+  if (seq > actaSeq) return { ok: false, reason: 'acta-vieja' }
+  // Y QUIEN LO EMITIÓ TIENE QUE PODER SELLAR. No se compara contra «la maestra»: cualquiera
+  // que el acta nombre sellador emite papeles válidos — si no, la segunda bóveda podría
+  // invalidar todos los certificados al sellar y luego no poder dar los nuevos.
+  if (!sealers.includes(iss)) return { ok: false, reason: 'untrusted-issuer' }
   if (expectedScope != null && !scopeAllows(scope, expectedScope)) return { ok: false, reason: 'scope' }
   if (expectedSub != null && sub !== expectedSub) return { ok: false, reason: 'sub' }
   if (nonce && revoked) {
@@ -233,26 +269,27 @@ export async function verifyDelegation ({ cert, expectedScope, expectedSub, now
       : (revoked instanceof Set ? revoked.has(nonce) : !!revoked[nonce])
     if (isRev) return { ok: false, reason: 'revoked' }
   }
-  return { ok: true, iss, sub, scope, iat, exp, nonce }
+  return { ok: true, iss, sub, scope, iat, seq, nonce }
 }
 
 /**
  * Verificación de CADENA de una acción/pin delegado (lo único que llama el bridge):
  *   1) el dispositivo `D` (= `data.publickey`) firmó `data`,
  *   2) el cert delega a ESTE dispositivo (`cert.sub === data.publickey`),
- *   3) el cert es válido (firma de `P`, scope, exp, revocación),
+ *   3) el cert es válido (firma de una selladora, scope, revocación),
  *   4) opcional: `cert.iss === trustedIssuer` (fija la identidad maestra esperada).
  * @returns {{ok:boolean, reason?:string, issuer?:string, device?:string}}
  */
-export async function verifyChain ({ data, signature, cert, expectedScope, expectedIssuer, trustedIssuer, now = Date.now(), skewMs = 0, revoked } = {}) {
+export async function verifyChain ({ data, signature, cert, expectedScope, actaSeq = null, sealers = null, revoked } = {}) {
   if (!data || typeof data !== 'object' || typeof signature !== 'string') return { ok: false, reason: 'shape' }
   const device = data.publickey
   if (typeof device !== 'string') return { ok: false, reason: 'no-device-pubkey' }
   if (!(await rawVerify(device, enc(canonicalStringify(data)), signature))) return { ok: false, reason: 'bad-action-signature' }
   if (!cert || cert.sub !== device) return { ok: false, reason: 'cert-device-mismatch' }
-  const d = await verifyDelegation({ cert, expectedScope, now, skewMs, revoked })
+  // `actaSeq` + `sealers` sustituyen a `trustedIssuer`: ya no se compara contra UNA llave
+  // (la maestra), sino contra lo que el acta dice — quién puede sellar, y cuál es el acta
+  // vigente. Ver `verifyDelegation`.
+  const d = await verifyDelegation({ cert, expectedScope, actaSeq, sealers, revoked })
   if (!d.ok) return { ok: false, reason: d.reason }
-  const issuer = trustedIssuer != null ? trustedIssuer : expectedIssuer
-  if (issuer != null && cert.iss !== issuer) return { ok: false, reason: 'untrusted-issuer' }
-  return { ok: true, issuer: cert.iss, device }
+  return { ok: true, issuer: cert.iss, device, scope: cert.scope }
 }

package/vault/core.js

@@ -18,7 +18,7 @@
  * vault, compartida por todos los runtimes.
  */
 
-import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
+import { signDelegationWith } from './capabilities.js'
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { pubkeyId as pubkeyIdOf, signWithDevice } from './capabilities.js'
@@ -158,7 +158,7 @@ function sanitizeProfilePatch (patch = {}) {
   return out
 }
 
-export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, keyStore = null, sessionKv = null, removeAccountOnExpulsion = true }) {
+export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, keyStore = null, sessionKv = null, removeAccountOnExpulsion = true, keyLock = null }) {
   const {
     initPeerStorage, loadPeers, savePeers, setPeersDirect, upsertPeer, onDirty
   } = peers
@@ -240,18 +240,77 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const raw = kv.getItem(storageKey)
     if (raw) {
       try {
-        const { privateJwk, publicJwk } = JSON.parse(raw)
-        const privateKey = await crypto.subtle.importKey('jwk', privateJwk, algo, true, privUses)
+        const guardado = JSON.parse(raw)
+        const { publicJwk } = guardado
+        // BAJO CANDADO. La mitad PRIVADA viaja sellada con una llave que no está en este
+        // disco (la deriva la contraseña del dueño); la PÚBLICA se queda en claro, que es
+        // lo que es. Cerrado se devuelve la identidad SIN con qué firmar: se sabe quién
+        // eres, no se puede hablar por ti.
+        //
+        // Y lo que NO se hace, que es el fallo que se paga caro: **no se genera otra**.
+        // Un `catch` que cae a `generateKey` con la llave delante, sellada, le cambiaría
+        // la identidad a la cuenta y la dejaría fuera de su propio perfil para siempre.
+        if (guardado.sealed) {
+          const abierto = keyLock?.open ? await keyLock.open(guardado.sealed) : null
+          if (!abierto) return { privateKey: null, publicKey: await importPub(publicJwk), publicJwk, locked: true }
+          const privateKey = await crypto.subtle.importKey('jwk', JSON.parse(abierto), algo, true, privUses)
+          return { privateKey, publicKey: await importPub(publicJwk), publicJwk }
+        }
+        const privateKey = await crypto.subtle.importKey('jwk', guardado.privateJwk, algo, true, privUses)
         return { privateKey, publicKey: await importPub(publicJwk), publicJwk }
-      } catch (_) {}
+      } catch (e) {
+        // Solo se sigue de largo si NO había nada que abrir. Con una llave sellada
+        // delante, un error es un error: se propaga en vez de fabricar otra identidad.
+        if (String(raw).includes('"sealed"')) throw e
+      }
     }
     const pair = await crypto.subtle.generateKey(algo, true, pairUses)
     const privateJwk = await crypto.subtle.exportKey('jwk', pair.privateKey)
     const publicJwk = await crypto.subtle.exportKey('jwk', pair.publicKey)
-    kv.setItem(storageKey, JSON.stringify({ privateJwk, publicJwk }))
+    await guardarPar(storageKey, privateJwk, publicJwk)
     return { privateKey: pair.privateKey, publicKey: pair.publicKey, publicJwk }
   }
 
+  /**
+   * Escribe un par. Si hay candado ABIERTO, la privada va sellada; si no, en claro bajo el
+   * cifrado en reposo de siempre. Un perfil sin contraseña se queda como estaba.
+   */
+  async function guardarPar (storageKey, privateJwk, publicJwk) {
+    if (keyLock?.seal) {
+      const sealed = await keyLock.seal(JSON.stringify(privateJwk))
+      if (sealed) return kv.setItem(storageKey, JSON.stringify({ sealed, publicJwk }))
+    }
+    kv.setItem(storageKey, JSON.stringify({ privateJwk, publicJwk }))
+  }
+
+  /**
+   * ECHAR EL CANDADO A LA MAESTRA QUE YA EXISTE: se llama al abrir el perfil, cuando la
+   * llave de la contraseña está en la mano. Idempotente.
+   */
+  async function sealMasterKey () {
+    const raw = kv.getItem(KEY_STORAGE)
+    if (!raw || !keyLock?.seal) return { ok: false, reason: 'sin-candado' }
+    const guardado = JSON.parse(raw)
+    if (guardado.sealed) return { ok: true, already: true }
+    await guardarPar(KEY_STORAGE, guardado.privateJwk, guardado.publicJwk)
+    return { ok: true, sealed: true }
+  }
+
+  /**
+   * LA LLAVE PARA FIRMAR, o un error con nombre.
+   *
+   * Todo lo que firme con la maestra pasa por aquí. Cerrada, `keypair.privateKey` es
+   * `null` y sin esto reventaría con un `TypeError` a diez marcos de profundidad —
+   * ilegible para quien lo recibe e indistinguible de un fallo de red. El código va
+   * aparte del texto porque el texto se traduce (ver el contrato de errores).
+   */
+  function masterKey () {
+    if (!keypair?.privateKey) {
+      throw Object.assign(new Error('vault locked: the master key is sealed; unlock the profile to sign'), { code: 'vault-locked' })
+    }
+    return keypair.privateKey
+  }
+
   const loadOrCreateKeypair = () => loadOrCreatePair('sign', KEY_STORAGE)
   const loadOrCreateEncKeypair = () => loadOrCreatePair('enc', ENC_KEY_STORAGE)
 
@@ -277,40 +336,30 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
   function loadJson (key) { try { return JSON.parse(kv.getItem(key) || '{}') || {} } catch (_) { return {} } }
 
-  // PODA (los dos registros crecían para siempre): la renovación automática firma un cert
-  // nuevo cada 30 días, así que sin podar cada dispositivo dejaba 12 entradas muertas al año.
-  // Se tira lo que YA NO PUEDE SERVIR, nunca lo vivo:
-  //   · delegación → cuando su `exp` ya pasó (un cert vencido no autoriza nada).
-  //     OJO: no se poda «la anterior del mismo dispositivo» al renovar, porque el cert
-  //     viejo SIGUE VIGENTE hasta su exp y hay que poder revocarlo si te roban el aparato.
-  //   · revocación → 30 días después de revocar: para entonces el cert al que apunta está
-  //     vencido seguro (el tope duro de vida es `MAX_DELEGATION_MS`, y exp ≤ iat + 30 días
-  //     ≤ revokedAt + 30 días), y un cert vencido ya falla por `expired` sin mirar la lista.
-  const DELEGATION_MAX_LIFE_MS = 30 * 24 * 60 * 60 * 1000 // espejo de MAX_DELEGATION_MS (capabilities.js)
-
-  function loadDelegations () {
-    const o = loadJson(DELEGATIONS_STORAGE)
-    const now = Date.now()
-    let changed = false
-    for (const k of Object.keys(o)) {
-      const exp = o[k]?.exp
-      if (typeof exp === 'number' && exp < now) { delete o[k]; changed = true }
-    }
-    if (changed) kv.setItem(DELEGATIONS_STORAGE, JSON.stringify(o))
-    return o
-  }
+  // YA NO SE PODA NADA, y el motivo es que la poda existía por el reloj.
+  //
+  // Antes se tiraba lo VENCIDO, porque la renovación automática firmaba un papel nuevo cada
+  // 30 días y sin podar cada aparato dejaba doce entradas muertas al año. Con el papel atado
+  // al acta esa renovación desaparece: solo se emite uno nuevo cuando el acta cambia lo que
+  // ese aparato puede, y ahí `revokePriorCertsFor` ya retira el anterior. O sea que el
+  // registro crece con los CAMBIOS DE POLÍTICA, no con el calendario.
+  //
+  // Se probó podar «lo que el acta ya no nombra» y se descartó: borra en silencio, y un
+  // registro que se borra solo es justo lo que no quieres tener delante cuando estás
+  // averiguando qué pasó. Las revocaciones, por lo mismo, son PARA SIEMPRE: se podaban a
+  // los 30 días porque para entonces el papel estaba vencido seguro, y sin vencimiento
+  // olvidar una revocación lo resucita.
+  const loadDelegations = () => loadJson(DELEGATIONS_STORAGE)
   const saveDelegations = (o) => kv.setItem(DELEGATIONS_STORAGE, JSON.stringify(o))
 
+  /**
+   * Las revocaciones NO se podan por tiempo. Se podaban a los 30 días porque para entonces
+   * el papel al que apuntaban estaba vencido seguro; sin vencimiento ese razonamiento se
+   * cae, y olvidar una revocación **resucita el papel**. Se quedan mientras el aparato siga
+   * en el acta; cuando se le echa, se van con él (`loadDelegations` hace lo mismo).
+   */
   function loadRevocations () {
-    const o = loadJson(REVOCATIONS_STORAGE)
-    const now = Date.now()
-    let changed = false
-    for (const k of Object.keys(o)) {
-      const at = o[k]
-      if (typeof at === 'number' && now - at > DELEGATION_MAX_LIFE_MS) { delete o[k]; changed = true }
-    }
-    if (changed) kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
-    return o
+    return loadJson(REVOCATIONS_STORAGE)
   }
   const saveRevocations = (o) => kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
 
@@ -503,14 +552,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // Marcador nuevo (o JWK legado que ES la llave del perfil): usar la CryptoKey
       // no extractable del perfil para firmar; nada de privadas en claro.
       if (d.useIdentityKey || (d.publickey === publickeyJwkStr && !d.privateJwk)) {
-        return { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+        return { publickey: publickeyJwkStr, privateKey: masterKey() }
       }
       // MIGRACIÓN: el emparejamiento viejo persistía la privada del perfil en
       // claro aquí. Si es la misma llave del perfil, reemplazar por el marcador
       // (borra el último JWK plano) y firmar con la CryptoKey.
       if (d.privateJwk && d.publickey === publickeyJwkStr) {
         kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
-        return { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+        return { publickey: publickeyJwkStr, privateKey: masterKey() }
       }
       return d // legado real (dispositivo con llave propia distinta)
     } catch (_) { return null }
@@ -591,7 +640,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   let sealKeyProvider = null
 
   /** Sella con la llave del perfil (CryptoKey, puede ser no extractable). */
-  const seal = (acta) => Acta.sealActa({ acta, privateKey: keypair.privateKey })
+  const seal = (acta) => Acta.sealActa({ acta, privateKey: masterKey() })
 
   /**
    * Aplica cambios, sella y guarda. Solo funciona si este dispositivo es el master: es la
@@ -759,14 +808,14 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
     // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
     // y NO se persiste ningún JWK del dispositivo (marcador useIdentityKey).
-    const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+    const device = { publickey: publickeyJwkStr, privateKey: masterKey() }
     // Si esta identidad ya existía por su cuenta, se lleva un certificado de continuidad
     // firmado por ella misma: es el puente para que su reputación previa siga contando.
     // Solo si esta llave tenía vida propia. Una recién creada para adoptar (camino B) no
     // tiene pasado que salvar: mandarle un puente de continuidad sería puro ruido.
     const mine = loadActa()
     const continuity = (mine && mine.members.length === 1 && !isPendingJoin())
-      ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mine.profileId, privateKey: keypair.privateKey })
+      ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mine.profileId, privateKey: masterKey() })
       : null
     const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
     kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
@@ -775,7 +824,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
     emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join: unido })
     pullProfileFromVault() // adoptar el perfil que ya viva en el vault (si hay)
-    return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join: unido }
+    return { ok: true, deviceId: res.deviceId, master: res.master, seq: res.cert.seq, scope: res.cert.scope, join: unido }
   }
 
   /**
@@ -826,7 +875,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // segundo plano un `vault.renew`: el vault firma un cert fresco (30 días) para la
   // misma sub-clave y scope. Mientras uses el ecosistema ~1 vez al mes, nunca vence.
   // Un cert YA vencido o revocado no puede renovarse (ahí sí, re-emparejar).
-  const RENEW_WINDOW_MS = 15 * 24 * 60 * 60 * 1000
+  // Ya no hay ventana de caducidad: el papel no vence. Lo único que obliga a pedir uno
+  // nuevo es que el ACTA diga algo distinto de lo que lleva escrito.
   const RENEW_RETRY_MS = 60 * 60 * 1000 // si falla (vault apagado), no insistir >1 vez/hora
   let renewLastTry = 0
   /**
@@ -852,10 +902,12 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) return
       const now = Date.now()
-      // Se renueva por dos motivos: porque el cert se acerca a su fin, o porque el acta
-      // dice que este aparato puede algo distinto de lo que lleva escrito el cert.
-      const porCaducar = v.cert.exp > now && v.cert.exp - now <= RENEW_WINDOW_MS
-      if (v.cert.exp <= now || (!porCaducar && !certDesfasadoDelActa())) return
+      // UN SOLO MOTIVO: que el acta diga algo distinto de lo que lleva el papel. El otro
+      // —«se acerca su fin»— era el que obligaba a la bóveda a firmar sola cada mes, y con
+      // él se va la última razón por la que la maestra tenía que estar disponible sin nadie
+      // delante. Renovar pasa a ocurrir justo cuando ya hay una selladora abierta, porque
+      // cambiar el acta ES tenerla abierta.
+      if (!certDesfasadoDelActa()) return
       if (now - renewLastTry < RENEW_RETRY_MS) return
       renovarCert().catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
     } catch (_) {}
@@ -868,7 +920,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     renewLastTry = Date.now()
     const { cert } = await remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink })
     kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ ...v, cert, renewedAt: Date.now() }))
-    emitVault({ phase: 'renewed', exp: cert.exp })
+    emitVault({ phase: 'renewed', seq: cert.seq })
     return cert
   }
 
@@ -1050,7 +1102,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   let profilePushTimer = null
   function pushProfileToVault () {
     const v = loadVaultCert(); const device = loadVaultDevice()
-    if (!v?.cert || !device || v.cert.exp <= Date.now()) return
+    if (!v?.cert || !device) return
     clearTimeout(profilePushTimer)
     profilePushTimer = setTimeout(() => {
       const { publickey, encryptionPubkey, ...content } = me || {}
@@ -1085,7 +1137,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const r = await remoteCheck({
         master: Acta.sealersOf(acta)[0] || null,
         proxy: v?.proxy || 'wss://proxy.dotrino.com',
-        device: { publickey: publickeyJwkStr, privateKey: keypair.privateKey },
+        device: { publickey: publickeyJwkStr, privateKey: masterKey() },
         onRevoked: wipeVaultLink
       })
       if (r?.error) console.warn('[identity] could not confirm membership with the vault:', r.error)
@@ -1209,7 +1261,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     async signChallenge ({ nonce }) {
       if (!nonce || typeof nonce !== 'string') throw new Error('nonce required')
       const bytes = new TextEncoder().encode(nonce)
-      const signature = await signBytes(keypair.privateKey, bytes)
+      const signature = await signBytes(masterKey(), bytes)
       return { nonce, publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, signature }
     },
 
@@ -1240,7 +1292,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const issuedAt = Date.now()
       const envelope = { subject: publickey, rating: r, notes: safeNotes, ratedBy: publickeyJwkStr, issuedAt }
       const sigBytes = new TextEncoder().encode(canonicalStringify(envelope))
-      const signature = await signBytes(keypair.privateKey, sigBytes)
+      const signature = await signBytes(masterKey(), sigBytes)
       const myRating = { ...envelope, signature }
       return upsertPeer(publickey, { myRating, rating: r, notes: safeNotes })
     },
@@ -1359,7 +1411,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         const bytes = new TextEncoder().encode(canonicalStringify(data))
         const acta = loadActa()
         return {
-          signature: await signBytes(keypair.privateKey, bytes),
+          signature: await signBytes(masterKey(), bytes),
           publickey: publickeyJwkStr,
           // A NOMBRE DE QUIÉN VA. `publickey` es la llave de ESTE aparato, y las apps la
           // venían guardando como si fuera la identidad: publicar desde el teléfono y
@@ -1391,16 +1443,26 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // de dispositivo `sub`, acotado por `scope` y `exp`, revocable por `nonce`.
     // Es la ÚNICA forma en que la autoridad sale de la clave maestra, y va limitada.
 
-    async signDelegation ({ sub, scope, ttlMs, exp, nonce, label, supersede }) {
+    /**
+     * EL PAPEL NO CADUCA POR RELOJ: lleva el `seq` del acta con el que se emitió.
+     *
+     * `ttlMs`/`exp` se aceptan y se IGNORAN a propósito, para no romper a quien todavía los
+     * pasa (el daemon, `enroll.js`). Reventar ahí dejaría sin emparejar a media cadena por
+     * un parámetro que ya no significa nada.
+     */
+    async signDelegation ({ sub, scope, nonce, label, supersede }) {
       if (!sub || typeof sub !== 'string') throw new Error('sub (device pubkey) required')
       if (!scope || (typeof scope !== 'string' && !Array.isArray(scope))) throw new Error('scope required')
       const iat = Date.now()
-      const want = typeof exp === 'number' ? exp : iat + (Number(ttlMs) || DEFAULT_DELEGATION_MS)
-      const cappedExp = Math.min(want, iat + MAX_DELEGATION_MS)   // tope duro de vida
+      // El acta con la que se emite. Sin acta no hay papel: el certificado dice «una
+      // selladora de ESTE perfil, mirando ESTA acta, avaló esta llave», y sin acta no se
+      // puede decir ninguna de las dos cosas.
+      const acta = loadActa()
+      if (!acta) throw Object.assign(new Error('this profile has no record to issue against'), { code: 'sin-acta' })
       // `iss` se FUERZA a la propia maestra: el usuario no puede emitir cert para otro emisor.
-      const cert = await signDelegationWith(keypair.privateKey, publickeyJwkStr, { sub, scope, iat, exp: cappedExp, nonce: nonce || crypto.randomUUID() })
+      const cert = await signDelegationWith(masterKey(), publickeyJwkStr, { sub, scope, iat, seq: acta.seq, nonce: nonce || crypto.randomUUID() })
       const store = loadDelegations()
-      store[cert.nonce] = { nonce: cert.nonce, sub, scope, iat, exp: cappedExp, label: typeof label === 'string' ? label.slice(0, 60) : '' }
+      store[cert.nonce] = { nonce: cert.nonce, sub, scope, iat, seq: acta.seq, label: typeof label === 'string' ? label.slice(0, 60) : '' }
       saveDelegations(store)
       // UNA LLAVE, UN CERTIFICADO VIGENTE. Renovar emitía uno nuevo y dejaba vivo el
       // anterior: el mismo aparato salía dos veces en la lista (parecían dos máquinas) y,
@@ -1702,7 +1764,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if ((Array.isArray(caps) ? caps : [caps]).includes('sealer')) {
         throw new Error('sealing cannot be renounced: ask another sealer to take it from you')
       }
-      const record = await Acta.makeRenounce({ member: publickeyJwkStr, caps, privateKey: keypair.privateKey })
+      const record = await Acta.makeRenounce({ member: publickeyJwkStr, caps, privateKey: masterKey() })
       const pend = loadRenounces().filter((r) => r.member !== publickeyJwkStr)
       pend.push(record)
       saveRenounces(pend)
@@ -1956,7 +2018,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (!mine) throw new Error('this device has no account to hand over yet')
       if (!amMaster()) throw new Error('not-the-master: another device or vault is in charge of this account; the handover is done from there')
 
-      const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+      const device = { publickey: publickeyJwkStr, privateKey: masterKey() }
       const res = await remoteEnroll({
         qr,
         device,
@@ -2011,7 +2073,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert()
       if (!v?.cert) return { paired: false }
       maybeRenewVaultCert()
-      return { paired: true, deviceId: v.deviceId, master: v.master, proxy: v.proxy, scope: v.cert.scope, exp: v.cert.exp, pairedAt: v.pairedAt }
+      return { paired: true, deviceId: v.deviceId, master: v.master, proxy: v.proxy, scope: v.cert.scope, seq: v.cert.seq, pairedAt: v.pairedAt }
     },
 
     async vaultUnpair () {
@@ -2456,6 +2518,16 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   return {
     handlers,
     get me () { return me },
+    /** ¿Está la maestra bajo llave? Cerrada, esta identidad NO puede firmar nada. */
+    get masterLocked () { return !keypair?.privateKey },
+    /** Echa el candado a la maestra que ya existía (al abrir el perfil). Idempotente. */
+    sealMasterKey,
+    /** Recarga el par tras abrir el candado, sin reabrir la identidad entera. */
+    async reloadMasterKey () {
+      keypair = await loadOrCreateKeypair()
+      publickeyJwkStr = JSON.stringify(keypair.publicJwk)
+      return { locked: !keypair?.privateKey }
+    },
     sync,
     onSyncStatus (fn) { if (sync) sync.onStatus(fn) },
     onVaultEvent (fn) { vaultListeners.add(fn); return () => vaultListeners.delete(fn) }

package/vault/remote.js

@@ -13,7 +13,8 @@
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId, PEER_SKEW_MS } from './capabilities.js'
+import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
+import { sealersOf } from './acta.js'
 
 const MSG = {
   HELLO: 'vault.hello',
@@ -208,11 +209,22 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     }
 
     // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
-    // `PEER_SKEW_MS`: el cert lo acaba de sellar la bóveda con SU reloj y lo valida ESTE
-    // aparato con el suyo. Sin margen, ir 850 ms por detrás bastaba para no poder enrolarse.
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey, skewMs: PEER_SKEW_MS })
+    //
+    // EL ACTA VIAJA CON EL PAPEL y hace falta para juzgarlo: el cert lleva el `seq` del acta
+    // con el que se emitió, y quien lo emitió tiene que ser SELLADORA de ese acta. Lo que se
+    // fija ya no es la LLAVE que firma —con varias selladoras puede ser otra del mismo
+    // perfil— sino el PERFIL: el del QR, que es el que el usuario vio.
+    //
+    // (Aquí vivía el margen de reloj: el cert lo sellaba la bóveda con SU reloj y lo validaba
+    // este aparato con el suyo, y 850 ms de diferencia bastaban para no poder enrolarse. Sin
+    // vencimiento no hay ventana que ajustar y el problema no puede volver.)
+    if (!res.acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
+    if (res.acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw')
+    const v = await verifyDelegation({
+      cert: res.cert, expectedSub: dev.publickey,
+      actaSeq: res.acta.seq, sealers: sealersOf(res.acta)
+    })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.iss !== qr.iss) throw new Error('cert signed by a master key different from the one you saw')
     if (res.cert.sub !== dev.publickey) throw new Error('cert issued for a different device')
     return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
   } finally { try { client.close() } catch (_) {} }