@dotrino/identity 0.22.1 → 0.24.0

package/vault/core.js

@@ -19,6 +19,7 @@
  */
 
 import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
+import * as Acta from './acta.js'
 import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
@@ -29,6 +30,8 @@ export const DELEGATIONS_STORAGE = 'dotrino.identity.delegations'   // caps emit
 export const REVOCATIONS_STORAGE = 'dotrino.identity.revocations'   // nonces revocados
 export const VAULT_DEVICE_STORAGE = 'dotrino.identity.vault.device' // sub-clave D de ESTE dispositivo (custodia en el iframe)
 export const VAULT_CERT_STORAGE = 'dotrino.identity.vault.cert'     // { cert, master, proxy, deviceId, pairedAt }
+export const ACTA_STORAGE = 'dotrino.identity.acta'                 // acta de perfil vigente (quién es del perfil y qué puede)
+export const RENOUNCE_STORAGE = 'dotrino.identity.renounced'        // renuncias propias aún no absorbidas por el master
 // Multi-perfil por dispositivo: lista de perfiles + el activo. Cada perfil tiene su propio
 // namespace `dotrino.identity.p.<id>.<suffix>` para TODAS las claves de arriba (keypair, me, etc.).
 export const PROFILES_STORAGE = 'dotrino.identity.profiles' // [{ id, name, pubkey }]
@@ -249,23 +252,69 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // ----- delegaciones de capacidad emitidas + revocaciones (kv-backed) -----
 
   function loadJson (key) { try { return JSON.parse(kv.getItem(key) || '{}') || {} } catch (_) { return {} } }
-  const loadDelegations = () => loadJson(DELEGATIONS_STORAGE)
+
+  // 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
+  }
   const saveDelegations = (o) => kv.setItem(DELEGATIONS_STORAGE, JSON.stringify(o))
-  const loadRevocations = () => loadJson(REVOCATIONS_STORAGE)
+
+  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
+  }
   const saveRevocations = (o) => kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
 
   // ----- emparejamiento con el vault del usuario (este dispositivo enrolado) -----
-  // Canal de eventos 'vault' (p.ej. el SAS a comparar durante el emparejamiento).
+  // Canal de eventos 'vault' (p.ej. el código a tipear durante el emparejamiento).
   const vaultListeners = new Set()
   const emitVault = (p) => { for (const fn of vaultListeners) { try { fn(p) } catch (_) {} } }
-  // Si el vault RECHAZA por cert revocado, este dispositivo perdió el acceso: limpiamos el
-  // cert local (ya no sirve) y emitimos 'revoked' → @dotrino/store borra SOLO el store de
-  // ESTE perfil (los demás perfiles quedan intactos). Cualquier otro error se propaga igual.
+
+  /**
+   * BORRADO por revocación. Solo lo dispara un `vault.revoked` FIRMADO por la maestra
+   * pineada (lo verifica `remote.js` antes de llamar aquí). Emite 'revoked' →
+   * `@dotrino/store` borra el store de ESTE perfil (los demás quedan intactos).
+   */
+  const wipeVaultLink = () => {
+    try { kv.removeItem(VAULT_CERT_STORAGE); kv.removeItem(VAULT_DEVICE_STORAGE) } catch (_) {}
+    emitVault({ phase: 'revoked' })
+  }
+
+  /**
+   * El vault RECHAZÓ una petición diciendo «revocado». Ese mensaje NO va firmado: lo
+   * puede falsificar cualquiera que conozca la pubkey de este dispositivo, así que
+   * **jamás borra nada** (sería un wipe-DoS: destruir datos ajenos con un mensaje suelto,
+   * prohibido por `dotrino-vault/docs/pairing-protocol.md §2.3`). Lo único que hacemos es
+   * DEGRADAR: avisar a la app de que la bóveda nos está rechazando, y que sea el usuario
+   * quien decida. El borrado real llega por `vault.revoked` firmado (ver `wipeVaultLink`).
+   */
   const handleVaultError = (e) => {
-    if (e && /\brevoked\b/.test(e.message || '')) {
-      try { kv.removeItem(VAULT_CERT_STORAGE); kv.removeItem(VAULT_DEVICE_STORAGE) } catch (_) {}
-      emitVault({ phase: 'revoked' })
-    }
+    if (e && /\brevoked\b/.test(e.message || '')) emitVault({ phase: 'rejected', reason: e.message })
     throw e
   }
   const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
