@dotrino/identity 0.33.0 → 0.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -55,7 +55,7 @@
     "url": "git+https://github.com/imdotrino/dotrino-identity.git"
   },
   "dependencies": {
-    "@dotrino/proxy-client": "0.6.3"
+    "@dotrino/proxy-client": "0.8.0"
   },
   "devDependencies": {
     "fake-indexeddb": "^6.2.5"

package/src/index.js

@@ -299,6 +299,15 @@ export class Identity {
 
   /** Adopta un acta recibida de otro miembro (gana el seq mayor; a igual seq, el traspaso). */
   async adoptActa (acta) { return this._call('adoptActa', { acta }) }
+  /**
+   * Une ESTE perfil a la cuenta de otro (la de una bóveda). No es adoptar una versión nueva
+   * de la tuya: esta llave pasa a ser de OTRA cuenta y deja de tener la suya, así que solo
+   * procede sobre un perfil creado con `{ forVault: true }`. Si no, devuelve
+   * `{ joined: false, reason: 'perfil-con-datos' }` y no escribe nada.
+   */
+  async joinProfile (acta) { return this._call('joinProfile', { acta }) }
+  /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A). */
+  async prepareForAdoption () { return this._call('prepareForAdoption') }
   /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
    *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
   async profileCard () { return this._call('profileCard') }
@@ -321,10 +330,16 @@ export class Identity {
    * nunca sale), hace el emparejamiento endurecido por el proxy y guarda el cert.
    * Emite un evento 'vault' { phase:'challenge', deviceId, sas } para que muestres el
    * código a comparar; resuelve cuando el dueño aprueba en su PC (espera hasta 3 min).
+   *
+   * `join` dice **de qué cuenta se está hablando** (`vinculacion-de-cuentas.md` §3):
+   *   · `'new'`     → crea aquí una cuenta MÁS, con llave nueva, y es esa la que entra en la
+   *                   bóveda. La que estabas usando no se toca. **Es lo normal.**
+   *   · `'current'` → sigue con la cuenta abierta; solo vale si nació para adoptar o si ya
+   *                   está emparejada con esa misma bóveda. Si no, falla antes de tocar la red.
    * @returns {Promise<{ ok:boolean, deviceId:string, master:string, exp:number, scope:string[] }>}
    */
-  async enrollDevice (qr, { label = '' } = {}) {
-    return this._call('vaultPair', { qr, label }, 200000)
+  async enrollDevice (qr, { label = '', join = 'current' } = {}) {
+    return this._call('vaultPair', { qr, label, join }, 200000)
   }
 
   /** Estado de emparejamiento: { paired, deviceId?, master?, scope?, exp?, pairedAt? }. */
@@ -410,8 +425,14 @@ export class Identity {
   async listProfiles () { return this._call('listProfiles') }
   /** El perfil activo: { id, name, pubkey }. */
   async currentProfile () { return this._call('currentProfile') }
-  /** Crea un perfil nuevo (identidad fresca) y lo deja activo. La app debe recargar. */
-  async createProfile (name) { return this._call('createProfile', { name }) }
+  /**
+   * Crea un perfil nuevo (identidad fresca) y lo deja activo. La app debe recargar.
+   *
+   * `forVault: true` lo marca como **nacido para adoptar** la cuenta de una bóveda (camino B
+   * de `vinculacion-de-cuentas.md`): es el único permiso que acepta `joinProfile`, y se
+   * consume al unirse. Sin esa marca, la cuenta es de este dispositivo y nadie se la lleva.
+   */
+  async createProfile (name, { forVault = false } = {}) { return this._call('createProfile', { name, forVault }) }
   /** Cambia el perfil activo. La app debe recargar la página. */
   async switchProfile (id) { return this._call('switchProfile', { id }) }
   /** Renombra un perfil (o el activo si no se pasa id). */

package/src/node.js

@@ -173,6 +173,10 @@ export class Identity {
   renounceCaps (caps) { return this._h('renounceCaps', { caps }) }
   absorbRenounce (record) { return this._h('absorbRenounce', { record }) }
   adoptActa (acta) { return this._h('adoptActa', { acta }) }
+  /** Une ESTE perfil a la cuenta de otro (solo si nació para eso: `createProfile(n, { forVault: true })`). */
+  joinProfile (acta) { return this._h('joinProfile', { acta }) }
+  /** Marca este perfil como nacido para ADOPTAR la cuenta de otro (camino A: lo usa la bóveda). */
+  prepareForAdoption () { return this._h('prepareForAdoption') }
   /** MI tarjeta de perfil: lo mínimo que un contacto necesita para cifrarme a todos mis
    *  dispositivos (perfil, versión y llaves). Sin etiquetas ni permisos. */
   profileCard () { return this._h('profileCard') }
@@ -187,7 +191,7 @@ export class Identity {
   /** Rota la clave de contenido (corta el acceso al contenido FUTURO de quien ya no está). */
   rotateContentKey () { return this._h('rotateContentKey') }
   // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
-  enrollDevice (qr, { label = '' } = {}) { return this._h('vaultPair', { qr, label }) }
+  enrollDevice (qr, { label = '', join = 'current' } = {}) { return this._h('vaultPair', { qr, label, join }) }
   vaultStatus () { return this._h('vaultStatus') }
   unpairDevice () { return this._h('vaultUnpair') }
   vaultSign (payload) { return this._h('vaultSign', { payload }) }
@@ -198,7 +202,7 @@ export class Identity {
   // Multi-perfil por dispositivo (crear/cambiar reinicializa con el nuevo perfil activo).
   listProfiles () { return this._h('listProfiles') }
   currentProfile () { return this._h('currentProfile') }
-  createProfile (name) { return this._h('createProfile', { name }) }
+  createProfile (name, { forVault = false } = {}) { return this._h('createProfile', { name, forVault }) }
   switchProfile (id) { return this._h('switchProfile', { id }) }
   renameProfile (id, name) { return this._h('renameProfile', { id, name }) }
   deleteProfile (id) { return this._h('deleteProfile', { id }) }

package/vault/core.js

@@ -34,6 +34,7 @@ export const VAULT_DEVICE_STORAGE = 'dotrino.identity.vault.device' // sub-clave
 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 ACTA_HISTORY_STORAGE = 'dotrino.identity.acta.history' // últimas actas selladas (§1.3)
+export const PENDING_JOIN_STORAGE = 'dotrino.identity.pendingJoin'  // «nací para adoptar la cuenta de otro»
 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.).
@@ -178,6 +179,26 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   const loadProfiles = () => { try { return JSON.parse(rawKv.getItem(PROFILES_STORAGE) || '[]') || [] } catch { return [] } }
   const saveProfiles = (list) => rawKv.setItem(PROFILES_STORAGE, JSON.stringify(list))
 
+  // ----- la MARCA de «este perfil nació para adoptar la cuenta de una bóveda» -----
+  // Unirse a otra cuenta borra la que este perfil tenía, así que no puede pasar por
+  // accidente ni deducirse de heurísticas tipo «parece vacío»: se pide a propósito con
+  // `createProfile({ forVault: true })` y esa marca es el único permiso que vale.
+  // Además identity NO PUEDE ver el contenido del store (vive en otro origen), así que
+  // «vacío» no es algo que pueda comprobar por su cuenta.
+  // Ver `dotrino-vault/docs/vinculacion-de-cuentas.md` §5.1.
+  // La marca vive en DOS sitios porque hay dos formas de tener perfiles: en el
+  // navegador son entradas de una lista dentro del mismo almacén (`pendingJoin` en la
+  // entrada), y en la bóveda es UN directorio por perfil, donde esa lista está vacía y
+  // no hay ninguna entrada que marcar. El kv es lo único que existe siempre y ya está
+  // acotado al perfil abierto, así que ahí va la marca de la bóveda.
+  const isPendingJoin = (pid = currentPid) =>
+    kv.getItem(PENDING_JOIN_STORAGE) === '1' || !!loadProfiles().find((p) => p.id === pid)?.pendingJoin
+  const clearPendingJoin = (pid = currentPid) => {
+    try { kv.removeItem(PENDING_JOIN_STORAGE) } catch (_) {}
+    const list = loadProfiles(); const e = list.find((p) => p.id === pid)
+    if (e?.pendingJoin) { delete e.pendingJoin; saveProfiles(list) }
+  }
+
   // ----- keypair loaders -----
   // Con `keyStore` (IndexedDB del navegador): la privada vive como CryptoKey
   // NO EXTRACTABLE — puede FIRMAR/DERIVAR pero nadie (ni este código, ni un XSS)
@@ -440,13 +461,18 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
   }
 
   /**
-   * 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.
+   * UNIRSE a la cuenta de la bóveda con la que te acabas de emparejar (camino B de
+   * `dotrino-vault/docs/vinculacion-de-cuentas.md`). NO es adoptar una versión nueva de TU
+   * acta: es que ESTA llave pase a ser de OTRA cuenta, y por lo tanto **deja de tener la
+   * suya**.
+   *
+   * Por eso solo procede sobre un perfil que **nació para esto** (`createProfile({ forVault:
+   * true })`). Sin la marca no se une: se devuelve el conflicto para que la consola ofrezca
+   * crear una cuenta nueva, y **no se escribe nada**.
    *
-   * 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.
+   * Antes bastaba con ser el único miembro del acta propia, y entonces se sobrescribía el
+   * acta sin preguntar: una cuenta con su contenido pasaba a colgar de otra en silencio —
+   * justo la fusión de cuentas que el modelo prohíbe (§4). Eso se acabó.
    */
   async function joinProfile (candidate) {
     const v = await Acta.verifyActa({ acta: candidate })
@@ -455,10 +481,29 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       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 }
+
+    // Misma cuenta: no es unirse, es ponerse al día. Va por las reglas de adopción (§2.4.1).
+    if (current && current.profileId === candidate.profileId) {
+      const r = await adoptActa(candidate)
+      return { joined: r.adopted, reason: r.reason, profileId: candidate.profileId, seq: r.seq }
     }
+
+    if (current && !isPendingJoin()) {
+      return {
+        joined: false,
+        reason: 'perfil-con-datos',
+        profileId: current.profileId,
+        seq: current.seq,
+        members: current.members.length
+      }
+    }
+
     saveActa(candidate)
+    // El historial era de la cuenta anterior y no encadena con esta. La que se abandona es
+    // siempre una génesis recién nacida (lo garantiza la marca), así que no hay nada que
+    // retener; guardarla aquí solo mezclaría dos cuentas en la misma ventana (§1.3).
+    kv.setItem(ACTA_HISTORY_STORAGE, '[]')
+    clearPendingJoin()
     emitVault({ phase: 'acta', seq: candidate.seq, sealer: candidate.sealer, joined: true })
     return { joined: true, profileId: candidate.profileId, seq: candidate.seq }
   }
@@ -1018,14 +1063,23 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
           const m = raw ? JSON.parse(raw) : null
           if (m && typeof m.avatar === 'string') avatar = m.avatar
         } catch (_) {}
-        return { id: p.id, name: p.name || '', pubkey: p.pubkey || null, avatar, current: p.id === currentPid }
+        // `pendingJoin`: nació para adoptar la cuenta de una bóveda y todavía no se unió.
+        // La consola lo usa para no ofrecerlo como una cuenta normal a medio hacer.
+        return { id: p.id, name: p.name || '', pubkey: p.pubkey || null, avatar, current: p.id === currentPid, pendingJoin: !!p.pendingJoin }
       })
     },
     async currentProfile () {
       const e = loadProfiles().find((p) => p.id === currentPid) || {}
       return { id: currentPid, name: e.name || me?.nickname || '', pubkey: publickeyJwkStr }
     },
