@dotrino/identity 0.66.0 → 0.68.0

package/package.json

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

package/vault/acta.js

@@ -37,7 +37,7 @@
 import { canonicalStringify } from './core.js'
 import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
 
-export const ACTA_V = 2
+export const ACTA_V = 4
 
 /**
  * Versiones de acta que se ACEPTAN al leer. La 1 sigue entrando porque una v1 en el disco
@@ -46,7 +46,26 @@ export const ACTA_V = 2
  * asciende sola: el acta siguiente que selle la maestra ya sale v2 (ver `applyChanges`).
  * La única diferencia es la llave de sellado (§8.9), que en una v1 simplemente no hay.
  */
-const ACTA_LEIBLES = Object.freeze([1, 2])
+/**
+ * v3 quita `acta.sealer` (dueño, 2026-08-31: «SEAL es el nuevo master»): sellar es un
+ * permiso y nada más.
+ *
+ * Las anteriores SE SIGUEN LEYENDO, y no por nostalgia: dejar de hacerlo dejaría sin abrir
+ * TODAS las cuentas que existen hoy —cada una tendría que rehacerse aparato por aparato—
+ * cuando lo único que hace falta es traducir el campo a un permiso al leerlas. Un acta
+ * vieja no se puede reescribir (está firmada), así que se lee tal cual y `canSeal` la
+ * 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])
+/** 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. */
+const conCadena = (acta) => Number(acta?.v) >= V_CON_CADENA
+/** Desde esta versión, sellar es solo un permiso y no hay campo `sealer`. */
+const V_SIN_CAMPO_SELLADOR = 3
+/** ¿Este acta es de las viejas, con el campo? */
+const conCampoSellador = (acta) => Number(acta?.v) < V_SIN_CAMPO_SELLADOR
 
 /**
  * Lista CERRADA de capacidades.
@@ -182,26 +201,20 @@ export async function memberId (pub) {
  */
 export const sealersOf = (acta, renounces = []) => {
   if (!acta) return []
-  const extra = (acta.members || [])
-    .filter((m) => m.pub !== acta.sealer && memberCan(acta, m.pub, 'sealer', renounces))
+  const porPermiso = (acta.members || [])
+    .filter((m) => memberCan(acta, m.pub, 'sealer', renounces))
     .map((m) => m.pub)
-  return [acta.sealer, ...extra]
+  // Acta vieja: el que estaba en el campo sellaba SIN tener el permiso. Se traduce al
+  // leerla, que es la única forma —está firmada y no se puede reescribir—.
+  if (conCampoSellador(acta) && acta.sealer && !porPermiso.includes(acta.sealer)) {
+    return [acta.sealer, ...porPermiso]
+  }
+  return porPermiso
 }
 
 /** ¿Puede `pub` sellar la siguiente acta de este perfil? */
 export const canSeal = (acta, pub, renounces = []) =>