@@ -289,6 +338,86 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     } catch (_) { return null }
   }
 
+  // ----- ACTA DE PERFIL: qué llaves son de este perfil y qué puede hacer cada una -----
+  // Diseño en `dotrino-vault/docs/acta-de-perfil.md`. Aquí solo se guarda, se lee y se
+  // sella; las reglas (sellador único, seq/prev, no dejar el perfil sin firmante) viven en
+  // `acta.js`, que es puro y está probado aparte.
+  const loadActa = () => { try { return JSON.parse(kv.getItem(ACTA_STORAGE) || 'null') } catch (_) { return null } }
+  const saveActa = (a) => kv.setItem(ACTA_STORAGE, JSON.stringify(a))
+  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
+
+  /** Sella con la llave del perfil (CryptoKey, puede ser no extractable). */
+  const seal = (acta) => Acta.sealActa({ acta, privateKey: keypair.privateKey })
+
+  /**
+   * Aplica cambios, sella y guarda. Solo funciona si este dispositivo es el master: es la
+   * regla 1 del modelo, y `applyChanges` la vuelve a comprobar por su cuenta.
+   */
+  async function sealChanges (changes) {
+    const acta = loadActa()
+    if (!acta) throw new Error('este perfil todavía no tiene acta')
+    const next = await Acta.applyChanges(acta, changes, { by: publickeyJwkStr })
+    const sealed = await seal(next)
+    saveActa(sealed)
+    emitVault({ phase: 'acta', seq: sealed.seq, sealer: sealed.sealer })
+    return sealed
+  }
+
+  /**
+   * Si el perfil todavía no tiene acta, la crea: un miembro (esta llave), que es el master,
+   * con todas las capacidades. `profileId` = la pubkey de este perfil → el perfil se llama
+   * como la identidad que el usuario ya tenía, así que no hay nada que migrar.
+   */
+  async function ensureActa (label = '') {
+    if (loadActa()) return loadActa()
+    const acta = await seal(Acta.genesisActa({
+      pub: publickeyJwkStr, encPub: encPublickeyJwkStr, label: label || me?.nickname || ''
+    }))
+    saveActa(acta)
+    return acta
+  }
+
+  /**
+   * UNIRSE a otro perfil (el de la bóveda a la que te acabas de conectar). No es adoptar
+   * una versión nueva de TU acta: es cambiar de perfil, así que solo procede si aquí no
+   * hay nada que perder — es decir, si este dispositivo es el único miembro del suyo.
+   *
+   * Si ya tienes otros dispositivos, los dos lados tienen master y hay que ELEGIR cuál
+   * manda (§2.4.3): eso es una decisión del dueño, no un efecto colateral de escanear un
+   * código, así que se devuelve el conflicto para que lo resuelva la consola.
+   */
+  async function joinProfile (candidate) {
+    const v = await Acta.verifyActa({ acta: candidate })
+    if (!v.ok) return { joined: false, reason: 'acta-invalida:' + v.reason }
+    if (!candidate.members.some((m) => m.pub === publickeyJwkStr)) {
+      return { joined: false, reason: 'no-soy-miembro' }
+    }
+    const current = loadActa()
+    if (current && current.profileId !== candidate.profileId && current.members.length > 1) {
+      return { joined: false, reason: 'ya-tienes-perfil-propio', members: current.members.length }
+    }
+    saveActa(candidate)
+    emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, joined: true })
+    return { joined: true, profileId: candidate.profileId, seq: candidate.seq }
+  }
+
+  /**
+   * Adopta un acta que llega de otro miembro, si gana según §2.4.1 (seq mayor que encadene,
+   * o el traspaso a igual seq). Nunca retrocede.
+   */
+  async function adoptActa (candidate) {
+    const current = loadActa()
+    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 })
+    return { adopted: true, reason: r.reason, seq: candidate.seq }
+  }
+
   // ----- renovación AUTOMÁTICA del cert (sin QR ni aprobación) -----
   // Con el cert aún vigente y quedando <15 días, cualquier uso del vault dispara en
   // segundo plano un `vault.renew`: el vault firma un cert fresco (30 días) para la