-    async createProfile ({ name } = {}) {
+    /**
+     * Crea una cuenta más en este dispositivo, con su propia llave.
+     *
+     * `forVault: true` la marca como **nacida para adoptar** la cuenta de una bóveda
+     * (camino B): es el único permiso que acepta `joinProfile`, y se consume al unirse.
+     * Sin la marca, la cuenta es de este dispositivo y nadie se la puede llevar.
+     */
+    async createProfile ({ name, forVault = false } = {}) {
       const pid = 'p' + crypto.randomUUID().slice(0, 8)
       currentPid = pid
       rawKv.setItem(CURRENT_STORAGE, pid)
@@ -1035,9 +1089,11 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       encKeypair = await loadOrCreateEncKeypair(); encPublickeyJwkStr = JSON.stringify(encKeypair.publicJwk)
       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)
+      const list = loadProfiles()
+      list.push({ id: pid, name: me.nickname, pubkey: publickeyJwkStr, ...(forVault ? { pendingJoin: true } : {}) })
+      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 }
+      return { id: pid, name: me.nickname, pubkey: publickeyJwkStr, pendingJoin: !!forVault }
     },
     async switchProfile ({ id } = {}) {
       if (!loadProfiles().find((p) => p.id === id)) throw new Error('perfil no existe')
@@ -1259,7 +1315,33 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // ----- 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).
-    async vaultPair ({ qr, label = '' }) {
+    /**
+     * Empareja este dispositivo con una bóveda.
+     *
+     * `join` dice **de qué cuenta estamos hablando** (V7: la intención es explícita, nunca
+     * se adivina):
+     *   · `'new'`     → camino B: crea aquí una cuenta más, con llave nueva, y ES ESA la que
+     *                   entra al acta de la bóveda. La que estabas usando **no se toca**.
+     *   · `'current'` → sigue con la cuenta abierta. Solo vale si nació para adoptar
+     *                   (`forVault`) o si ya está emparejada con ESA misma bóveda
+     *                   (re-emparejar). En cualquier otro caso falla **antes de tocar la
+     *                   red**, en vez de traerse un acta ajena y pisar la tuya.
+     *   · `'adopt'`    → camino A: la cuenta que YA vive en este aparato pasa a vivir en la
+     *                   bóveda. Sigue siendo la misma cuenta para todo el mundo (mismo
+     *                   `profileId`); lo que cambia es quién sella. Solo puede hacerlo el
+     *                   master: si esta cuenta ya la manda otra bóveda, no hay nada que
+     *                   regalar y falla en voz alta.
+     */
+    async vaultPair ({ qr, label = '', join = 'current' }) {
+      if (join === 'adopt') return handlers.vaultAdopt({ qr, label })
+      if (join === 'new') {
+        await handlers.createProfile({ name: label || me?.nickname || '', forVault: true })
+      } else {
+        const yaConEsta = loadVaultCert()?.master === qr?.iss
+        if (loadActa() && !isPendingJoin() && !yaConEsta) {
+          throw new Error('este aparato ya está usando una cuenta: para usar también la de tu bóveda, crea una cuenta nueva aquí (la que tienes abierta no se toca)')
+        }
+      }
       // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
       // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
       // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
@@ -1267,18 +1349,90 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
       // 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.
+      // Solo si esta llave tenía vida propia. Una recién creada para adoptar (camino B) no
+      // tiene pasado que salvar: mandarle un puente de continuidad sería puro ruido.
       const mio = loadActa()
-      const continuity = (mio && mio.members.length === 1)
+      const continuity = (mio && mio.members.length === 1 && !isPendingJoin())
         ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
         : null
       const res = await remoteEnroll({ qr, device, continuity, encPub: encPublickeyJwkStr, label: label || me?.nickname || '', 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() }))
-      // 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 })
+      // Conectarse a una bóveda es ENTRAR A SU CUENTA: el acta viene con el cert.
+      const unido = res.acta ? await joinProfile(res.acta) : { joined: false, reason: 'sin-acta' }
+      emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master, join: unido })
       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, join }
