@dotrino/identity 0.105.0 → 0.107.0

package/package.json

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

package/vault/content.js

@@ -106,12 +106,68 @@ export async function myContentKey ({ keyring, myPub, myEncPrivateKey }) {
   return null
 }
 
-/** Cifra con la CEK. Devuelve un sobre `{ gen, iv, ct }` (el `gen` dice con cuál se cifró). */
+/**
+ * La marca de un sobre de la llave de la cuenta. La lleva todo sobre de `encryptWithCek`
+ * para que quien guarda datos ajenos —la bóveda con el almacén de las apps— lo RECONOZCA
+ * dentro de un JSON cualquiera sin adivinar por la forma, y pueda volver a cerrarlo con la
+ * generación vigente cuando la llave rota (`resealStale`).
+ */
+export const CEK_ENVELOPE = 'dotrino-cek'
+
+/** ¿Es un sobre de la llave de la cuenta? */
+export const isCekEnvelope = (v) => !!v && typeof v === 'object' && v.t === CEK_ENVELOPE &&
+  Number.isInteger(v.gen) && typeof v.iv === 'string' && typeof v.ct === 'string'
+
+/** Cifra con la CEK. Devuelve un sobre `{ t, gen, iv, ct }` (el `gen` dice con cuál se cifró). */
 export async function encryptWithCek ({ cek, gen, plaintext }) {
   const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['encrypt'])
   const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
   const ct = await subtle.encrypt({ name: 'AES-GCM', iv }, k, new TextEncoder().encode(plaintext))