@@ -305,7 +434,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (v.cert.exp <= now || v.cert.exp - now > RENEW_WINDOW_MS) return
       if (now - renewLastTry < RENEW_RETRY_MS) return
       renewLastTry = now
-      remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert }).then(({ cert }) => {
+      remoteRenew({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink }).then(({ cert }) => {
         kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ ...v, cert, renewedAt: Date.now() }))
         emitVault({ phase: 'renewed', exp: cert.exp })
       }).catch(() => {}) // best-effort: el cert vigente sigue sirviendo mientras tanto
@@ -548,7 +677,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   // nada que lea datos o firme).
   const LOCK_EXEMPT = new Set([
     'profileLockStatus', 'unlockProfile', 'listProfiles', 'currentProfile',
-    'switchProfile', 'createProfile'
+    'switchProfile', 'createProfile',
+    'profileActa', 'profileMembers', 'myMembership', 'isMaster'
   ])
 
   const handlers = {
@@ -735,11 +865,33 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return rec
     },
 
+    /**
+     * Firma. Con `sign` en el acta, firma aquí mismo (como siempre). Si este dispositivo
+     * RENUNCIÓ a firmar —o el master se lo quitó— la petición se re-enruta a quien sí
+     * firma (tu bóveda) y vuelve su firma: la identidad de cara a los demás sigue siendo
+     * UNA, y este aparato deja de poder firmar por ti aunque lo roben.
+     *
+     * El `identify` del transporte es la excepción y SIEMPRE se firma en local: es lo que
+     * identifica esta conexión ante el proxy, no una firma tuya de cara a nadie, y sin él
+     * el dispositivo no podría ni hablar con la bóveda para pedirle que firme.
+     */
     async signData ({ data }) {
       if (data == null) throw new Error('data required')
-      const bytes = new TextEncoder().encode(canonicalStringify(data))
-      const signature = await signBytes(keypair.privateKey, bytes)
-      return { signature, publickey: publickeyJwkStr }
+      const local = async () => {
+        const bytes = new TextEncoder().encode(canonicalStringify(data))
+        return { signature: await signBytes(keypair.privateKey, bytes), publickey: publickeyJwkStr }
+      }
+      const acta = loadActa()
+      const puedeFirmar = !acta || Acta.memberCan(acta, publickeyJwkStr, 'sign', loadRenounces())
+      if (puedeFirmar || data?.op === 'identify') return local()
+
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) {
+        throw new Error('perfil-sin-firmante: este dispositivo ya no firma por ti y no está conectado a ninguna bóveda que pueda hacerlo')
+      }
+      maybeRenewVaultCert()
+      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload: data, onRevoked: wipeVaultLink }) }
+      catch (e) { return handleVaultError(e) }
     },
 
     // ----- delegación de capacidad: la maestra firma un cert para una sub-clave -----
@@ -799,6 +951,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr, nickname: String(name || '').slice(0, 40) }
       saveMe(me)
       const list = loadProfiles(); list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr }); saveProfiles(list)
+      await ensureActa(me.nickname) // el perfil nuevo nace con su acta (él mismo es el master)
       return { id: pid, name: me.nickname, pubkey: publickeyJwkStr }
     },
     async switchProfile ({ id } = {}) {
@@ -819,7 +972,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (!list.find((p) => p.id === id)) throw new Error('perfil no existe')
       list = list.filter((p) => p.id !== id); saveProfiles(list)
       // Borrado directo del namespace del perfil (incluye su store del vault si lo tuviera).
-      for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations', 'vault.device', 'vault.cert']) {
+      for (const s of ['keypair', 'enc-keypair', 'me', 'nonces', 'delegations', 'revocations', 'vault.device', 'vault.cert', 'acta', 'renounced']) {
         rawKv.removeItem(`dotrino.identity.p.${id}.${s}`)
       }
       // …y sus CryptoKeys no extractables del keyStore (IndexedDB).
@@ -832,6 +985,108 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       return { ok: true, current: currentPid }
     },
 
