@dotrino/identity 0.23.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.23.0",
+  "version": "0.25.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -21,7 +21,10 @@
       "import": "./vault/avatar.js"
     },
     "./vault/core.js": "./vault/core.js",
-    "./vault/remote.js": "./vault/remote.js"
+    "./vault/remote.js": "./vault/remote.js",
+    "./acta": {
+      "import": "./vault/acta.js"
+    }
   },
   "files": [
     "src",

package/src/index.js

@@ -256,6 +256,50 @@ export class Identity {
     return this._call('listDelegations')
   }
 
+  // ----- Acta de perfil: qué llaves son tuyas y qué puede hacer cada una -----
+  // Un perfil es un conjunto de llaves ligadas por certificados, con una política firmada
+  // por UN solo sellador (el «master»). Ninguna llave privada viaja nunca.
+  // Diseño: dotrino-vault/docs/acta-de-perfil.md
+
+  /** El acta vigente + si este dispositivo es el master + sus capacidades efectivas. */
+  async profileActa () { return this._call('profileActa') }
+
+  /** Miembros del perfil, ya con id legible y capacidades efectivas. */
+  async profileMembers () { return this._call('profileMembers') }
+
+  /** Dónde estoy yo: { inProfile, profileId, seq, isMaster, caps, id }. */
+  async myMembership () { return this._call('myMembership') }
+
+  /** ¿Es ESTE dispositivo el master (el único que puede cambiar el acta)? */
+  async isMaster () { return this._call('isMaster') }
+
+  /** Admite un miembro nuevo (solo el master). */
+  async admitMember (member) { return this._call('admitMember', member) }
+
+  /** Cambia las capacidades de un miembro (solo el master). */
+  async setCaps (pub, caps) { return this._call('setCaps', { pub, caps }) }
+
+  /** Expulsa a un miembro (solo el master; al master no se le puede expulsar). */
+  async removeMember (pub) { return this._call('removeMember', { pub }) }
+
+  /**
+   * Traspasa el master a otro miembro — dispositivo → bóveda, o bóveda → bóveda al mudarse
+   * de PC. Si `member` viene, se admite y se nombra en el MISMO seq (sin ventana intermedia).
+   */
+  async handoverMaster (to, member = null) { return this._call('handoverMaster', { to, member }) }
+
+  /**
+   * Este dispositivo se quita capacidades a sí mismo (p. ej. dejar de firmar). Es
+   * unilateral y funciona con la bóveda apagada, que es justo cuando hace falta.
+   */
+  async renounceCaps (caps) { return this._call('renounceCaps', { caps }) }
+
+  /** Absorbe en el acta una renuncia de otro miembro (solo el master). */
+  async absorbRenounce (record) { return this._call('absorbRenounce', { record }) }
+
+  /** Adopta un acta recibida de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
+  async adoptActa (acta) { return this._call('adoptActa', { acta }) }
+
   // ----- Emparejar ESTE navegador/dispositivo con el vault del usuario (Fase 1) -----
 
   /**

package/src/node.js

@@ -150,6 +150,18 @@ export class Identity {
   signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
   revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }
   listDelegations () { return this._h('listDelegations') }
+  // Acta de perfil (qué llaves son del perfil y qué puede cada una; ver acta-de-perfil.md)
+  profileActa () { return this._h('profileActa') }
+  profileMembers () { return this._h('profileMembers') }
+  myMembership () { return this._h('myMembership') }
+  isMaster () { return this._h('isMaster') }
+  admitMember (member) { return this._h('admitMember', member) }
+  setCaps (pub, caps) { return this._h('setCaps', { pub, caps }) }
+  removeMember (pub) { return this._h('removeMember', { pub }) }
+  handoverMaster (to, member = null) { return this._h('handoverMaster', { to, member }) }
+  renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
+  absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
+  adoptActa (acta) { return this._h('adoptActa', { acta }) }
   // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
   enrollDevice (qr) { return this._h('vaultPair', { qr }) }
   vaultStatus () { return this._h('vaultStatus') }

package/vault/acta.js

@@ -0,0 +1,342 @@
+/**
+ * acta.js — el ACTA DE PERFIL: qué llaves son del mismo perfil y qué puede hacer cada una.
+ *
+ * Un perfil no es una llave: es un CONJUNTO de llaves miembro, ligadas por certificados,
+ * más una política firmada. Ninguna llave privada viaja nunca; lo que se mueve es el acta.
+ * Diseño completo y decisiones en `dotrino-vault/docs/acta-de-perfil.md`.
+ *
+ * Las cuatro reglas que este módulo hace cumplir:
+ *   1. **Un solo sellador** (el «master»). Solo el sellador vigente puede producir la
+ *      siguiente acta. Como las llaves son intransferibles no se puede clonar → dos actas
+ *      legítimas con el mismo `seq` son imposibles: no hay bifurcaciones que resolver.
+ *   2. **`seq` monotónico + `prev`** (hash del acta anterior): cadena verificable.
+ *   3. **Nunca dejar el perfil sin quien firme**: un cambio que quite el último `sign` se
+ *      rechaza.
+ *   4. **Renunciar es aparte**: un miembro se quita capacidades a sí mismo con un registro
+ *      suelto que solo QUITA (§2.2). No toca el acta ni el `seq`, así que funciona con la
+ *      bóveda apagada; el master lo absorbe después.
+ *
+ * DOS CAMPOS, NO UNO: `sealedBy` es la llave que FIRMÓ esta acta y `sealer` es quien queda
+ * como master de aquí en adelante. Normalmente coinciden; en un TRASPASO no, porque el acta
+ * que nombra al nuevo master la firma el saliente. Esa distinción es la que hace el traspaso
+ * auto-verificable: la firma del saliente es la prueba de su propia degradación.
+ *
+ * Los tiempos son epoch en ms (UTC) e INFORMATIVOS: la precedencia va por `seq` y por la
+ * regla de traspaso (§2.4.1), nunca por reloj — si dependiera de la hora, un master mintiendo
+ * reescribiría el orden cambiando el reloj de su máquina.
+ *
+ * Módulo PURO: sin kv, sin red, sin disco. Cripto de `./capabilities.js`.
+ */
+import { canonicalStringify } from './core.js'
+import { signWithDevice, verifyDeviceSig, pubkeyId } from './capabilities.js'
+
+export const ACTA_V = 1
+
+/** Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master. */
+export const CAPS = Object.freeze(['sign', 'store', 'read'])
+
+/** Cada capacidad es uno de los scopes que ya existen en los certs (sin scopes nuevos). */
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read' })
+
+const enc = (s) => new TextEncoder().encode(s)
+const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
+const isPub = (v) => typeof v === 'string' && v.length > 0
+const cleanCaps = (caps) => [...new Set((Array.isArray(caps) ? caps : []).filter((c) => CAPS.includes(c)))].sort()
+
+/** El acta SIN la firma: es lo que se sella y sobre lo que se calcula el hash. */
+export function actaBody (acta) {
+  const { sig, ...body } = acta || {}
+  return body
+}
+
+/** Hash del acta (hex de SHA-256 sobre el cuerpo canónico). Es lo que apunta el `prev`. */
+export async function actaHash (acta) {
+  return hex(await crypto.subtle.digest('SHA-256', enc(canonicalStringify(actaBody(acta)))))
+}
+
+/** Id legible de un miembro (mismo formato que el deviceId del emparejamiento). */
+export async function memberId (pub) {
+  const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
+  return id.slice(0, 4) + '-' + id.slice(4, 8)
+}
+
+/** ¿Esta acta es un traspaso? (la firmó uno y nombra master a otro) */
+export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
+
+/**
+ * Acta de génesis: un perfil recién nacido tiene UN miembro (esta llave), que además es el
+ * sellador, con todas las capacidades. `profileId` = su pubkey → el nombre del perfil es
+ * estable para siempre y coincide con la identidad que el usuario ya tenía (cero migración).
+ */
+export function genesisActa ({ pub, encPub = null, label = '', now = Date.now() }) {
+  if (!isPub(pub)) throw new Error('genesisActa: falta la pubkey de la génesis')
+  return {
+    v: ACTA_V,
+    profileId: pub,
+    sealer: pub,
+    sealedBy: pub,
+    seq: 1,
+    prev: null,
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), caps: [...CAPS], addedAt: now, cert: null }],
+    revoked: [],
+    renounced: [],
+    updatedAt: now
+  }
+}
+
+/** Comprobaciones de FORMA (sin cripto): que el acta sea un acta. */
+export function checkShape (acta) {
+  if (!acta || typeof acta !== 'object') return 'no-acta'
+  if (acta.v !== ACTA_V) return 'version'
+  if (!isPub(acta.profileId) || !isPub(acta.sealer) || !isPub(acta.sealedBy)) return 'shape'
+  if (!Number.isInteger(acta.seq) || acta.seq < 1) return 'seq'
+  if (acta.seq > 1 && typeof acta.prev !== 'string') return 'prev'
+  if (!Array.isArray(acta.members) || acta.members.length === 0) return 'members'
+  for (const m of acta.members) {
+    if (!isPub(m?.pub) || !Array.isArray(m?.caps)) return 'member'
+    if (m.caps.some((c) => !CAPS.includes(c))) return 'cap-desconocida'
+  }
+  if (new Set(acta.members.map((m) => m.pub)).size !== acta.members.length) return 'miembro-duplicado'
+  if (!acta.members.some((m) => m.pub === acta.sealer)) return 'sealer-no-es-miembro'
+  if (!acta.members.some((m) => m.caps.includes('sign'))) return 'sin-firmante'
+  return null
+}
+
+/** Sella (firma) un acta. `privateKey` puede ser una CryptoKey no extractable. */
+export async function sealActa ({ acta, privateKey, privateJwk }) {
+  const shape = checkShape(acta)
+  if (shape) throw new Error('acta inválida: ' + shape)
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: actaBody(acta) })
+  return { ...acta, sig: signature }
+}
+
+/**
+ * Verifica un acta: forma + firma de `sealedBy`. Que ESE firmante estuviera autorizado no se
+ * decide aquí sino al adoptarla (`canAdopt`), comparándola con la que ya tienes.
+ * @returns {{ok:boolean, reason?:string}}
+ */
+export async function verifyActa ({ acta, expectedProfileId } = {}) {
+  const shape = checkShape(acta)
+  if (shape) return { ok: false, reason: shape }
+  if (typeof acta.sig !== 'string') return { ok: false, reason: 'sin-firma' }
+  if (expectedProfileId != null && acta.profileId !== expectedProfileId) return { ok: false, reason: 'otro-perfil' }
+  const ok = await verifyDeviceSig({ publickey: acta.sealedBy, data: actaBody(acta), signature: acta.sig })
+  return ok ? { ok: true } : { ok: false, reason: 'firma-invalida' }
+}
+
+/**
+ * Aplica cambios y devuelve el acta SIGUIENTE, **sin firmar** (hay que `sealActa`).
+ * `by` es quien va a sellar: si no es el sellador vigente, se rechaza (regla 1).
+ *
+ * Cambios: `{op:'admit', member}` · `{op:'caps', pub, caps}` · `{op:'remove', pub}` ·
+ * `{op:'handover', to}` · `{op:'revoke', nonce, until}` · `{op:'renounce', record}`.
+ * Van en ARRAY porque hay combinaciones que deben ser atómicas: admitir al nuevo sellador y
+ * traspasarle el master ocurre en el MISMO `seq` (§2.1.3).
+ */
+export async function applyChanges (acta, changes, { by, now = Date.now() } = {}) {
+  const shape = checkShape(acta)
+  if (shape) throw new Error('acta inválida: ' + shape)
+  if (!by) throw new Error('applyChanges: falta `by` (quién sella)')
+  if (by !== acta.sealer) throw new Error('solo el master puede cambiar el acta; este dispositivo no lo es')
+
+  const list = Array.isArray(changes) ? changes : [changes]
+  if (list.length === 0) throw new Error('applyChanges: no hay cambios')
+
+  const next = {
+    ...acta,
+    sealedBy: by,
+    seq: acta.seq + 1,
+    prev: await actaHash(acta),
+    members: acta.members.map((m) => ({ ...m, caps: [...m.caps] })),
+    revoked: [...(acta.revoked || [])],
+    renounced: [...(acta.renounced || [])],
+    updatedAt: now
+  }
+  delete next.sig
+
+  const find = (pub) => next.members.find((m) => m.pub === pub)
+
+  for (const ch of list) {
+    switch (ch?.op) {
+      case 'admit': {
+        const m = ch.member
+        if (!isPub(m?.pub)) throw new Error('admit: falta la pubkey del miembro')
+        if (find(m.pub)) throw new Error('admit: ese miembro ya está en el acta')
+        next.members.push({
+          pub: m.pub,
+          encPub: m.encPub || null,
+          label: String(m.label || '').slice(0, 60),
+          caps: cleanCaps(m.caps),
+          addedAt: now,
+          cert: m.cert || null,
+          // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
+          ...(m.continuity ? { continuity: m.continuity } : {})
+        })
+        break
+      }
+      case 'caps': {
+        const m = find(ch.pub)
+        if (!m) throw new Error('caps: ese miembro no está en el acta')
+        m.caps = cleanCaps(ch.caps)
+        break
+      }
+      case 'remove': {
+        const i = next.members.findIndex((m) => m.pub === ch.pub)
+        if (i < 0) throw new Error('remove: ese miembro no está en el acta')
+        if (next.members[i].pub === next.sealer) throw new Error('remove: no puedes expulsar al master; primero traspasa el sellado')
+        next.members.splice(i, 1)
+        break
+      }
+      case 'handover': {
+        if (!find(ch.to)) throw new Error('handover: el nuevo master tiene que ser miembro (admítelo en el mismo cambio)')
+        next.sealer = ch.to
+        break
+      }
+      case 'revoke': {
+        if (typeof ch.nonce !== 'string') throw new Error('revoke: falta el nonce')
+        next.revoked.push({ nonce: ch.nonce, until: ch.until || (now + 30 * 24 * 60 * 60 * 1000) })
+        break
+      }
+      case 'renounce': {
+        // Absorbe un registro de renuncia ya verificado (§2.2): solo puede QUITAR.
+        const r = ch.record
+        const m = find(r?.member)
+        if (!m) break // el que renunció ya no está: nada que hacer
+        m.caps = m.caps.filter((c) => !(r.caps || []).includes(c))
+        next.renounced = next.renounced.filter((x) => x.member !== r.member)
+        next.renounced.push(r)
+        break
+      }
+      default:
+        throw new Error('cambio desconocido: ' + ch?.op)
+    }
+  }
+
+  // Poda: las revocaciones vencidas ya no hacen falta (el cert al que apuntan expiró).
+  next.revoked = next.revoked.filter((r) => !r.until || r.until > now)
+
+  // Reglas de cierre: sin firmante no se puede operar, y sin sellador no se puede cambiar.
+  if (!next.members.some((m) => m.caps.includes('sign'))) {
+    throw new Error('el cambio dejaría el perfil sin ningún miembro que pueda firmar')
+  }
+  if (!next.members.some((m) => m.pub === next.sealer)) {
+    throw new Error('el cambio dejaría el acta sin master')
+  }
+  return next
+}
+
+// ----- renuncia (§2.2): el único cambio que no pasa por el master -----
+
+/** Crea el registro firmado con el que un miembro se QUITA capacidades a sí mismo. */
+export async function makeRenounce ({ member, caps, privateKey, privateJwk, now = Date.now() }) {
+  const body = { op: 'renounce', member, caps: cleanCaps(caps), ts: now }
+  if (body.caps.length === 0) throw new Error('renuncia: no hay capacidades que quitar')
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: member, data: body })
+  return { ...body, sig: signature }
+}
+
+/**
+ * ¿Es válida esta renuncia? La firma tiene que ser del PROPIO miembro. Como solo puede
+ * quitar, cualquiera puede honrarla sin riesgo, sin esperar a que el master la selle.
+ */
+export async function verifyRenounce (record) {
+  if (!record || record.op !== 'renounce' || !isPub(record.member) || typeof record.sig !== 'string') return false
+  if (!Array.isArray(record.caps) || record.caps.length === 0) return false
+  const { sig, ...body } = record
+  return verifyDeviceSig({ publickey: record.member, data: body, signature: sig })
+}
+
+/**
+ * Capacidad EFECTIVA de un miembro: lo que dice el acta menos lo que haya renunciado.
+ * `extraRenounces` son renuncias sueltas ya verificadas que todavía no absorbió el master.
+ */
+export function effectiveCaps (acta, pub, extraRenounces = []) {
+  const m = (acta?.members || []).find((x) => x.pub === pub)
+  if (!m) return []
+  const quitadas = new Set()
+  for (const r of [...(acta.renounced || []), ...extraRenounces]) {
+    if (r?.member === pub) for (const c of (r.caps || [])) quitadas.add(c)
+  }
+  return m.caps.filter((c) => !quitadas.has(c))
+}
+
+/** ¿Puede este miembro hacer `cap` según el acta? (con el cert se cruza aparte: cert ∩ acta). */
+export function memberCan (acta, pub, cap, extraRenounces = []) {
+  return effectiveCaps(acta, pub, extraRenounces).includes(cap)
+}
+
+// ----- continuidad: unir una identidad que ya existía -----
+
+/**
+ * CERTIFICADO DE CONTINUIDAD. Cuando una identidad que ya existía entra en otro perfil,
+ * firma —con su propia llave— que a partir de ahora es miembro de él. Sirve de puente:
+ * lo que hizo antes (su reputación, lo que firmó, quien la tenía de contacto) se puede
+ * seguir atribuyendo a la misma persona en vez de quedar huérfano.
+ *
+ * No otorga nada por sí solo: es una declaración del que se une, y solo tiene efecto
+ * dentro del acta donde el master la mete.
+ */
+export async function makeContinuity ({ member, from, privateKey, privateJwk, now = Date.now() }) {
+  const body = { op: 'continuity', member, from: from || member, ts: now }
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: member, data: body })
+  return { ...body, sig: signature }
+}
+
+/** ¿La firmó de verdad la identidad que dice venir? (única comprobación posible). */
+export async function verifyContinuity (record) {
+  if (!record || record.op !== 'continuity' || !isPub(record.member) || typeof record.sig !== 'string') return false
+  const { sig, ...body } = record
+  return verifyDeviceSig({ publickey: record.member, data: body, signature: sig })
+}
+
+// ----- adopción y empates (§2.4.1) -----
+
+/**
+ * ¿Adopto `candidate` en lugar de `current`?
+ *
+ *   · `seq` mayor y contigua → sí, si encadena (`prev` = hash de la mía) y la firmó quien
+ *     era master en la mía (`sealedBy === current.sealer`).
+ *   · `seq` mayor con HUECO (estuve apagado) → solo si la firmó el master que conozco; si
+ *     hubo un traspaso durante el hueco no puedo comprobarlo y toca re-admitirse (§1.3).
+ *   · MISMO `seq` → gana la que TRASPASA. Es el caso del master obsoleto: un vault restaurado
+ *     de un respaldo anterior al traspaso sella su propio `seq` creyéndose master, pero el
+ *     acta del traspaso la firmó él mismo y esa firma prueba su degradación. Si las dos
+ *     traspasan a destinos distintos (master mintiendo), desempata el hash menor —
+ *     determinista, y nada salva de un master hostil.
+ *   · `seq` menor → nunca (jamás retroceder).
+ *
+ * @returns {Promise<{adopt:boolean, reason:string}>}
+ */
+export async function canAdopt ({ candidate, current }) {
+  const v = await verifyActa({ acta: candidate, expectedProfileId: current?.profileId })
+  if (!v.ok) return { adopt: false, reason: v.reason }
+  if (!current) return { adopt: true, reason: 'sin-acta-previa' }
+
+  if (candidate.seq > current.seq) {
+    if (candidate.sealedBy !== current.sealer) return { adopt: false, reason: 'sellador-no-autorizado' }
+    if (candidate.seq === current.seq + 1 && candidate.prev !== await actaHash(current)) {
+      return { adopt: false, reason: 'no-encadena' }
+    }
+    return { adopt: true, reason: 'seq-mayor' }
+  }
+
+  if (candidate.seq === current.seq) {
+    const [hCan, hCur] = [await actaHash(candidate), await actaHash(current)]
+    if (hCan === hCur) return { adopt: false, reason: 'misma-acta' }
+    if (candidate.sealedBy !== current.sealedBy) return { adopt: false, reason: 'otro-sellador' }
+    const canT = isHandover(candidate)
+    const curT = isHandover(current)
+    if (canT && !curT) return { adopt: true, reason: 'traspaso-gana' }
+    if (!canT && curT) return { adopt: false, reason: 'traspaso-gana' }
+    return hCan < hCur ? { adopt: true, reason: 'desempate-hash' } : { adopt: false, reason: 'desempate-hash' }
+  }
+
+  return { adopt: false, reason: 'seq-menor' }
+}
+
+export default {
+  ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
+  sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
+  makeContinuity, verifyContinuity,
+  effectiveCaps, memberCan, canAdopt
+}

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 }]
@@ -335,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
@@ -594,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 = {
@@ -781,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 -----
@@ -845,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 } = {}) {
@@ -865,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).
@@ -878,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).
@@ -887,12 +1096,20 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
       // y NO se persiste ningún JWK del dispositivo (marcador useIdentityKey).
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
-      const res = await remoteEnroll({ qr, device, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
+      // Si esta identidad ya existía por su cuenta, se lleva un certificado de continuidad
+      // firmado por ella misma: es el puente para que su reputación previa siga contando.
+      const mio = loadActa()
+      const continuity = (mio && mio.members.length === 1)
+        ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
+        : null
+      const res = await remoteEnroll({ qr, device, continuity, 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 () {
@@ -935,8 +1152,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, onRevoked: wipeVaultLink }) }
-      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`
@@ -1128,6 +1349,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

@@ -56,7 +56,7 @@ async function identifyAsDevice (client, device) {
  * @param {number} [opts.approveTimeoutMs]  Espera de la aprobación humana (def 3 min).
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string}>}
  */
-export async function enrollDevice ({ qr, device, onChallenge, label = '', approveTimeoutMs = 180000 } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, approveTimeoutMs = 180000 } = {}) {
   if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: qr.proxy, enableWebRTC: false, autoReconnect: false })
@@ -75,7 +75,9 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     // 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() }
+    // `continuity`: si esta identidad ya existía, va firmada por ella misma para que lo
+    // que hizo antes se pueda seguir atribuyendo a la misma persona (ver acta.js).
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), ...(continuity ? { continuity } : {}) }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -98,7 +100,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 (_) {} }
 }
 
@@ -161,7 +163,7 @@ export async function requestStore ({ master, proxy, device, cert, method, args,
 /** Lista (solo lectura) los dispositivos enrolados en tu vault. */
 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 || [] }
+  return { devices: res.devices || [], revoked: res.revoked || [], acta: res.acta || null }
 }
 
 /**

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,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.3.0 (lib/src/{index,enroll}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.6.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

package/vault/vendor/vault/enroll.js

@@ -30,6 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
+import { verifyContinuity } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -44,6 +45,11 @@ export const MSG_ENROLLED = 'vault.enrolled'
 export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
+/** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
+const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read' }
+export const scopeToCaps = (scope) =>
+  (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
+
 /** Token aleatorio de 128 bits en hex. */
 export function randToken () {
   const b = crypto.getRandomValues(new Uint8Array(16))
@@ -152,6 +158,12 @@ export function createEnrollDesk ({
     pend.dpub = d.dpub
     pend.deviceId = deviceId
     pend.commit = d.commit
+    // Certificado de continuidad (opcional): lo firma la identidad que se une, con su
+    // propia llave. Se comprueba aquí y se guarda con el miembro al aprobar.
+    if (d.continuity) {
+      const okC = await verifyContinuity(d.continuity)
+      pend.continuity = (okC && d.continuity.member === d.dpub) ? d.continuity : null
+    }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
 
@@ -193,10 +205,24 @@ export function createEnrollDesk ({
     }
 
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
+
+    // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
+    // credencial y el acta es la política, y no tiene sentido emitir una sin la otra.
+    // Las capacidades salen del scope que se pidió al emparejar (cert ∩ acta, §2.3).
+    let acta = null
+    try {
+      if (typeof identity.admitMember === 'function') {
+        const caps = scopeToCaps(pend.scope)
+        if (caps.length) await identity.admitMember({ pub: pend.dpub, label: pend.label || '', caps, cert, continuity: pend.continuity || null })
+      }
+      acta = (await identity.profileActa?.())?.acta || null
+    } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }
+
     audit('enroll', { device: pend.deviceId, label: pend.label || '', scope: pend.scope })
     // Echamos el código tipeado junto al cert: el DISPOSITIVO acepta solo si coincide
     // con el que generó → una bóveda falsa (que no lo conoce) no puede enrolarlo.
-    reply(pend.from, { type: MSG_ENROLLED, code, cert, iss })
+    // El acta viaja con el cert: el dispositivo ya sabe de quién es el perfil al que entra.
+    reply(pend.from, { type: MSG_ENROLLED, code, cert, iss, acta })
     pend.state = 'DONE'
     pending.delete(pend.token)
     fire(onPendingChange)