-  return { gen, iv: b64(iv), ct: b64(ct) }
+  return { t: CEK_ENVELOPE, gen, iv: b64(iv), ct: b64(ct) }
+}
+
+/**
+ * VUELVE A CERRAR con la generación vigente todo sobre de una generación anterior que haya
+ * dentro de `value`, a cualquier profundidad. Devuelve una copia (no toca el original) y
+ * cuántos sobres cambió.
+ *
+ * Es lo que hace la bóveda al abrirse después de una rotación (dueño, 2026-09-30): lo que
+ * sirve va SIEMPRE con la llave vigente, así que un aparato que entra después —que solo
+ * recibe esa generación— abre todo, y la llave vieja deja de abrir nada porque ya no se
+ * le sirve nada cerrado con ella.
+ *
+ * `reseal(envelope)` abre y vuelve a cerrar un sobre; lo pone quien tiene las llaves. Si
+ * un sobre no se puede abrir, se PARA: no se deja a medias ni se salta en silencio.
+ *
+ * @param {any} value
+ * @param {{ gen: number, reseal: (env: object) => Promise<object> }} o
+ * @returns {Promise<{ value: any, changed: number }>}
+ */
+export async function resealStale (value, { gen, reseal }) {
+  if (!Number.isInteger(gen)) throw new Error('resealStale: the current generation is required')
+  let changed = 0
+  const walk = async (v) => {
+    if (isCekEnvelope(v)) {
+      if (v.gen === gen) return v
+      const nuevo = await reseal(v)
+      if (!isCekEnvelope(nuevo) || nuevo.gen !== gen) throw new Error(`resealStale: reseal did not return an envelope of generation ${gen}`)
+      changed++
+      return nuevo
+    }
+    if (Array.isArray(v)) {
+      const out = []
+      for (const x of v) out.push(await walk(x))
+      return out
+    }
+    if (v && typeof v === 'object') {
+      const out = {}
+      for (const [k, x] of Object.entries(v)) out[k] = await walk(x)
+      return out
+    }
+    return v
+  }
+  const out = await walk(value)
+  return { value: out, changed }
 }
 
 /**
@@ -144,5 +200,5 @@ export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPriva
 
 export default {
   makeContentKey, wrapForMember, openWrap, makeGeneration, myContentKey,
-  encryptWithCek, decryptWithCek, decryptWithKeyring
+  encryptWithCek, decryptWithCek, decryptWithKeyring, CEK_ENVELOPE, isCekEnvelope, resealStale
 }

package/vault/core.js

@@ -21,6 +21,7 @@
 import { signDelegationWith, LEGACY_CERTS_UNTIL } from './capabilities.js'
 import * as Acta from './acta.js'
 import * as Content from './content.js'
+import { syncPeers, stampOf } from './peerSync.js'
 import { assertionBody, cleanScopes, claimsAllowed, ASSERTION_DEFAULT_TTL_MS, ASSERTION_MAX_TTL_MS } from './assertion.js'
 import { pubkeyId as pubkeyIdOf, signWithDevice } from './capabilities.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin, requestApproval as remoteApproval, requestRenounce as remoteRenounce, checkMembership as remoteCheck } from './remote.js'
@@ -1450,7 +1451,10 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       const merged = { ...a }
       const aSeen = a.lastSeen || 0
       const bSeen = b.lastSeen || 0
-      const newer = bSeen > aSeen ? b : a
+      // Gana la ficha que cambió MÁS TARDE (vista o tocada: `stampOf`), también para ser o no
+      // contacto: antes bastaba con que una de las dos lo fuera, y un contacto que quitabas
+      // volvía desde el otro aparato.
+      const newer = stampOf(b) > stampOf(a) ? b : a
       if (newer === b) {
         if (b.nickname !== undefined) merged.nickname = b.nickname
         if (b.notes !== undefined) merged.notes = b.notes
@@ -1460,7 +1464,10 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       }
       merged.firstSeen = Math.min(a.firstSeen || aSeen || Date.now(), b.firstSeen || bSeen || Date.now())
       merged.lastSeen = Math.max(aSeen, bSeen)
-      merged.isContact = !!(a.isContact || b.isContact)
+      const changed2 = Math.max(Number(a.changedAt) || 0, Number(b.changedAt) || 0)
+      if (changed2) merged.changedAt = changed2
+      if (newer.isContact) merged.isContact = true; else delete merged.isContact
+      if (!merged.card && b.card) merged.card = b.card
       const aMine = a.myRating
       const bMine = b.myRating
       if (bMine && (!aMine || (bMine.issuedAt || 0) > (aMine.issuedAt || 0))) {
@@ -2085,6 +2092,8 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       const rec = p[publickey]
       if (!rec) return null
       delete rec.isContact
+      // Quitarlo es un CAMBIO: con fecha, para que no vuelva desde otro aparato (`peerSync.js`).
+      rec.changedAt = Date.now()
       p[publickey] = rec
       savePeers(p)
       return rec
@@ -3495,8 +3504,40 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       applyMerged: applyMergedFromSync,
       mergeFn: mergeForSync
     })
-    onDirty(() => { if (sync) sync.markDirty() })
   }
+  // Un cambio en el libro de contactos avisa a los dos respaldos: Drive (si está) y la bóveda.
+  onDirty(() => { if (sync) sync.markDirty(); schedulePeerSync(1500) })
+
+  // ----- el libro de contactos en la bóveda (peerSync.js) -----
+  //
+  // Solo con bóveda y con la clave de contenido; una cuenta volátil no guarda contactos en ningún
+  // sitio, tampoco en la bóveda. Sin bóveda no es un error: es el estado normal, y no se dice.
+  let peerSyncTimer = null
+  let peerSyncRunning = false
+  function schedulePeerSync (delay) {
+    if (volatilePids.has(currentPid)) return
+    clearTimeout(peerSyncTimer)
+    peerSyncTimer = setTimeout(runPeerSync, delay)
+    peerSyncTimer?.unref?.()
+  }
+  async function runPeerSync () {
+    if (peerSyncRunning) { schedulePeerSync(3000); return }
+    if (!loadVaultCert()?.cert || volatilePids.has(currentPid)) return
+    peerSyncRunning = true
+    try {
+      const { incoming } = await syncPeers({ peers: loadPeers(), call: (method, args) => handlers.vaultStore({ method, args }) })
+      if (incoming.length) {
+        const here = loadPeers()
+        const { merged, changed } = await mergePeerMaps(here, Object.fromEntries(incoming.map((r) => [r.publickey, r])))
+        // Fundido en su sitio, sin volver a marcar sucio (sería subirlo otra vez para nada).
+        if (changed) setPeersDirect(merged)
+      }
+    } catch (e) {
+      if (!['not-paired', 'no-content-key'].includes(e?.code)) console.warn(`[cc-identity] contact book ↔ vault failed (${e?.code || 'error'}): ${e?.message}`)
+    } finally { peerSyncRunning = false }
+  }
+  schedulePeerSync(4000)
+  setInterval(() => schedulePeerSync(0), 5 * 60_000)?.unref?.()
 
   // ----- gate del candado: TODO handler no exento exige perfil desbloqueado -----
   refreshLockState()

package/vault/peerSync.js

@@ -0,0 +1,81 @@
+/**
+ * EL LIBRO DE CONTACTOS EN LA BÓVEDA: los mismos contactos en todos los aparatos del perfil.
+ *
+ * Hasta aquí el libro vivía en cada aparato (el navegador, la app de identidad del teléfono) y
+ * solo viajaba por Google Drive, que es opcional y no existe en las apps nativas: el mismo perfil
+ * veía sus conversaciones en otro aparato (el historial sí se respalda) pero no a sus contactos.
+ *
+ * Ahora el libro es UN HILO más del almacén de la bóveda (`identity.peers`), con una entrada por
+ * persona `{ id, ts, peer }`: `id` sale de su llave y `ts` es la última vez que su ficha cambió
+ * (`stampOf`). Viaja cifrado con la clave de contenido del perfil, por el mismo camino que el
+ * historial (`identity.vaultStore`). Se reconcilia por índice: se sube lo que aquí es más nuevo y
+ * se trae lo que allí lo es, y lo que llega se FUNDE con lo de aquí (`mergePeer`), no lo pisa.
+ *
+ * Quitar un contacto es un cambio más (`changedAt`): gana el más reciente, así un contacto que
+ * quitaste no vuelve desde otro aparato. Lo mismo hacen `PeerBookBackup` en Android e iOS.
+ */
+
+export const PEERS_THREAD = 'identity.peers'
+
+/** Tope de una tanda de subida (cifrada, con su sobre, queda bajo el 1 MB del proxio). */
+const PUSH_BYTES = 350_000
+
+/** La última vez que la ficha cambió: la vio (`lastSeen`) o la tocaste (`changedAt`). */
+export function stampOf (rec) {
+  return Math.max(Number(rec?.lastSeen) || 0, Number(rec?.changedAt) || 0)
+}
+
+/** El id de la entrada: de su llave, estable y sin comillas (sha-256, 32 hex). */
+export async function peerIdOf (publickey) {
+  const d = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(String(publickey)))
+  return [...new Uint8Array(d)].slice(0, 16).map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+/**
+ * Reconciliar el libro con la bóveda. `peers` es el libro de aquí (`{ publickey: ficha }`),
+ * `call(method, args)` habla con el almacén de la bóveda. Devuelve las fichas que llegaron (para
+ * fundirlas aquí) y cuántas subieron.
+ */
+export async function syncPeers ({ peers, call }) {
+  const remote = new Map()
+  let cursor = null
+  do {
+    const page = await call('getThreadIndexes', { keys: [PEERS_THREAD], cursor })
+    const idx = page?.indexes?.[PEERS_THREAD]
+    for (const [id, ts] of idx?.items || []) remote.set(String(id), Number(ts) || 0)
+    cursor = page?.next ?? null
+  } while (cursor != null)
+
+  const local = new Map()
+  for (const [pk, rec] of Object.entries(peers || {})) {
+    if (!rec || typeof rec !== 'object') continue
+    local.set(await peerIdOf(pk), { pk, rec, ts: stampOf(rec) })
+  }
+
+  // SUBIR primero lo que aquí es más nuevo, en tandas.
+  const up = [...local.entries()].filter(([id, l]) => !remote.has(id) || l.ts > remote.get(id))
+  let batch = []; let bytes = 0; let pushed = 0
+  const flush = async () => {
+    if (!batch.length) return
+    await call('importThreads', { threads: { [PEERS_THREAD]: batch }, tombs: {}, mode: 'merge' })
+    pushed += batch.length; batch = []; bytes = 0
+  }
+  for (const [id, l] of up) {
+    const entry = { id, ts: l.ts, peer: { ...l.rec, publickey: l.rec.publickey || l.pk } }
+    const size = JSON.stringify(entry).length
+    if (bytes + size > PUSH_BYTES) await flush()
+    batch.push(entry); bytes += size
+  }
+  await flush()
+
+  // TRAER lo que allí es más nuevo.
+  const down = [...remote.entries()].filter(([id, ts]) => !local.has(id) || ts > local.get(id).ts).map(([id]) => id)
+  const incoming = []
+  let refs = down.length ? { [PEERS_THREAD]: down } : null
+  while (refs) {
+    const page = await call('getEntries', { refs })
+    for (const e of page?.threads?.[PEERS_THREAD] || []) if (e?.peer?.publickey) incoming.push(e.peer)
+    refs = page?.rest && Object.keys(page.rest).length ? page.rest : null
+  }
+  return { incoming, pushed }
+}