+    // ----- ACTA DE PERFIL -----
+    // Quién es de este perfil y qué puede hacer cada uno. Solo el master sella; los demás
+    // adoptan. Ver `dotrino-vault/docs/acta-de-perfil.md`.
+
+    async profileActa () {
+      const acta = loadActa()
+      if (!acta) return null
+      return { acta, isMaster: amMaster(), myCaps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()) }
+    },
+
+    async profileMembers () {
+      const acta = loadActa()
+      if (!acta) return { members: [], profileId: null, seq: 0, sealer: null }
+      const pend = loadRenounces()
+      const members = await Promise.all(acta.members.map(async (m) => ({
+        pub: m.pub,
+        id: await Acta.memberId(m.pub),
+        label: m.label || '',
+        caps: Acta.effectiveCaps(acta, m.pub, pend),
+        addedAt: m.addedAt || null,
+        isMe: m.pub === publickeyJwkStr,
+        isMaster: m.pub === acta.sealer
+      })))
+      return { members, profileId: acta.profileId, seq: acta.seq, sealer: acta.sealer, updatedAt: acta.updatedAt }
+    },
+
+    async myMembership () {
+      const acta = loadActa()
+      if (!acta) return { inProfile: false }
+      const m = acta.members.find((x) => x.pub === publickeyJwkStr)
+      return {
+        inProfile: !!m,
+        profileId: acta.profileId,
+        seq: acta.seq,
+        isMaster: acta.sealer === publickeyJwkStr,
+        caps: Acta.effectiveCaps(acta, publickeyJwkStr, loadRenounces()),
+        id: m ? await Acta.memberId(m.pub) : null
+      }
+    },
+
+    async isMaster () { return amMaster() },
+
+    /** Admite un miembro (solo el master). El cert lo emite quien llama, antes o después. */
+    async admitMember ({ pub, encPub = null, label = '', caps = ['store', 'read'], cert = null } = {}) {
+      const acta = await sealChanges([{ op: 'admit', member: { pub, encPub, label, caps, cert } }])
+      return { ok: true, seq: acta.seq }
+    },
+
+    async setCaps ({ pub, caps } = {}) {
+      const acta = await sealChanges([{ op: 'caps', pub, caps }])
+      return { ok: true, seq: acta.seq }
+    },
+
+    async removeMember ({ pub } = {}) {
+      const acta = await sealChanges([{ op: 'remove', pub }])
+      return { ok: true, seq: acta.seq }
+    },
+
+    /**
+     * Traspasa el master a otro miembro. Admitir y nombrar van en el MISMO seq: el nuevo
+     * 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).
+     */
+    async handoverMaster ({ to, member = null } = {}) {
+      const changes = []
+      if (member) changes.push({ op: 'admit', member: { ...member, pub: to } })
+      changes.push({ op: 'handover', to })
+      const acta = await sealChanges(changes)
+      return { ok: true, seq: acta.seq, sealer: acta.sealer }
+    },
+
+    /**
+     * RENUNCIA (§2.2): este dispositivo se quita capacidades a sí mismo. No pasa por el
+     * master —por eso funciona con la bóveda apagada, que es justo cuando hace falta (te
+     * robaron el aparato)— y solo puede QUITAR, así que cualquiera puede honrarla.
+     */
+    async renounceCaps ({ caps } = {}) {
+      const acta = loadActa()
+      if (!acta) throw new Error('este perfil todavía no tiene acta')
+      const record = await Acta.makeRenounce({ member: publickeyJwkStr, caps, privateKey: keypair.privateKey })
+      const pend = loadRenounces().filter((r) => r.member !== publickeyJwkStr)
+      pend.push(record)
+      saveRenounces(pend)
+      emitVault({ phase: 'renounced', caps: record.caps })
+      // Si además soy el master, la absorbo ya en el acta.
+      if (amMaster()) { try { await sealChanges([{ op: 'renounce', record }]) } catch (_) {} }
+      return { ok: true, record, caps: Acta.effectiveCaps(loadActa(), publickeyJwkStr, loadRenounces()) }
+    },
+
+    /** Absorbe en el acta una renuncia ajena ya verificada (solo el master). */
+    async absorbRenounce ({ record } = {}) {
+      if (!(await Acta.verifyRenounce(record))) throw new Error('renuncia inválida: la firma no es del propio miembro')
+      const acta = await sealChanges([{ op: 'renounce', record }])
+      return { ok: true, seq: acta.seq }
+    },
+
+    /** Adopta un acta que llega de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
+    async adoptActa ({ acta } = {}) { return adoptActa(acta) },
+
+    /** Une este dispositivo al perfil de otra bóveda (solo si aquí no hay nada que perder). */
+    async joinProfile ({ acta } = {}) { return joinProfile(acta) },
+
     // ----- emparejar ESTE dispositivo con el vault del usuario (Fase 1) -----
     // Genera D aquí dentro (su privada NUNCA sale de la identidad), hace el enroll
     // endurecido por el proxy y guarda el cert. NO cambia signData todavía (Fase 2).
