@dotrino/identity 0.104.2 → 0.106.0

package/package.json

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

package/src/index.js

@@ -348,6 +348,8 @@ export class Identity {
 
   /** Cambia las capacidades de un miembro (solo el master). */
   async setCaps (pub, caps) { return this._call('setCaps', { pub, caps }) }
+  /** Cambia las capacidades de VARIOS miembros en una sola acta: `[{ pub, caps }]`. */
+  async setCapsMany (changes) { return this._call('setCapsMany', { changes }) }
   async setLabel (pub, label) { return this._call('setLabel', { pub, label }) }
 
   /** Expulsa a un miembro (solo el master; al master no se le puede expulsar). */

package/src/node.js

@@ -228,6 +228,7 @@ export class Identity {
   /** Registra la llave de cifrado de un miembro ya admitido (evita re-enrolarlo). */
   setMemberEncPub (args) { return this._h('setMemberEncPub', args) }
   setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
+  setCapsMany (changes) { return this._h('setCapsMany', { changes }) }
   setLabel (pub, label) { return this._h('setLabel', { pub, label }) }
   removeMember (pub) { return this._h('removeMember', { pub }) }
   handoverMaster (to, member = null) { return this._h('handoverMaster', { to, member }) }

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'
@@ -973,19 +974,6 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
     keyring: loadActa()?.keyring, myPub: publickeyJwkStr, myEncPrivateKey: encKeypair.privateKey
   })
 
-  /** Envuelve la clave vigente para un miembro recién admitido (no hace falta rotar). */
-  async function wrapForNewMember (pub) {
-    const acta = loadActa()
-    const gen = (acta?.keyring || []).at(-1)
-    const m = acta?.members.find((x) => x.pub === pub)
-    if (!gen || !m?.encPub) return false
-    const mine = await myCek()
-    if (!mine) return false
-    const wrap = await Content.wrapForMember({ cek: mine.cek, memberEncPub: m.encPub })
-    await sealChanges([{ op: 'wrap', gen: mine.gen, pub, wrap }])
-    return true
-  }
-
   /**
    * QUITAR UN APARATO, entero y de una vez.
    *
@@ -1463,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
@@ -1473,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))) {
@@ -2098,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
@@ -2571,12 +2567,21 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       // `cn`: si viene, este miembro es un SERVICIO y su único permiso es abrir el cajón de
       // secretos de ESE nombre — no ve nada más del usuario. Sin `cn` es un dispositivo.
       const finales = caps || (cn ? ['secrets'] : ['store', 'read'])
-      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }])
       // Que entre al perfil incluye poder LEER lo que ya hay: se le envuelve la clave
       // vigente (no hace falta rotar; rotar es para cuando alguien SALE).
-      let wrapped = false
-      try { wrapped = await wrapForNewMember(pub) } catch (_) {}
-      return { ok: true, seq: acta.seq, wrapped }
+      //
+      // EN LA MISMA ACTA que la admisión (dueño, 2026-09-26: nada de actas inútiles). Antes
+      // se sellaba una para admitir y otra para envolver, y cada acta es un aviso a todos
+      // los aparatos. La envoltura solo necesita la llave de cifrado del que entra, que ya
+      // viene aquí. Si no se puede envolver (sin clave propia, sin `encPub`), entra igual y
+      // `wrapped` lo dice — lo mismo que antes.
+      let wrap = null
+      try {
+        const mine = encPub ? await myCek() : null
+        if (mine) wrap = { op: 'wrap', gen: mine.gen, pub, wrap: await Content.wrapForMember({ cek: mine.cek, memberEncPub: encPub }) }
+      } catch (_) { wrap = null }
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, cn, caps: finales, cert, continuity } }, ...(wrap ? [wrap] : [])])
+      return { ok: true, seq: acta.seq, wrapped: !!wrap }
     },
 
     async setCaps ({ pub, caps } = {}) {
@@ -2584,6 +2589,18 @@ export async function createIdentityCore ({ kv: hostKv, peers, makeSync = null,
       return { ok: true, seq: acta.seq }
     },
 
+    /**
+     * LOS PERMISOS DE VARIOS APARATOS EN UNA SOLA ACTA (dueño, 2026-09-26). Editar tres
+     * aparatos eran tres actas y tres avisos; ahora el borrador entero se sella de golpe.
+     * `changes`: `[{ pub, caps }]`, cada `caps` la lista COMPLETA de ese aparato.
+     * @param {{ changes?: Array<{ pub: string, caps: string[] }> }} [args]
+     */
+    async setCapsMany ({ changes } = {}) {
+      if (!Array.isArray(changes) || !changes.length) throw new Error('setCapsMany: no changes')
+      const acta = await sealChanges(changes.map(({ pub, caps }) => ({ op: 'caps', pub, caps })))
+      return { ok: true, seq: acta.seq }
+    },
+
     /**
      * RENOMBRA un miembro (el nombre con el que lo reconoces). Se escribe en el acta y
      * TAMBIÉN en la delegación: son dos registros distintos —el acta dice quién es del
@@ -3487,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.73.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/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal, DEVICE_CAPS } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -159,8 +159,24 @@ export function createEnrollDesk ({
    *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
    *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
    *                       identidad de verdad de la cuenta es `iss`.
+   *   · `caps`          → LOS PERMISOS con los que entra al acta, elegidos por quien
+   *                       empareja (dueño, 2026-09-26: «al emparejar debería escoger los
+   *                       permisos, caso contrario estoy obligado a hacer dos actas»). Sin
+   *                       esto el aparato entraba con lo que da el scope y cualquier otro
+   *                       permiso —`admin`, `approve`…— costaba una segunda acta. Se quedan
+   *                       AQUÍ, en la sesión de la bóveda: NO viajan en el QR, así que la
+   *                       invitación que circula no concede nada; lo concede quien teclea
+   *                       el código, igual que hacía `caps` después.
    */
-  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '', caps = null } = {}) {
+    if (caps != null) {
+      if (!Array.isArray(caps)) throw Object.assign(new Error('caps must be a list'), { code: 'bad-caps' })
+      const cn = scopeToCn(scope)
+      const bad = caps.filter((c) => !(DEVICE_CAPS.includes(c) || (c === 'secrets' && cn)))
+      if (bad.length) throw Object.assign(new Error('unknown permission(s): ' + bad.join(', ')), { code: 'bad-caps' })
+      if (!caps.length) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
+      caps = [...new Set(caps)]
+    }
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
     const acct = String(account || '').slice(0, 40)
     // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
@@ -176,12 +192,12 @@ export function createEnrollDesk ({
     const conn = typeof connToken === 'function' ? await connToken() : connToken
     if (conn) {
       const sn = randToken(8)
-      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
       return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
     }
     const token = randToken(PAIR_TOKEN_BYTES)
     const sn = randToken(PAIR_TOKEN_BYTES)
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
@@ -364,8 +380,10 @@ export function createEnrollDesk ({
     // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
     // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
     // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    // Si quien emparejó ELIGIÓ los permisos (`startPairing({ caps })`), entran esos y en
+    // esta misma acta; si no, los que da el scope.
     const cn = scopeToCn(pend.scope)
-    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    const caps = [...new Set([...(pend.caps || scopeToCaps(pend.scope)), ...(cn ? ['secrets'] : [])])]
     if (!caps.length) {
       throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
     }

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 }