package/vault/vendor/proxy-client/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/proxy-client@0.24.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc}.js).
+Copia vendorizada de @dotrino/proxy-client@0.26.0 (dotrino-proxy-client/src/{index,client,signature,canonical,sealing,encpub,webrtc}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 sealing.js resuelve @dotrino/identity/content de forma PEREZOSA (= ../../content.js
 por el import map): solo se carga si de verdad se sella algo.

package/vault/vendor/proxy-client/client.js

@@ -153,6 +153,7 @@ export class WebSocketProxyClient {
     this._handlers = new Map()
     this._pending = new Map() // messageId -> { resolve, reject, timer }
     this._nextId = 1
+    this._tokenWatch = new Map() // messageId -> { token, sobre, peerPubkey, timer }
 
     this._rtc = this.enableWebRTC ? new WebRTCManager({
       getSelfToken: () => this.token,
@@ -453,7 +454,7 @@ export class WebSocketProxyClient {
     // Con la llave puesta a mano se respeta tal cual: quien la pasa está diciendo que ya
     // sabe de quién es (se emparejaron), y un sobre vale para todos los destinatarios.
     if (peerEncPub) {
-      this._sendByPubkeyRaw(list, await this._seal(payload, peerEncPub), opts)
+      this._sendByPubkeyRaw(list, await this._seal(payload, peerEncPub, list.length === 1 ? list[0] : undefined), opts)
       return
     }
     // Sin ella, se averigua. UNA ENVOLTURA POR DESTINATARIO: cada uno tiene su llave, así
@@ -464,7 +465,7 @@ export class WebSocketProxyClient {
     // sin forma de saber cuál mitad.
     const llaves = await Promise.all(list.map(async (pk) => [pk, await this.encPubOf(pk)]))
     for (const [pk, encPub] of llaves) {
-      this._sendByPubkeyRaw([pk], await this._seal(payload, encPub), opts)
+      this._sendByPubkeyRaw([pk], await this._seal(payload, encPub, pk), opts)
     }
   }
 
@@ -495,11 +496,55 @@ export class WebSocketProxyClient {
       }
       peerEncPub = await this.encPubOf(peerPubkey)
     }
-    const sobre = await this._seal(payload, peerEncPub)
+    if (!peerPubkey && tokens.length === 1) peerPubkey = this.pubkeyOfToken(tokens[0]) || undefined
+    const sobre = await this._seal(payload, peerEncPub, peerPubkey)
+    if (tokens.length === 1 && peerPubkey) { this._sendToTokenOrQueue(tokens[0], sobre, peerPubkey); return }
     // Por `send`, no por `_sendRaw`: así sigue prefiriendo el canal directo si lo hay.
     this.send(tokens, sobre)
   }
 
+  /**
+   * UN TOKEN MUERTO NO SE TRAGA EL MENSAJE. Un token es una conexión, y cuando la otra punta
+   * reinicia la app su token deja de existir; la app que lo tenía apuntado sigue mandando ahí
+   * y el proxio contesta `message_sent` con ese token en `failed` (solo contesta si algo
+   * falla). Antes nadie escuchaba esa respuesta: el mensaje se daba por enviado y se perdía.
+   *
+   * Si sabemos de quién es el token, el MISMO sobre —ya va sellado a esa identidad— sale por
+   * su pubkey: la cola de 24 h del proxio, que además timbra su teléfono. Y se avisa con
+   * `token_gone` para que la app deje de usar ese token. No bloquea a nadie: se manda ya y
+   * el arreglo, si hace falta, llega detrás.
+   */
+  _sendToTokenOrQueue (token, sobre, peerPubkey) {
+    if (this.requireSealed && !this._isSealed(sobre)) {
+      throw errorCon('requireSealed: refusing to send a directed message in the clear — use sendSealedTo()', 'unsealed')
+    }
+    const messageStr = JSON.stringify(sobre)
+    if (this._rtc && this._rtc.trySend(token, messageStr)) return
+    const id = `msg_${this._nextId++}`
+    const timer = setTimeout(() => this._tokenWatch.delete(id), 15000)
+    timer.unref?.()
+    this._tokenWatch.set(id, { token, sobre, peerPubkey, timer })
+    try {
+      this._sendRaw({ to: [token], message: messageStr, id })
+    } catch (e) {
+      clearTimeout(timer)
+      this._tokenWatch.delete(id)
+      throw e
+    }
+    this._upgradeDirect([token])
+  }
+
+  /** `message_sent` con fallos: lo que iba a un token que ya no existe sale por pubkey. */
+  _tokenFailed (data) {
+    const w = data.id && this._tokenWatch.get(data.id)
+    if (!w) return
+    clearTimeout(w.timer)
+    this._tokenWatch.delete(data.id)
+    if (!Array.isArray(data.failed) || !data.failed.includes(w.token)) return
+    this._emit('token_gone', w.token, w.peerPubkey)
+    try { this._sendByPubkeyRaw([w.peerPubkey], w.sobre) } catch (e) { this._emit('error', { type: 'client', error: e.message, code: e.code || null }) }
+  }
+
   // ---------- el saludo: de quién es este token ----------
 
   /**
@@ -560,9 +605,11 @@ export class WebSocketProxyClient {
   }
 
   /** Sella con lo que haya: la bóveda de la app (`sealing`) o las primitivas del pilar. */
-  async _seal (payload, peerEncPub) {
+  async _seal (payload, peerEncPub, peerPubkey) {
     if (!peerEncPub) throw errorCon('seal: missing peerEncPub', 'unsealed')
-    return this.sealing ? this.sealing.seal(payload, peerEncPub) : seal(payload, peerEncPub)
+    return this.sealing
+      ? this.sealing.seal(payload, peerEncPub, { publickey: peerPubkey })
+      : seal(payload, peerEncPub)
   }
 
   // ---------- llaves de cifrado ajenas ----------
@@ -692,7 +739,10 @@ export class WebSocketProxyClient {
         const opened = this.sealing
           ? await this.sealing.open(payload, meta)
           : await open(payload, this.myEncPrivateKey)
-        this._emit('message', from, opened, { ...meta, sealed: true })
+        // Quién selló (la llave de cifrado), si el sobre lo dice: es lo que autentica al
+        // remitente, porque solo quien tiene esa privada pudo armarlo.
+        const senderEncPub = this.sealing?.senderOf?.(payload) || null
+        this._emit('message', from, opened, { ...meta, sealed: true, ...(senderEncPub ? { senderEncPub } : {}) })
       } catch (e) {
         // Sealed to somebody else, or tampered with. Staying quiet is the point.
         this._emit('error', { type: 'undecipherable', from, error: e })
@@ -1292,8 +1342,11 @@ export class WebSocketProxyClient {
       case 'channels_list':
       case 'channel_count':
       case 'disconnect_confirmation':
-      case 'identified':
       case 'message_sent':
+        this._tokenFailed(data)
+        this._resolvePending(data, type)
+        break
+      case 'identified':
       case 'push-config':
       case 'push-subscribed':
       case 'push-unsubscribed':
@@ -1311,6 +1364,8 @@ export class WebSocketProxyClient {
         this._emit('error', {
           type: 'server',
           error: data.error,
+          // El código es el contrato; la frase es para las personas (CONVENCIONES §8.1).
+          code: data.code || null,
           id: data.id,
           messageId: data.messageId,
           limit_level: data.limit_level,
@@ -1378,7 +1433,9 @@ export class WebSocketProxyClient {
     const entry = this._pending.get(id)
     clearTimeout(entry.timer)
     this._pending.delete(id)
-    entry.reject(new Error(data.error || 'Server error'))
+    // Con su `code`: quien llama distingue los casos por él, no por la frase (que el proxio
+    // puede cambiar o traducir). Antes se perdía aquí y solo quedaba comparar el texto.
+    entry.reject(errorCon(data.error || 'Server error', data.code || null))
   }
 
   _emit (event, ...args) {

package/vault/vendor/proxy-client/sealing.js

@@ -136,11 +136,14 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
   }
 
   return {
-    async seal (msg, peerEncPub) {
+    async seal (msg, peerEncPub, { publickey } = {}) {
       if (!peerEncPub) throw errorCon('no encryption key for the other side', 'unsealed')
-      // Destinatarios como OBJETOS: `encrypt` expande cada uno a todos los aparatos de
-      // esa persona, y una llave suelta se le cae sin envolver nada.
-      const sealed = await identity.encrypt([{ encryptionPubkey: peerEncPub }], JSON.stringify(msg))
+      // Destinatarios como OBJETOS, y CON SU `publickey`: `encrypt` expande cada uno a
+      // todos los aparatos de esa persona por su tarjeta de perfil, y la tarjeta se busca
+      // por la pubkey. Sin ella el sobre solo lo abría el aparato que anunció la llave, y
+      // los demás aparatos de esa persona recibían un mensaje que «no es para mí».
+      const recipient = publickey ? { publickey, encryptionPubkey: peerEncPub } : { encryptionPubkey: peerEncPub }
+      const sealed = await identity.encrypt([recipient], JSON.stringify(msg))
       // Y SE COMPRUEBA QUE ENVOLVIÓ A ALGUIEN. `encrypt` se salta en silencio al
       // destinatario cuya llave no puede importar, y devuelve un sobre con el llavero
       // VACÍO: cifrado de verdad, y que no abre nadie. Eso no es un sobre, es un mensaje
@@ -151,6 +154,13 @@ export function identitySealing (identity, { app = 'dotrino' } = {}) {
       return { app, sealed, from: await myEncPub() }
     },
     async open (env) { return JSON.parse(await openEnvelope(env.from, env.sealed)) },
+    /**
+     * La llave de cifrado de QUIEN SELLÓ. El sobre de la bóveda es ECDH entre la llave de
+     * quien sella y la mía, así que solo lo pudo armar quien tiene la privada de `from`:
+     * es lo que dice de quién viene de verdad (el token no lo dice, y el saludo no
+     * autentica). La app la compara con la que conoce de su contacto.
+     */
+    senderOf: (env) => (typeof env?.from === 'string' ? env.from : null),
     isSealed: (m) => !!m && m.app === app && !!m.sealed,
   }
 }

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.74.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
+Copia vendorizada de @dotrino/vault@0.79.0 (dotrino-vault/lib/src/{index,enroll,protocol,passwordLogins,loginClient,b64}.js).
 NO se edita a mano: la escribe `node vendor.mjs` y la vigila test/vendor-up-to-date.test.mjs.
 index.js importa ./enroll.js y ./protocol.js (relativos, van en esta misma copia),
 @dotrino/identity/{capabilities,acta} (= ../../{capabilities,acta}.js) y

package/vault/vendor/vault/protocol.js

@@ -65,7 +65,7 @@ export const MSG = Object.freeze({
   //     empieza con el heap limpio.
   // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
   // aviso de reinicio sin autenticar ES un ataque de denegación.
-  SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, seal, acta }
   // REPARTIR LA LLAVE DE UN CAJÓN A UN MIEMBRO NUEVO. Lo hace el SERVICIO y no la
   // bóveda, porque la bóveda no puede abrir la llave sin la frase y el servicio ya la
   // tiene: re-envolverla no le añade ningún poder. Ver `docs/secretos-sellados.md` §8.11.
@@ -74,7 +74,7 @@ export const MSG = Object.freeze({
   // el ACTA que viene dentro (también firmada) y saca de ahí la llave pública del
   // destinatario. Así, ni siquiera una bóveda comprometida puede hacerle envolver la
   // llave para alguien que la maestra no haya metido en su propio cajón.
-  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, signature }
+  REWRAP: 'vault.rewrap',                     // vault → servicio: { body:{op,owner,gen,wrap,target,acta,ts}, seal }
   REWRAP_OK: 'vault.rewrap.ok',               // servicio → vault: { data:{op,owner,gen,target,wrap,ts}, signature, cert }
   // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
   // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
@@ -85,7 +85,7 @@ export const MSG = Object.freeze({
   // Aviso a TODOS los miembros de que el perfil cambió (alguien entró o salió). Es la
   // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
   // invisible para el resto de tus dispositivos.
-  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, acta } (pedidos: + seal)
   // RÉPLICAS: la principal empuja lo que hay que servir (el acta y los sobres, que van
   // firmados de antes y no se pueden falsificar) y la réplica acusa hasta qué `seq` tiene.
   REPLICA_PUSH: 'vault.replica.push',         // master → réplica: { body:{seq,acta,secrets,ts}, signature }