@@ -844,9 +1099,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const res = await remoteEnroll({ qr, device, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
       kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
       kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
-      emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master })
+      // Conectarse a una bóveda es ENTRAR A SU PERFIL: el acta viene con el cert.
+      const join = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
+      emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join })
       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 }
+      return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join }
     },
 
     async vaultStatus () {
@@ -870,7 +1127,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload }) }
+      try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
     },
 
@@ -880,7 +1137,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args }) }
+      try { return await remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
     },
 
@@ -889,8 +1146,12 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const v = loadVaultCert(); const device = loadVaultDevice()
       if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
       maybeRenewVaultCert()
-      try { return await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert }) }
-      catch (e) { return handleVaultError(e) }
+      try {
+        const res = await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, onRevoked: wipeVaultLink })
+        // El acta viaja con la lista: así los cambios de política llegan sin canal aparte.
+        if (res.acta) { try { await (res.acta.profileId === loadActa()?.profileId ? adoptActa(res.acta) : joinProfile(res.acta)) } catch (_) {} }
+        return res
+      } catch (e) { return handleVaultError(e) }
     },
 
     // El cert de delegación de este dispositivo (para presentarlo al proxy en `identify`
@@ -1082,6 +1343,9 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     me = { publickey: publickeyJwkStr, encryptionPubkey: encPublickeyJwkStr }
     kv.setItem(ME_STORAGE, JSON.stringify(me))
   }
+  // Acta de perfil: si no existe, nace ahora (un miembro, este dispositivo, que es el master).
+  try { await ensureActa() } catch (e) { console.warn('[identity] no se pudo crear el acta de perfil:', e.message) }
+
   // Perfil compartido: jalar del vault en background (gana el más nuevo).
   pullProfileFromVault()
 

package/vault/remote.js

@@ -5,22 +5,49 @@
  * —cuya privada NUNCA sale de la identidad—, hace el emparejamiento ENDURECIDO por el
  * proxy (ver dotrino-vault/docs/pairing-protocol.md) y devuelve el cert ya validado.
  *
- * Flujo: firma el ENROLL con D (prueba de posesión) → recibe el reto y computa SU
- * propio SAS (que el usuario compara con el del PC) → al ser aprobado en el PC, recibe
- * el cert y lo valida (firmado por la maestra que vio en el QR, y para SU clave).
+ * Flujo: genera un código de 6 dígitos, lo MUESTRA y manda solo su COMPROMISO dentro del
+ * ENROLL firmado con D (prueba de posesión) → el dueño tipea el código en la bóveda, que
+ * lo comprueba contra el compromiso y solo entonces firma → el dispositivo acepta el cert
+ * si le ECHAN su código y lo valida (firmado por la maestra que vio en el QR, y para SU clave).
  *
  * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
  * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, makePairingCode, pubkeyId } from './capabilities.js'
+import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from './capabilities.js'
 
 const MSG = {
   ENROLL: 'vault.enroll',
   ENROLL_CHALLENGE: 'vault.enroll.challenge',
   ENROLLED: 'vault.enrolled',
+  REVOKED: 'vault.revoked',
   ERROR: 'vault.error'
 }
 