+      return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope, join: unido }
+    },
+
+    /**
+     * CAMINO A — «esta cuenta que tengo aquí, que la guarde mi computadora».
+     *
+     * La cuenta no se muda ni se copia: sigue siendo la misma (mismo `profileId`, misma
+     * reputación, lo mismo firmado). Lo único que cambia es **quién sella el acta**. Este
+     * aparato admite a la bóveda como miembro, le envuelve la clave de contenido para que
+     * pueda leer lo que ya hay, y le traspasa el mando — los tres cambios en un **único
+     * `seq`**, que es la regla que existe justamente para que no haya un momento raro en
+     * el que la cuenta tenga dos sellador​es o ninguno.
+     *
+     * Requisito (§2 del doc): solo puede hacerlo el master. Si esta cuenta ya la manda otra
+     * bóveda, este aparato no puede regalar lo que no tiene; el traspaso se hace desde la
+     * que manda hoy.
+     */
+    async vaultAdopt ({ qr, label = '' } = {}) {
+      const mio = loadActa()
+      if (!mio) throw new Error('este aparato todavía no tiene ninguna cuenta que entregar')
+      if (!amMaster()) throw new Error('no-eres-el-master: esta cuenta ya la manda otro dispositivo o bóveda; el traspaso se hace desde ahí')
+
+      const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
+      const res = await remoteEnroll({
+        qr,
+        device,
+        intent: 'adopt',
+        profileId: mio.profileId,
+        encPub: encPublickeyJwkStr,
+        label: label || me?.nickname || '',
+        onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }),
+        // Admitir + envolver + traspasar, en UN solo sello. Se ejecuta cuando la bóveda ya
+        // fue aprobada por un humano (el código de 6 dígitos volvió correcto).
+        onAdopt: async ({ pub, encPub, label: vlabel }) => {
+          const cambios = [{ op: 'admit', member: { pub, encPub, label: vlabel || 'bóveda', caps: ['sign', 'store', 'read'] } }]
+          // Sin la clave de contenido envuelta, la bóveda entraría mandando pero sin poder
+          // leer nada de lo que guarda la cuenta que acaba de recibir.
+          const mine = await myCek()
+          if (mine && encPub) {
+            const wrap = await Content.wrapForMember({ cek: mine.cek, memberEncPub: encPub })
+            cambios.push({ op: 'wrap', gen: mine.gen, pub, wrap })
+          }
+          cambios.push({ op: 'handover', to: pub })
+          return sealChanges(cambios)
+        }
+      })
+      // La bóveda devuelve el acta ya sellada por ella (y con los certs re-emitidos): se
+      // adopta por las reglas de siempre (§2.4.1) — encaja porque el sellador es el que
+      // este mismo aparato nombró hace un momento.
+      // `misma-acta` = la bóveda guardó exactamente la que este aparato acababa de sellar
+      // y no la cambió. No hay nada que adoptar, y es justo lo que se esperaba: el
+      // traspaso ya iba dentro de esa acta.
+      const r = await adoptActa(res.acta)
+      const ok = r.adopted || r.reason === 'misma-acta'
+      emitVault({ phase: 'adopted', master: res.master, seq: res.acta?.seq, ok })
+      if (!ok) throw new Error('la bóveda devolvió un acta que no encaja: ' + r.reason)
+      return { ok: true, adopted: true, profileId: mio.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }
+    },
+
+    /**
+     * Marca este perfil como **nacido para adoptar** la cuenta de otro (la marca que
+     * `joinProfile` exige, §5.1). Lo usa la BÓVEDA al abrir un perfil vacío para el camino
+     * A: sin la marca, adoptar la cuenta del aparato se leería como pisar una cuenta con
+     * datos y se rechazaría, que es exactamente lo que tiene que pasar cuando nadie lo pidió.
+     */
+    async prepareForAdoption () {
+      kv.setItem(PENDING_JOIN_STORAGE, '1')
+      const list = loadProfiles()
+      const e = list.find((p) => p.id === currentPid)
+      if (e) { e.pendingJoin = true; saveProfiles(list) }
+      return { ok: true, pending: true }
     },
 
     async vaultStatus () {

package/vault/remote.js

@@ -19,9 +19,16 @@ const MSG = {
   ENROLL: 'vault.enroll',
   ENROLL_CHALLENGE: 'vault.enroll.challenge',
   ENROLLED: 'vault.enrolled',
+  // --- camino A (la cuenta del aparato pasa a vivir en la bóveda) ---
+  // La bóveda, en vez del cert, manda QUIÉN es ella para que el aparato la meta en su
+  // acta; el aparato responde con el acta sellada y la bóveda devuelve la definitiva.
+  ENROLL_ADOPT: 'vault.enroll.adopt',
+  ACTA_SEALED: 'vault.acta.sealed',
+  ACTA_ADOPTED: 'vault.acta.adopted',
   REVOKED: 'vault.revoked',
   ERROR: 'vault.error'
 }
+export { MSG as VAULT_MSG }
 
 /**
  * ¿Es AUTÉNTICO este `vault.revoked`? Solo lo es si va firmado por la maestra PINEADA al
@@ -57,7 +64,7 @@ async function identifyAsDevice (client, device, { cert = null, acta = null } =
  * @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 = '', continuity = null, encPub = null, approveTimeoutMs = 180000 } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null } = {}) {
   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 })
@@ -80,16 +87,40 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // que hizo antes se pueda seguir atribuyendo a la misma persona (ver acta.js).
     // `encPub`: la llave de CIFRADO de este dispositivo. Sin ella la bóveda no puede
     // envolverle la clave de contenido del perfil, y entraría sin poder leer nada.
-    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {}) }
+    // `intent` (V7 de `vinculacion-de-cuentas.md`): va DENTRO de lo firmado, y la bóveda
+    // rechaza el que no coincida con el modo con el que ella abrió el emparejamiento. Así
+    // ninguno de los dos puede hacer, a mitad de camino, algo distinto de lo que el humano
+    // vio anunciado en las dos pantallas.
+    const adoptar = intent === 'adopt'
+    if (adoptar && typeof onAdopt !== 'function') throw new Error('enrollDevice(adopt): falta onAdopt')
+    const data = {
+      op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), intent,
+      ...(adoptar && profileId ? { profileId } : {}),
+      ...(continuity ? { continuity } : {}), ...(encPub ? { encPub } : {})
+    }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {
+      let sellando = false
       const off = client.on('message', (_from, p) => {
         if (!p || typeof p !== 'object') return
         if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, code }) } catch (_) {} }
         // El vault ECHA el código que tipeaste; aceptamos SOLO si coincide con el que generamos.
         // (Un código distinto = un vault que no lo conoce → lo ignoramos y seguimos esperando.)
         else if (p.type === MSG.ENROLLED) { if (p.code === code) { cleanup(); resolve(p) } }
+        // CAMINO A · la bóveda dice quién es (con el código de vuelta, misma defensa que el
+        // ENROLLED): este aparato la admite en SU acta, le envuelve la clave de contenido y
+        // le traspasa el mando, todo en un solo `seq`, y le manda el acta sellada.
+        else if (p.type === MSG.ENROLL_ADOPT && adoptar) {
+          if (p.code !== code || sellando) return
+          sellando = true
+          Promise.resolve(onAdopt({ pub: p.pub, encPub: p.encPub || null, label: p.label || '' }))
+            .then((acta) => { client.sendByPubkey(qr.iss, { type: MSG.ACTA_SEALED, acta, code }) })
+            .catch((e) => { cleanup(); reject(e) })
+        }
+        // La bóveda ya se vio como sellador y devuelve el acta definitiva (con los certs
+        // re-emitidos, §D9). Es la que este aparato adopta.
+        else if (p.type === MSG.ACTA_ADOPTED && adoptar) { cleanup(); resolve(p) }
         else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('timeout esperando la aprobación en el vault')) }, approveTimeoutMs)
@@ -98,6 +129,14 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
     const res = await enrolled
 
+    // Camino A: aquí no hay cert que validar — este aparato NO delega su identidad, sigue
+    // siendo la cuenta. Lo que vuelve es el acta ya sellada por la bóveda.
+    if (adoptar) {
+      if (!res.acta) throw new Error('la bóveda no devolvió el acta adoptada')
+      if (res.acta.sealer !== qr.iss) throw new Error('el acta la sella una bóveda distinta a la que viste')
+      return { device: dev, cert: null, master: qr.iss, proxy: qr.proxy, deviceId, acta: res.acta, adopted: true }
+    }
+
     // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
     const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey })
     if (!v.ok) throw new Error('cert inválido: ' + v.reason)