-  !!acta && (pub === acta.sealer || memberCan(acta, pub, 'sealer', renounces))
-
-/**
- * El acta la firmó alguien DISTINTO del sellador que ella misma nombra.
- *
- * ⚠️ Desde el multivault esto ya NO significa «es un traspaso», y confundirlo costó un
- * desempate mal resuelto: cuando sella la segunda bóveda, el acta sigue nombrando
- * sellador a la primera y la firma la segunda, así que esto da `true` sin que nadie
- * traspase nada. Es condición NECESARIA de un traspaso, no suficiente — lo que lo
- * distingue es que un traspaso CAMBIA a quién nombra (ver `canAdopt`).
- */
-export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
+  !!acta && (memberCan(acta, pub, 'sealer', renounces) || (conCampoSellador(acta) && pub === acta.sealer))
 
 /**
  * Acta de génesis: un perfil recién nacido tiene UN miembro (esta llave), que además es el
@@ -213,11 +226,16 @@ export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', n
   return {
     v: ACTA_V,
     profileId: pub,
-    sealer: pub,
     sealedBy: pub,
     seq: 1,
     prev: null,
-    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS], addedAt: now, cert: null }],
+    // LA CADENA DE SELLADORES. El génesis es el ancla: está autofirmado por la llave que
+    // da nombre al perfil, así que no apunta a nada y no hay nada que falsificar sin ella.
+    sealerAnchor: null,
+    // `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,
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS, 'sealer'], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
@@ -239,7 +257,10 @@ export function genesisActa ({ pub, encPub = null, sealPub = null, label = '', n
 export function checkShape (acta) {
   if (!acta || typeof acta !== 'object') return 'no-acta'
   if (!ACTA_LEIBLES.includes(acta.v)) return 'version'
-  if (!isPub(acta.profileId) || !isPub(acta.sealer) || !isPub(acta.sealedBy)) return 'shape'
+  if (!isPub(acta.profileId) || !isPub(acta.sealedBy)) return 'shape'
+  // El campo solo existe —y solo se exige— en las viejas.
+  if (conCampoSellador(acta) && !isPub(acta.sealer)) return 'shape'
+  if (!conCampoSellador(acta) && acta.sealer != null) return 'sealer-no-va-en-v3'
   if (!Number.isInteger(acta.seq) || acta.seq < 1) return 'seq'
   if (acta.seq > 1 && typeof acta.prev !== 'string') return 'prev'
   if (!Array.isArray(acta.members) || acta.members.length === 0) return 'members'
@@ -279,7 +300,22 @@ export function checkShape (acta) {
   }
   }
   if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
-  if (!acta.members.some((m) => m.pub === acta.sealer)) return 'sealer-no-es-miembro'
+  // SIN NADIE QUE SELLE, el acta está muerta: no habría forma de volver a cambiarla nunca.
+  // Es el hermano del cierre de `sign`, y sustituye a «el sellador tiene que ser miembro»
+  // ahora que sellar es solo un permiso y los permisos ya son de miembros por definición.
+  if (!sealersOf(acta).length) return 'sin-sellador'
+  // La cadena de selladores: el génesis es el ancla (`null`); cualquier otra apunta a un
+  // eslabón anterior. Sin `hash` no se puede encadenar nada, así que se exige la forma.
+  if (acta.sealerAnchor != null) {
+    const a = acta.sealerAnchor
+    if (typeof a !== 'object' || !Number.isInteger(a.seq) || a.seq < 1 || a.seq >= acta.seq) return 'sealeranchor'
+    if (typeof a.hash !== 'string' || !/^[0-9a-f]{64}$/.test(a.hash)) return 'sealeranchor'
+  }
+  // El ancla NO se exige: una cuenta que viene de antes de v4 escribe su primera acta
+  // nueva sin poder apuntar a nada (su padre no era eslabón), y exigirla la dejaría
+  // inválida. Lo que sostiene la cadena no es el ancla sino que **cada eslabón lo selle
+  // alguien a quien el anterior autorizaba**; el ancla añade que no se pueda empalmar un
+  // eslabón de otra rama, y se comprueba cuando viene (ver `verifySealerChain`).
   if (!acta.members.some((m) => m.caps.includes('sign'))) return 'sin-firmante'
   return null
 }
@@ -301,6 +337,60 @@ export async function sealActa ({ acta, privateKey, privateJwk }) {
  * decide aquí sino al adoptarla (`canAdopt`), comparándola con la que ya tienes.
  * @returns {{ok:boolean, reason?:string}}
  */