+/**
+ * ¿Es AUTÉNTICO este `vault.revoked`? Solo lo es si va firmado por la maestra PINEADA al
+ * emparejar, es para ESTE dispositivo y no ha caducado. Es la única puerta al autoborrado:
+ * un `vault.error` con la palabra «revocado» no borra nada (cierra el wipe-DoS, ver
+ * `dotrino-vault/docs/pairing-protocol.md §2.3`).
+ */
+export async function isAuthenticRevoke ({ body, signature, master, devicePubkey }) {
+  if (!body || body.op !== 'revoke' || typeof signature !== 'string') return false
+  if (body.sub !== devicePubkey) return false
+  if (typeof body.exp === 'number' && Date.now() > body.exp) return false
+  return verifyDeviceSig({ publickey: master, data: body, signature })
+}
+
+/**
+ * Identifica la conexión bajo la pubkey de este dispositivo. Además de hacerlo
+ * direccionable, es lo que hace que el proxy le entregue lo que tenía ENCOLADO (24 h) —
+ * entre otras cosas, un `vault.revoked` emitido mientras estaba apagado.
+ */
+async function identifyAsDevice (client, device) {
+  if (!client.token) return
+  const data = { op: 'identify', publickey: device.publickey, token: client.token, ts: Date.now() }
+  const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
+  await client.identify({ data, signature })
+}
+
 /**
  * @param {Object} opts
  * @param {{v:number, iss:string, proxy:string, token:string, sn:string}} opts.qr  QR v2 del vault.
@@ -43,9 +70,12 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     // El DISPOSITIVO genera el código y manda solo su COMPROMISO (no el código). El vault
     // aprende el código únicamente cuando vos lo tipeás en el PC → aprobar exige tener el dispositivo.
     const code = makePairingCode()
-    // NO se manda el código ni un compromiso: el vault lo aprende SOLO cuando lo tipeás, y al
-    // ECHARLO de vuelta el dispositivo confía. Un vault falso no conoce el código → no empareja.
-    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
+    // Se manda el COMPROMISO del código, nunca el código. El vault lo aprende solo cuando lo
+    // tipeas, recompone el compromiso y únicamente entonces firma el cert → aprobar exige
+    // haber leído el código de ESTA pantalla. Y al ECHARLO de vuelta, el dispositivo confía:
+    // una bóveda falsa no conoce el código y no puede enrolarlo.
+    const commit = await commitCode({ code, dpub: dev.publickey, sn: qr.sn })
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -68,7 +98,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     if (!v.ok) throw new Error('cert inválido: ' + v.reason)
     if (res.cert.iss !== qr.iss) throw new Error('cert firmado por una maestra distinta a la que viste')
     if (res.cert.sub !== dev.publickey) throw new Error('cert emitido para otro dispositivo')
-    return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId }
+    return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta || null }
   } finally { try { client.close() } catch (_) {} }
 }
 
@@ -78,41 +108,39 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
  * firma. Requiere que el vault esté online.
  * @returns {Promise<{ signature:string, publickey:string }>}  publickey = la maestra.
  */
-export async function requestSign ({ master, proxy, device, cert, payload, timeoutMs = 15000 } = {}) {
-  if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
-  await client.connect()
-  try {
-    const data = { op: 'sign', payload, publickey: device.publickey, ts: Date.now() }
-    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data })
-    const pending = new Promise((resolve, reject) => {
-      const off = client.on('message', (_f, p) => {
-        if (!p || typeof p !== 'object') return
-        if (p.type === 'vault.signed') { cleanup(); resolve(p) }
-        else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
-      })
-      const t = setTimeout(() => { cleanup(); reject(new Error('el vault no respondió (¿está encendido?)')) }, timeoutMs)
-      const cleanup = () => { off(); clearTimeout(t) }
-    })
-    client.sendByPubkey(master, { type: 'vault.sign', data, signature, cert })
-    const res = await pending
-    return { signature: res.signature, publickey: res.publickey }
-  } finally { try { client.close() } catch (_) {} }
+export async function requestSign ({ master, proxy, device, cert, payload, onRevoked, timeoutMs = 15000 } = {}) {
+  const res = await vaultRpc({
+    master, proxy, device, cert, onRevoked, timeoutMs,
+    sendType: 'vault.sign', okType: 'vault.signed', data: { op: 'sign', payload }
+  })
+  return { signature: res.signature, publickey: res.publickey }
 }
 