+/**
+ * ¿HABLA ESTA ACTA POR ESTA IDENTIDAD? Lo que comprueba un EXTRAÑO, sin saber nada de ti.
+ *
+ * Recibe la cadena de selladores: `[génesis, …cambios de sellador…, acta actual]`. No son
+ * todas tus actas —eso crecería con cada emparejamiento— sino solo los eslabones donde
+ * cambió quién sella, que casi nunca pasa. Lo normal es longitud 1 o 2.
+ *
+ * Qué se comprueba, y por qué basta:
+ *   1. el primer eslabón es el GÉNESIS y está autofirmado por `profileId`. Ese es el
+ *      ancla: sin esa llave no se puede fabricar, y el `profileId` ya lo conoce quien
+ *      verifica (viaja en cada firma tuya);
+ *   2. cada eslabón siguiente lo selló alguien a quien el ANTERIOR autorizaba;
+ *   3. y apunta al anterior por `seq` + hash, así que no se puede colar uno de otra rama.
+ *
+ * Sin esto, un acta suelta es falsificable: con tu `profileId` cualquiera fabrica una
+ * donde él sella, y `verifyActa` la da por buena — está firmada, solo que por él.
+ *
+ * Lo que NO resuelve, y no lo esconde: la frescura. Quien guardó una cadena vieja sigue
+ * aceptando a un sellador que ya retiraste. Es el problema de siempre y hace falta un
+ * oráculo, no más firmas.
+ */
+export async function verifySealerChain (chain, { expectedProfileId = null } = {}) {
+  if (!Array.isArray(chain) || !chain.length) return { ok: false, reason: 'cadena-vacia' }
+  const [raiz] = chain
+
+  if (raiz.seq !== 1 || raiz.sealerAnchor != null) return { ok: false, reason: 'no-empieza-en-genesis' }
+  // El ancla: el génesis se firma a sí mismo con la llave que da nombre al perfil.
+  if (raiz.sealedBy !== raiz.profileId) return { ok: false, reason: 'genesis-no-autofirmado' }
+  if (expectedProfileId != null && raiz.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  const vr = await verifyActa({ acta: 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: 'otro-perfil' }
+    const v = await verifyActa({ acta: actual })
+    if (!v.ok) return { ok: false, reason: `eslabon-${i}:` + v.reason }
+    // Encadena con el anterior: mismo `seq` y mismo hash. Sin el hash bastaría con
+    // acertar un número para colar un eslabón de otra rama.
+    // El ancla, SI viene: fija que este eslabón sale del anterior y no de otra rama. Una
+    // cuenta anterior a v4 puede no traerla, y entonces lo que sostiene la cadena es lo de
+    // abajo — que es lo que de verdad impide falsificarla.
+    const a = actual.sealerAnchor
+    if (a && (a.seq !== previo.seq || a.hash !== await actaHash(previo))) {
+      return { ok: false, reason: `eslabon-${i}:no-encadena` }
+    }
+    // Y lo que da la autoridad: quien la selló tenía permiso SEGÚN EL ESLABÓN ANTERIOR.
+    if (!canSeal(previo, actual.sealedBy)) return { ok: false, reason: `eslabon-${i}:sellador-no-autorizado` }
+  }
+  const ultima = chain[chain.length - 1]
+  return { ok: true, profileId: raiz.profileId, seq: ultima.seq, sealers: sealersOf(ultima) }
+}
+
 export async function verifyActa ({ acta, expectedProfileId } = {}) {
   const shape = checkShape(acta)
   if (shape) return { ok: false, reason: shape }
@@ -436,7 +526,6 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
       case 'remove': {
         const i = next.members.findIndex((m) => m.pub === ch.pub)
         if (i < 0) throw new Error('remove: that member is not in the record')
-        if (next.members[i].pub === next.sealer) throw new Error('remove: cannot remove the master; hand the sealing over first')
         // Quitar al miembro se lleva su permiso de sellar: no hay lista aparte que limpiar.
         const fuera = next.members.splice(i, 1)[0]
         // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
@@ -447,11 +536,6 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
         })
         break
       }
-      case 'handover': {
-        if (!find(ch.to)) throw new Error('handover: the new master must be a member (admit them in the same change)')
-        next.sealer = ch.to
-        break
-      }
       case 'keyring': {
         // Generación NUEVA de la clave de contenido (al rotar: expulsar a alguien).
         const g = ch.generation
@@ -493,8 +577,60 @@ export async function applyChanges (acta, changes, { by, now = Date.now(), sealP
   if (!next.members.some((m) => m.caps.includes('sign'))) {
     throw new Error('the change would leave the profile with no member able to sign')
   }
-  if (!next.members.some((m) => m.pub === next.sealer)) {
-    throw new Error('the change would leave the record with no master')
+  // ASCENDER DE UNA VIEJA: el que sellaba por el CAMPO pasa a sellar por el PERMISO. Es
+  // toda la migración, y va aquí porque este es el momento en que la cuenta escribe su
+  // primera v3 — el acta vieja no se puede tocar, está firmada.
+  if (conCampoSellador(acta) && acta.sealer) {
+    const m = next.members.find((x) => x.pub === acta.sealer)
+    if (m && !m.caps.includes('sealer')) m.caps = cleanCaps([...m.caps, 'sealer'])
+    // Y el campo se va con la vieja: la nueva es v3 y en v3 no existe.
+    delete next.sealer
+  }
+  if (!sealersOf(next).length) {
+    throw new Error('the change would leave the record with nobody able to seal it')
+  }
+
+  /**
+   * LA CADENA DE SELLADORES. Es lo que deja a un EXTRAÑO comprobar que quien firmó esto
+   * habla por esta identidad, sin tener que mandarle todas las actas.
+   *
+   * El problema: el acta suelta es falsificable —con tu `profileId`, que es público,
+   * cualquiera fabrica una donde él sella—. Y mandar la cadena entera no sale a cuenta
+   * porque crece con cada emparejamiento, que es lo que más cambia.
+   *
+   * La salida: solo encadenar los eslabones donde CAMBIA quién sella, que casi nunca pasa.
+   * Un usuario normal tiene cadena de longitud 1 —el génesis— para siempre; con una
+   * segunda bóveda, 2. Ese es el tamaño real, no el número de actas.
+   *
+   * Cada acta apunta al último cambio ANTERIOR a ella, nunca a sí misma (sería circular:
+   * el puntero va dentro de lo que se firma). Y `sealerChanged` dice si ELLA es uno, para
+   * que la siguiente sepa a dónde apuntar teniendo solo a su padre delante.
+   *
+   * Y lo que esto resuelve y el génesis firmando no resolvía: **no hace falta la llave del
+   * génesis para sumar un sellador.** La bóveda que ya está autorizada sella el acta que
+   * autoriza a la siguiente, y ese eslabón vale porque el anterior la autorizaba a ella.
+   * El génesis firmó el eslabón 1 y puede estar perdido desde entonces — que es justo el
+   * desastre para el que existe el multivault.
+   */
+  const antes = sealersOf(acta).slice().sort().join('|')
+  const despues = sealersOf(next).slice().sort().join('|')
+  next.sealerChanged = antes !== despues
+  next.sealerAnchor = acta.sealerChanged
+    ? { seq: acta.seq, hash: await actaHash(acta) }
+    : (acta.sealerAnchor || null)
+  // EL DOBLE FILTRO (dueño, 2026-08-31): un acta nueva tiene que pasar el filtro de la
+  // ANTERIOR —quién podía sellar, arriba— y también el de LA QUE SE VA A FIRMAR. Si no
+  // pasa los dos, no se firma.
+  //
+  // Lo que cierra: un sellador que se quita a sí mismo el permiso en la misma acta que
+  // firma. Es absurdo —se firma con una autoridad que uno acaba de retirarse— y no tiene
+  // vuelta atrás: deshacerlo requeriría sellar, que es justo lo que se acaba de perder.
+  //
+  // Y por qué aquí y no con una marca de «traspaso»: mirando el acta SOLA, ceder el mando
+  // y quitarse el permiso se ven igual. Con las dos actas delante no hay ambigüedad, y las
+  // dos veces que esto importa —construirla, y adoptar una ajena— se tienen las dos.
+  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')
   }
   return next
 }
@@ -761,21 +897,11 @@ export async function canAdopt ({ candidate, current }) {
     // exactamente lo que dice que las dos salieron de ella.
     const mismoFirmante = candidate.sealedBy === current.sealedBy
     if (!mismoFirmante && !canSeal(current, candidate.sealedBy)) return { adopt: false, reason: 'otro-sellador' }
-    // UN TRASPASO ES EL QUE CAMBIA A QUIÉN NOMBRA, no el que firma otro. Con una sola
-    // bóveda daba igual —solo un traspaso podía firmar sin ser el sellador—, pero con dos
-    // la segunda firma sin serlo cada vez que sella, y entonces TODA acta suya se leía
-    // como un traspaso y ganaba el desempate por la puerta de atrás.
-    //
-    // Las dos ramas salen del mismo padre, así que comparar a quién nombra cada una
-    // resuelve los tres casos: si nombran al mismo (dos coselladores trabajando), no hay
-    // traspaso y decide el hash; si una nombra a otro, esa es la que traspasa y gana; y
-    // si las dos traspasan a destinos distintos, vuelven a empatar y decide el hash,
-    // que es lo que §2.4.1 ya decía.
-    const mismoSellador = candidate.sealer === current.sealer
-    const canT = isHandover(candidate) && !mismoSellador
-    const curT = isHandover(current) && !mismoSellador
-    if (canT && !curT) return { adopt: true, reason: 'traspaso-gana' }
-    if (!canT && curT) return { adopt: false, reason: 'traspaso-gana' }
+    // SOLO QUEDA EL HASH. Antes había una regla más —«gana la que traspasa»— que existía
+    // para arbitrar el campo `sealer`: dos ramas que cedían el mando a destinos distintos.
+    // Ese campo ya no existe (dueño, 2026-08-31: «SEAL es el nuevo master»), y con él se
+    // va la regla y la ambigüedad que arrastraba: `sealer !== sealedBy` significaba
+    // «traspaso» con un solo master y dejó de significarlo con varios selladores.
     return hCan < hCur ? { adopt: true, reason: 'desempate-hash' } : { adopt: false, reason: 'desempate-hash' }
   }
 
@@ -783,7 +909,7 @@ export async function canAdopt ({ candidate, current }) {
 }
 
 export default {
-  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
+  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, verifySealerChain,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
   makeContinuity, verifyContinuity,
   cardBody, makeProfileCard, verifyProfileCard, canAdoptCard, sealersOf, canSeal,

package/vault/core.js

@@ -528,19 +528,55 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // que la nueva desciende de la que uno tenía. Más viejo que la ventana ⇒ re-admitirse.
   const ACTA_WINDOW = 50
   const loadHistory = () => { try { return JSON.parse(kv.getItem(ACTA_HISTORY_STORAGE) || '[]') || [] } catch (_) { return [] } }
+  /**
+   * LOS ESLABONES DE LA CADENA DE SELLADORES NO CADUCAN (dueño, 2026-08-31).
+   *
+   * El resto sí: la ventana existe para que un miembro que estuvo apagado compruebe el
+   * encadenamiento al volver, y para eso las últimas bastan. Pero los eslabones donde
+   * CAMBIÓ quién sella son otra cosa — son lo que deja a un EXTRAÑO anclar en el génesis
+   * y saber que hablas tú. Si la poda se los lleva, nadie de fuera puede verificar nada
+   * tuyo nunca más, y no hay forma de reconstruirlos.
+   *
+   * El comentario de la ventana decía «un tercero no las necesita, le basta el snapshot
+   * actual». Era cierto mientras el ancla fuera una llave fija; dejó de serlo en cuanto
+   * varias llaves pueden sellar.
+   *
+   * No crecen: solo suman al añadir o quitar una bóveda, que casi nunca pasa. Un usuario
+   * normal guarda uno —el génesis— para siempre.
+   */
   const pushHistory = (acta) => {
     if (!acta) return
     const h = loadHistory().filter((a) => a.seq !== acta.seq)
     h.push(acta)
     h.sort((a, b) => a.seq - b.seq)
-    kv.setItem(ACTA_HISTORY_STORAGE, JSON.stringify(h.slice(-ACTA_WINDOW)))
+    const ventana = h.slice(-ACTA_WINDOW)
+    const enVentana = new Set(ventana.map((a) => a.seq))
+    const eslabones = h.filter((a) => a.sealerChanged && !enVentana.has(a.seq))
+    kv.setItem(ACTA_HISTORY_STORAGE, JSON.stringify([...eslabones, ...ventana].sort((a, b) => a.seq - b.seq)))
+  }
+
+  /**
+   * La CADENA DE SELLADORES para mandarla con una firma: `[génesis, …cambios…, actual]`.
+   * Es lo que un extraño necesita para anclar en el `profileId`, y es corta a propósito —
+   * no lleva las actas de emparejar aparatos, que son casi todas.
+   */
+  const sealerChain = () => {
+    const cur = loadActa()
+    if (!cur) return []
+    const eslabones = loadHistory().filter((a) => a.sealerChanged).sort((a, b) => a.seq - b.seq)
+    return cur.sealerChanged ? eslabones : [...eslabones, cur]
   }
 
   const loadRenounces = () => { try { return JSON.parse(kv.getItem(RENOUNCE_STORAGE) || '[]') || [] } catch (_) { return [] } }
   const saveRenounces = (l) => kv.setItem(RENOUNCE_STORAGE, JSON.stringify(l))
 
   /** ¿Es ESTE dispositivo el master (el único que puede sellar)? */
-  const amMaster = () => loadActa()?.sealer === publickeyJwkStr
+  /**
+   * ¿PUEDO SELLAR? Antes era «¿soy el master?» y miraba un campo. Con sellar convertido en
+   * permiso, la pregunta correcta es esta — y su respuesta puede ser «sí» en más de un
+   * aparato a la vez, que es justo el punto del multivault.
+   */
+  const amMaster = () => Acta.canSeal(loadActa(), publickeyJwkStr, loadRenounces())
 
   /**
    * Quien sella SOBRES (la bóveda) pone aquí una función que estrena una llave de sellado
@@ -571,7 +607,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const sealed = await seal(next)
     pushHistory(acta) // la que deja de ser vigente entra en la ventana de retención
     saveActa(sealed)
-    emitVault({ phase: 'acta', seq: sealed.seq, sealer: sealed.sealer })
+    emitVault({ phase: 'acta', seq: sealed.seq, sealedBy: sealed.sealedBy })
     return sealed
   }
 
@@ -697,7 +733,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // retener; guardarla aquí solo mezclaría dos cuentas en la misma ventana (§1.3).
     kv.setItem(ACTA_HISTORY_STORAGE, '[]')
     clearPendingJoin()
-    emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, joined: true })
+    emitVault({ phase: 'acta', seq: candidate.seq, sealedBy: candidate.sealedBy, joined: true })
     return { joined: true, profileId: candidate.profileId, seq: candidate.seq }
   }
 
@@ -763,7 +799,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const r = await Acta.canAdopt({ candidate, current })
     if (!r.adopt) return { adopted: false, reason: r.reason, seq: current?.seq ?? null }
     saveActa(candidate)
-    emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, adopted: r.reason })
+    emitVault({ phase: 'acta', seq: candidate.seq, sealedBy: candidate.sealedBy, adopted: r.reason })
     const sigoDentro = (candidate.members || []).some((m) => m?.pub === publickeyJwkStr)
     if (!sigoDentro) {
       console.warn('[identity] the new record no longer lists this device: removing the account')
@@ -1025,7 +1061,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   async function askIfStillAMember () {
     try {
       const acta = loadActa()
-      if (!acta || acta.sealer === publickeyJwkStr) return          // no hay cuenta ajena que confirmar: mando yo
+      if (!acta || Acta.canSeal(acta, publickeyJwkStr)) return       // sello yo: no hay cuenta ajena que confirmar
       // El acta que ya tengo no me nombra: no hace falta preguntar nada, el acta manda y va
       // firmada. (Normalmente esto lo resuelve `adoptActa` al recibirla.)
       if (!(acta.members || []).some((m) => m?.pub === publickeyJwkStr)) {
@@ -1035,7 +1071,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert()
       if (v?.cert && loadVaultDevice()) return                      // con papel, ya lo comprueba el camino normal
       const r = await remoteCheck({
-        master: acta.sealer,
+        master: Acta.sealersOf(acta)[0] || null,
         proxy: v?.proxy || 'wss://proxy.dotrino.com',
         device: { publickey: publickeyJwkStr, privateKey: keypair.privateKey },
         onRevoked: wipeVaultLink
@@ -1493,7 +1529,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     async profileMembers () {
       const acta = loadActa()
-      if (!acta) return { members: [], profileId: null, seq: 0, sealer: null }
+      if (!acta) return { members: [], profileId: null, seq: 0, sealers: [] }
       const pend = loadRenounces()
       const members = await Promise.all(acta.members.map(async (m) => ({
         pub: m.pub,
@@ -1504,7 +1540,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         caps: Acta.effectiveCaps(acta, m.pub, pend),
         addedAt: m.addedAt || null,
         isMe: m.pub === publickeyJwkStr,
-        isMaster: m.pub === acta.sealer,
+        isMaster: Acta.canSeal(acta, m.pub),
         // La llave de CIFRADO del miembro y, derivado, si se le puede envolver algo.
         // Sale en la proyección porque sin ella ninguna interfaz (CLI, TUI, consola)
         // puede decir «a este aparato no se le puede escribir», y ese silencio es
@@ -1512,7 +1548,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         encPub: m.encPub || null,
         canSeal: !!m.encPub
       })))
-      return { members, profileId: acta.profileId, seq: acta.seq, sealer: acta.sealer, updatedAt: acta.updatedAt }
+      return { members, profileId: acta.profileId, seq: acta.seq, sealers: Acta.sealersOf(acta), updatedAt: acta.updatedAt }
     },
 
     async myMembership () {
@@ -1523,7 +1559,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
         inProfile: !!m,
         profileId: acta.profileId,
         seq: acta.seq,
-        isMaster: acta.sealer === publickeyJwkStr,
+        isMaster: Acta.canSeal(acta, publickeyJwkStr),
         caps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()),
         id: m ? await Acta.memberId(m.pub) : null
       }
@@ -1590,12 +1626,24 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * sellador tiene que ser miembro para poder serlo, y así no hay ventana intermedia.
      * Cubre igual dispositivo → bóveda y bóveda → bóveda (mudarse de PC).
      */
+    /**
+     * CEDER EL MANDO = CONCEDER `sella`. Ya no hay traspaso: sellar es un permiso, así que
+     * «pasarle el mando a otro» es dárselo, y punto. Lo que ANTES hacía esto —dejar de
+     * poder sellar uno mismo, en el mismo acto— ya no se puede: nadie se quita el sello a
+     * sí mismo (dejaría un acta que él firma sin poder firmarla). Si quieres salir, se lo
+     * pides al otro cuando ya pueda sellar.
+     */
     async handoverMaster ({ to, member = null } = {}) {
       const changes = []
-      if (member) changes.push({ op: 'admit', member: { ...member, pub: to } })
-      changes.push({ op: 'handover', to })
+      const acta0 = loadActa()
+      if (member) changes.push({ op: 'admit', member: { ...member, pub: to, caps: [...(member.caps || []), 'sealer'] } })
+      else {
+        const m = (acta0?.members || []).find((x) => x.pub === to)
+        if (!m) throw new Error('handover: the new sealer must be a member (admit them in the same change)')
+        changes.push({ op: 'caps', pub: to, caps: [...new Set([...(m.caps || []), 'sealer'])] })
+      }
       const acta = await sealChanges(changes)
-      return { ok: true, seq: acta.seq, sealer: acta.sealer }
+      return { ok: true, seq: acta.seq, sealers: Acta.sealersOf(acta) }
     },
 
     /**
@@ -1606,6 +1654,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     async renounceCaps ({ caps } = {}) {
       const acta = loadActa()
       if (!acta) throw new Error('this profile has no record yet')
+      // SELLAR NO SE RENUNCIA. Es la misma auto-amputación que el acta ya impide, por otra
+      // puerta: la renuncia es unilateral y no pasa por nadie, así que sin esto un
+      // sellador podría dejarse —o dejar a la cuenta— sin nadie que pueda volver a sellar,
+      // y eso no tiene marcha atrás. Que te lo quite otro sellador, que sí puede.
+      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 pend = loadRenounces().filter((r) => r.member !== publickeyJwkStr)
       pend.push(record)
@@ -1735,7 +1790,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // hasta ella: en los dos casos, mandarla es tirar cientos de KB por el transporte.
       if (!mine) return { chain: [], window: ACTA_WINDOW }
       // Puede dar el salto él solo: el sellador no cambió.
-      if (cur.sealedBy === mine.sealer) return { chain: [], window: ACTA_WINDOW }
+      // Si quien selló la última YA podía sellar en el acta que tiene el otro, el salto lo
+      // da él solo: no hace falta mandarle los eslabones. Antes esto comparaba contra el
+      // campo `sealer`; ahora se le pregunta al permiso, que es lo mismo con un solo
+      // sellador y lo correcto con varios.
+      if (Acta.canSeal(mine, cur.sealedBy)) return { chain: [], window: ACTA_WINDOW }
       const all = [...hist.filter((a) => a.seq > sinceSeq), cur]
       return { chain: all.sort((a, b) => a.seq - b.seq), window: ACTA_WINDOW }
     },