-/** Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`. */
-async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, timeoutMs = 15000 }) {
+/**
+ * Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`.
+ *
+ * Se identifica al conectar para que el proxy entregue lo ENCOLADO: si mientras el
+ * dispositivo estaba apagado la bóveda emitió un `vault.revoked` firmado, llega aquí y se
+ * ejecuta el autoborrado (`onRevoked`) tras verificar la firma contra la maestra pineada.
+ */
+async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, onRevoked, timeoutMs = 15000 }) {
   if (!master || !proxy || !(device?.privateJwk || device?.privateKey) || !cert) throw new Error('faltan datos de emparejamiento')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
   await client.connect()
   try {
+    try { await identifyAsDevice(client, device) } catch (_) { /* sin identify seguimos: solo perdemos la cola */ }
     const signed = { ...data, publickey: device.publickey, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, privateKey: device.privateKey, publickey: device.publickey, data: signed })
     const pending = new Promise((resolve, reject) => {
       const off = client.on('message', (_f, p) => {
         if (!p || typeof p !== 'object') return
+        if (p.type === MSG.REVOKED) {
+          isAuthenticRevoke({ body: p.body, signature: p.signature, master, devicePubkey: device.publickey })
+            .then((ok) => { if (ok) { try { onRevoked?.() } catch (_) {} } })
+            .catch(() => {})
+          return
+        }
         if (p.type === okType) { cleanup(); resolve(p) }
         else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
       })
@@ -125,15 +153,15 @@ async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data,
 }
 
 /** Lee/escribe el store de hilos+aperturas EN el vault (con el cert del dispositivo). */
-export async function requestStore ({ master, proxy, device, cert, method, args } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.store', okType: 'vault.store.result', data: { op: 'store', method, args: args || {} } })
+export async function requestStore ({ master, proxy, device, cert, method, args, onRevoked } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.store', okType: 'vault.store.result', data: { op: 'store', method, args: args || {} } })
   return res.result
 }
 
 /** Lista (solo lectura) los dispositivos enrolados en tu vault. */
-export async function requestDevices ({ master, proxy, device, cert } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
-  return { devices: res.devices || [], revoked: res.revoked || [] }
+export async function requestDevices ({ master, proxy, device, cert, onRevoked } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
+  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null }
 }
 
 /**
@@ -141,8 +169,8 @@ export async function requestDevices ({ master, proxy, device, cert } = {}) {
  * el vault firma uno fresco para la misma sub-clave y scope, sin QR ni aprobación.
  * @returns {Promise<{ cert: object }>}
  */
-export async function requestRenew ({ master, proxy, device, cert } = {}) {
-  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
+export async function requestRenew ({ master, proxy, device, cert, onRevoked } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, onRevoked, sendType: 'vault.renew', okType: 'vault.renewed', data: { op: 'renew' } })
   if (!res.cert || res.cert.sub !== device.publickey || res.cert.iss !== master) throw new Error('cert renovado inválido')
   return { cert: res.cert }
 }

package/vault/vault.js

@@ -110,12 +110,16 @@ import { pubkeyId } from './capabilities.js'
 
   // Adaptador: startDeviceVault exige identity.{me.publickey, signData, signDelegation,
   // listDelegations, revokeDelegation}; el core los expone vía handlers + getter me.
+  // `admitMember`/`profileActa` son opcionales para el mostrador de enrolamiento, pero sin
+  // ellos aprobar emitiría el cert SIN meter al dispositivo en el acta: se pasan también.
   const selfIdentity = {
     get me () { return core.me },
     signData: (data) => handlers.signData({ data }),
     signDelegation: (sub, scope, opts) => handlers.signDelegation({ sub, scope, ...(opts || {}) }),
     listDelegations: () => handlers.listDelegations({}),
-    revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce })
+    revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
+    admitMember: (m) => handlers.admitMember(m),
+    profileActa: () => handlers.profileActa({})
   }
 
   async function startSelfDaemon () {

package/vault/vendor/vault/VERSION.txt

@@ -1,5 +1,6 @@
-Copia vendorizada de @dotrino/vault@0.3.0 (lib/src/index.js, sin dependencias).
-El iframe de identity se sirve estático (vanilla, sin build); así startDeviceVault
-resuelve en el navegador sin bundler. Importa @dotrino/identity/capabilities
-(=../../capabilities.js) y @dotrino/proxy-client (=../proxy-client/), ambos vía
-el import map de index.html. Re-vendorizar al subir @dotrino/vault.
+Copia vendorizada de @dotrino/vault@0.5.0 (lib/src/{index,enroll}.js, sin dependencias).
+El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
+resuelve en el navegador sin bundler. index.js importa ./enroll.js (relativo, se
+vendoriza tambien) y @dotrino/identity/capabilities (=../../capabilities.js) y
+@dotrino/proxy-client (=../proxy-client/), ambos via el import map de index.html.
+Re-vendorizar AMBOS archivos al subir @dotrino/vault.