@dotrino/identity 0.37.1 → 0.38.0

package/package.json

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

package/src/index.js

@@ -371,6 +371,24 @@ export class Identity {
     return this._call('vaultStore', { method, args }, 20000)
   }
 
+  /**
+   * CONSOLA REMOTA: administra el perfil desde este dispositivo, contra la bóveda
+   * (`dotrino-vault/docs/consola-remota.md`). `op`: `pending` · `pair` · `approve` ·
+   * `reject` · `revoke` · `audit`.
+   *
+   * Requiere que el cert de este aparato lleve `vault:admin`, que **no se recibe al
+   * emparejar**: se concede a mano en la bóveda. Cambiar permisos y traspasar el mando
+   * NO se administran a distancia — siguen siendo del master, en su máquina.
+   */
+  async vaultAdmin (op, args) {
+    return this._call('vaultAdmin', { op, ...(args || {}) }, 20000)
+  }
+
+  /** ¿El cert de este dispositivo le permite administrar el perfil a distancia? */
+  async canAdminVault () {
+    return this._call('canAdminVault', {}, 20000)
+  }
+
   /** Lista (solo lectura) los dispositivos enrolados en tu vault: { devices, revoked }. */
   async listVaultDevices () {
     return this._call('listVaultDevices', {}, 20000)

package/vault/acta.js

@@ -35,13 +35,26 @@ export const ACTA_V = 1
 /**
  * Lista CERRADA de capacidades. Sellar y admitir no están: eso es ser el master.
  *
- * `secrets` es distinta de las otras tres: solo la pueden tener los miembros con **CN**
+ * `secrets` es distinta de las otras: solo la pueden tener los miembros con **CN**
  * (los servicios), y lo que abre es únicamente el cajón de SU nombre. Ver `cn` abajo.
+ *
+ * `admin` es la rendija que se le abre a la consola remota (`dotrino-vault/docs/
+ * consola-remota.md`): deja **admitir y expulsar** miembros a distancia, y nada más.
+ * NO deja cambiar permisos, traspasar el mando ni conceder `admin` — eso sigue siendo
+ * el rol de master, que no se delega. Así un dispositivo con `admin` robado hace daño
+ * acotado y **reversible** (se le revoca), en vez de poder dejarte fuera de tu cuenta.
  */
-export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets'])
+export const CAPS = Object.freeze(['sign', 'store', 'read', 'secrets', 'admin'])
 
 /** Capacidades de un DISPOSITIVO (sin CN): acceso a todo lo del usuario. */
-export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read'])
+export const DEVICE_CAPS = Object.freeze(['sign', 'store', 'read', 'admin'])
+
+/**
+ * Lo que recibe un dispositivo recién emparejado. `admin` **no está**: no se
+ * empareja, se concede después y a mano (`dotrino-vault caps <ID> +admin`), para que
+ * ningún QR que circule pueda otorgar administración.
+ */
+export const PAIRED_CAPS = Object.freeze(['sign', 'store', 'read'])
 
 /** Capacidades de un SERVICIO (con CN): solo su propio cajón de secretos. */
 export const SERVICE_CAPS = Object.freeze(['secrets'])
@@ -58,12 +71,13 @@ export function capScope (cap, cn = null) {
   if (cap === 'sign') return 'vault:sign'
   if (cap === 'store') return 'vault:store'
   if (cap === 'read') return 'vault:read'
+  if (cap === 'admin') return 'vault:admin'
   if (cap === 'secrets') return isValidCn(cn) ? 'vault:secrets:' + cn : null
   return null
 }
 
-/** Compat: el mapa directo, para las tres capacidades de dispositivo. */
-export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read' })
+/** Compat: el mapa directo, para las capacidades de dispositivo. */
+export const CAP_SCOPE = Object.freeze({ sign: 'vault:sign', store: 'vault:store', read: 'vault:read', admin: 'vault:admin' })
 
 const enc = (s) => new TextEncoder().encode(s)
 const hex = (buf) => [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, '0')).join('')
@@ -99,7 +113,7 @@ export const isHandover = (acta) => !!acta && acta.sealer !== acta.sealedBy
  * 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')
+  if (!isPub(pub)) throw new Error('genesisActa: missing genesis pubkey')
   return {
     v: ACTA_V,
     profileId: pub,
@@ -107,7 +121,7 @@ export function genesisActa ({ pub, encPub = null, label = '', now = Date.now()
     sealedBy: pub,
     seq: 1,
     prev: null,
-    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...DEVICE_CAPS], addedAt: now, cert: null }],
+    members: [{ pub, encPub, label: String(label || '').slice(0, 60), cn: null, caps: [...PAIRED_CAPS], addedAt: now, cert: null }],
     revoked: [],
     renounced: [],
     // Llavero del contenido: una entrada por generación, con la clave del perfil ENVUELTA
@@ -147,7 +161,7 @@ export function checkShape (acta) {
 /** 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)
+  if (shape) throw new Error('invalid record: ' + shape)
   const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: acta.sealedBy, data: actaBody(acta) })
   const sealed = { ...acta, sig: signature }
   // La TARJETA se firma en el mismo gesto y viaja con el acta: así cualquier miembro puede
@@ -181,9 +195,9 @@ export async function verifyActa ({ acta, expectedProfileId } = {}) {
  */
 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')
+  if (shape) throw new Error('invalid record: ' + shape)
+  if (!by) throw new Error('applyChanges: missing `by` (who seals)')
+  if (by !== acta.sealer) throw new Error('only the master can change the record; this device is not the master')
 
   const list = Array.isArray(changes) ? changes : [changes]
   if (list.length === 0) throw new Error('applyChanges: no hay cambios')
@@ -208,9 +222,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       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')
+        if (find(m.pub)) throw new Error('admit: that member is already in the record')
         const cn = m.cn != null ? String(m.cn) : null
-        if (cn !== null && !isValidCn(cn)) throw new Error('admit: CN inválido (minúsculas, números y guiones)')
+        if (cn !== null && !isValidCn(cn)) throw new Error('admit: invalid CN (lowercase, digits and hyphens)')
         next.members.push({
           pub: m.pub,
           encPub: m.encPub || null,
@@ -227,7 +241,7 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       }
       case 'caps': {
         const m = find(ch.pub)
-        if (!m) throw new Error('caps: ese miembro no está en el acta')
+        if (!m) throw new Error('caps: that member is not in the record')
         // No se puede ascender un servicio a dispositivo cambiándole las capacidades: para
         // eso hay que sacarlo y volver a admitirlo, que es un gesto visible.
         m.caps = cleanCaps(ch.caps).filter((c) => (m.cn ? SERVICE_CAPS : DEVICE_CAPS).includes(c))
@@ -235,8 +249,8 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
       }
       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')
+        if (i < 0) throw new Error('remove: that member is not in the record')
+        if (next.members[i].pub === next.sealer) throw new Error('remove: cannot remove the master; hand the sealing over first')
         const fuera = next.members.splice(i, 1)[0]
         // Sus envolturas se van con él: sin ellas no puede abrir ninguna generación. (El
         // acceso al contenido FUTURO se corta rotando, ver content.js; lo ya leído no vuelve.)
@@ -247,21 +261,21 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
         break
       }
       case 'handover': {
-        if (!find(ch.to)) throw new Error('handover: el nuevo master tiene que ser miembro (admítelo en el mismo cambio)')
+        if (!find(ch.to)) throw new Error('handover: the new master must be a member (admit them in the same change)')
         next.sealer = ch.to
         break
       }
       case 'keyring': {
         // Generación NUEVA de la clave de contenido (al rotar: expulsar a alguien).
         const g = ch.generation
-        if (!g || !Number.isInteger(g.gen)) throw new Error('keyring: generación inválida')
+        if (!g || !Number.isInteger(g.gen)) throw new Error('keyring: invalid generation')
         next.keyring = [...next.keyring.filter((x) => x.gen !== g.gen), g].sort((a, b) => a.gen - b.gen)
         break
       }
       case 'wrap': {
         // Envolver la clave YA existente para un miembro nuevo (al admitir: no hace falta rotar).
         const g = next.keyring.find((x) => x.gen === ch.gen)
-        if (!g) throw new Error('wrap: esa generación no está en el llavero')
+        if (!g) throw new Error('wrap: that generation is not in the keyring')
         g.wraps = { ...g.wraps, [ch.pub]: ch.wrap }
         break
       }
@@ -290,10 +304,10 @@ export async function applyChanges (acta, changes, { by, now = Date.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')
+    throw new Error('the change would leave the profile with no member able to sign')
   }
   if (!next.members.some((m) => m.pub === next.sealer)) {
-    throw new Error('el cambio dejaría el acta sin master')
+    throw new Error('the change would leave the record with no master')
   }
   return next
 }

package/vault/content.js

@@ -70,7 +70,7 @@ export async function wrapForMember ({ cek, memberEncPub }) {
 
 /** Abre la envoltura con la llave de cifrado privada de ESTE miembro. */
 export async function openWrap ({ wrap, myEncPrivateKey }) {
-  if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('envoltura inválida')
+  if (!wrap?.epk || !wrap?.iv || !wrap?.ct) throw new Error('invalid wrap')
   const key = await sharedKey(myEncPrivateKey, wrap.epk)
   const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(wrap.iv) }, key, fromB64(wrap.ct))
   return new TextDecoder().decode(pt)
@@ -119,7 +119,7 @@ export async function encryptWithCek ({ cek, gen, plaintext }) {
 export async function decryptWithKeyring ({ envelope, keyring, myPub, myEncPrivateKey }) {
   const g = (keyring || []).find((x) => x.gen === envelope?.gen)
   const w = g?.wraps?.[myPub]
-  if (!w) throw new Error('este dispositivo no tiene la llave de esa generación de contenido')
+  if (!w) throw new Error('this device does not hold the key for that content generation')
   const cek = await openWrap({ wrap: w, myEncPrivateKey })
   const k = await subtle.importKey('raw', fromB64(cek), { name: 'AES-GCM' }, false, ['decrypt'])
   const pt = await subtle.decrypt({ name: 'AES-GCM', iv: fromB64(envelope.iv) }, k, fromB64(envelope.ct))

package/vault/core.js

@@ -22,7 +22,7 @@ import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './
 import * as Acta from './acta.js'
 import * as Content from './content.js'
 import { pubkeyId as pubkeyIdOf } from './capabilities.js'
-import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew } from './remote.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices, requestRenew as remoteRenew, requestAdmin as remoteAdmin } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -400,7 +400,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
    */
   async function sealChanges (changes) {
     const acta = loadActa()
-    if (!acta) throw new Error('este perfil todavía no tiene acta')
+    if (!acta) throw new Error('this profile has no record yet')
     const next = await Acta.applyChanges(acta, changes, { by: publickeyJwkStr })
     const sealed = await seal(next)
     pushHistory(acta) // la que deja de ser vigente entra en la ventana de retención
@@ -815,7 +815,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       const proof = await derivePwd(password, pwd.salt, pwd.iter)
       if (proof !== pwd.verifier) {
         kv.setItem('dotrino.identity.pwd.tries', JSON.stringify({ n: tries.n + 1, at: Date.now() }))
-        throw new Error('contraseña incorrecta')
+        throw new Error('wrong password')
       }
       kv.removeItem('dotrino.identity.pwd.tries')
       try { sessionKv?.setItem(_scoped(PWD_SESSION), proof) } catch (_) {}
@@ -825,7 +825,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // Poner/cambiar contraseña (requiere estar desbloqueado; cambiar exige la actual vía unlock previo).
     async setProfilePassword ({ password }) {
       if (locked) throw new Error('perfil bloqueado')
-      if (!password || String(password).length < 4) throw new Error('la contraseña debe tener al menos 4 caracteres')
+      if (!password || String(password).length < 4) throw new Error('password must be at least 4 characters')
       const salt = b64(crypto.getRandomValues(new Uint8Array(16)))
       const verifier = await derivePwd(password, salt, PWD_ITER)
       kv.setItem(PWD_STORAGE, JSON.stringify({ v: 1, salt, iter: PWD_ITER, verifier }))
@@ -1004,7 +1004,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
       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')
+        throw new Error('profile-without-signer: this device no longer signs for you and is not connected to any vault that can')
       }
       maybeRenewVaultCert()
       try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload: data, onRevoked: wipeVaultLink }) }
@@ -1109,7 +1109,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     },
     async deleteProfile ({ id } = {}) {
       let list = loadProfiles()
-      if (list.length <= 1) throw new Error('no se puede borrar el único perfil')
+      if (list.length <= 1) throw new Error('cannot delete the only profile')
       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).
@@ -1220,7 +1220,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async renounceCaps ({ caps } = {}) {
       const acta = loadActa()
-      if (!acta) throw new Error('este perfil todavía no tiene acta')
+      if (!acta) throw new Error('this profile has no record yet')
       const record = await Acta.makeRenounce({ member: publickeyJwkStr, caps, privateKey: keypair.privateKey })
       const pend = loadRenounces().filter((r) => r.member !== publickeyJwkStr)
       pend.push(record)
@@ -1233,7 +1233,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
 
     /** 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')
+      if (!(await Acta.verifyRenounce(record))) throw new Error('invalid renounce: the signature is not the member own')
       const acta = await sealChanges([{ op: 'renounce', record }])
       return { ok: true, seq: acta.seq }
     },
@@ -1250,7 +1250,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async sealContent ({ plaintext } = {}) {
       const mine = await myCek()
-      if (!mine) throw new Error('este dispositivo todavía no tiene la clave de contenido del perfil')
+      if (!mine) throw new Error('this device does not hold the profile content key yet')
       return Content.encryptWithCek({ cek: mine.cek, gen: mine.gen, plaintext: String(plaintext) })
     },
 
@@ -1294,7 +1294,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      * y la firmó el mismo master. Si el master cambió, se avisa en vez de aceptarlo callando.
      */
     async adoptPeerCard ({ card } = {}) {
-      if (!card?.profileId) throw new Error('tarjeta inválida')
+      if (!card?.profileId) throw new Error('invalid card')
       const peers = loadPeers()
       const prev = peers[card.profileId]?.card || null
       const r = await Acta.canAdoptCard({ card, current: prev })
@@ -1339,7 +1339,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       } 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)')
+          throw new Error('this device is already using an account: to also use your vault account, create a new account here (the open one is untouched)')
         }
       }
       // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
@@ -1381,8 +1381,8 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     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í')
+      if (!mio) throw new Error('this device has no account to hand over yet')
+      if (!amMaster()) throw new Error('not-the-master: another device or vault is in charge of this account; the handover is done from there')
 
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
       const res = await remoteEnroll({
@@ -1417,7 +1417,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       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)
+      if (!ok) throw new Error('the vault returned a record that does not fit: ' + r.reason)
       return { ok: true, adopted: true, profileId: mio.profileId, seq: r.seq ?? res.acta?.seq, master: res.master, deviceId: res.deviceId }
     },
 
@@ -1454,7 +1454,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     // así nada se rompe si no estás emparejado o si el vault está apagado.
     async vaultSign ({ payload }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
       try { return await remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload, onRevoked: wipeVaultLink }) }
       catch (e) { return handleVaultError(e) }
@@ -1470,7 +1470,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
      */
     async vaultStore ({ method, args }) {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
       const mine = await myCek().catch(() => null)
       let payload = { method, args }
@@ -1489,10 +1489,38 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       } catch (e) { return handleVaultError(e) }
     },
 
+    /**
+     * CONSOLA REMOTA: administrar el perfil desde este dispositivo (ver
+     * `dotrino-vault/docs/consola-remota.md`). Requiere que el cert de este aparato
+     * lleve `vault:admin`, que **no se recibe al emparejar**: se concede a mano en la
+     * bóveda (`dotrino-vault caps <ID> +administra`).
+     *
+     * `op`: `pending` · `pair` · `approve` · `reject` · `revoke` · `audit`. Cambiar
+     * permisos y traspasar el mando NO están, y no es un olvido: eso sigue siendo del
+     * master, en su máquina.
+     */
+    async vaultAdmin ({ op, ...rest } = {}) {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
+      maybeRenewVaultCert()
+      try { return await remoteAdmin({ master: v.master, proxy: v.proxy, device, cert: v.cert, op, ...rest, onRevoked: wipeVaultLink }) }
+      catch (e) { return handleVaultError(e) }
+    },
+
+    /**
+     * ¿Puede ESTE dispositivo administrar el perfil a distancia? Sale del scope del
+     * cert que le dio la bóveda, no de una preferencia: la interfaz pregunta para
+     * saber qué pintar, pero quien decide es la bóveda al recibir la petición.
+     */
+    canAdminVault () {
+      const v = loadVaultCert()
+      return !!v?.cert && (v.cert.scope || []).includes('vault:admin')
+    },
+
     // Lista (solo lectura) de dispositivos enrolados en tu vault.
     async listVaultDevices () {
       const v = loadVaultCert(); const device = loadVaultDevice()
-      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      if (!v?.cert || !device) throw new Error('this device is not paired with a vault')
       maybeRenewVaultCert()
       try {
         const res = await remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert, sinceSeq: loadActa()?.seq ?? 0, onRevoked: wipeVaultLink })
@@ -1603,7 +1631,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       if (!envelope || (envelope.v !== 1 && envelope.v !== 2)) throw new Error('Unsupported envelope')
       const myId = await encKeyId(encPublickeyJwkStr)
       const myEntry = envelope.wrap && (envelope.wrap[myId] || (myToken ? envelope.wrap[myToken] : null))
-      if (!myEntry) throw new Error('este dispositivo no está entre los destinatarios del mensaje')
+      if (!myEntry) throw new Error('this device is not among the message recipients')
       const senderPub = await importPeerEncPubkey(senderEncryptionPubkey)
       const sharedKey = await deriveSharedAesKey(encKeypair.privateKey, senderPub)
       const kRaw = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: base64ToBuf(myEntry.iv) }, sharedKey, base64ToBuf(myEntry.ct))
@@ -1615,7 +1643,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     async exportIdentity () {
       const raw = kv.getItem(KEY_STORAGE)
       if (!raw) {
-        throw new Error('Este perfil guarda su llave de forma NO exportable (protección contra robo). ' +
+        throw new Error('This profile stores its key as NON-exportable (theft protection). ' +
           'Para usar tu identidad en otro navegador, conecta ese navegador a tu bóveda (vault) desde profile.dotrino.com.')
       }
       const keys = JSON.parse(raw)
@@ -1758,7 +1786,7 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
     const fn = handlers[name]
     handlers[name] = async (params) => {
       if (locked) refreshLockState() // otra pestaña pudo desbloquear… no: session es por pestaña; re-chequea por si se quitó el pwd
-      if (locked) throw new Error('perfil bloqueado: desbloquéalo con tu contraseña (unlockProfile)')
+      if (locked) throw new Error('profile locked: unlock it with your password (unlockProfile)')
       return fn(params)
     }
   }

package/vault/index.html

@@ -25,7 +25,8 @@
   { "imports": {
     "@dotrino/proxy-client": "./vendor/proxy-client/index.js",
     "@dotrino/vault": "./vendor/vault/index.js",
-    "@dotrino/identity/capabilities": "./capabilities.js"
+    "@dotrino/identity/capabilities": "./capabilities.js",
+    "@dotrino/identity/acta": "./acta.js"
   } }
   </script>
   <script type="module" src="./vault.js"></script>

package/vault/peerStore.js

@@ -96,7 +96,7 @@ export async function initPeerStorage () {
     const stored = await idbGet(_idb, peersKey()) // peer book DEL perfil activo (namespaceado)
     _peers = (stored && typeof stored === 'object') ? stored : {}
   } catch (e) {
-    console.warn('[cc-identity] IndexedDB no disponible, uso localStorage:', e?.message)
+    console.warn('[cc-identity] IndexedDB unavailable, falling back to localStorage:', e?.message)
     _fallback = true
     _idb = null
     try { const raw = localStorage.getItem(peersKey()); _peers = raw ? (JSON.parse(raw) || {}) : {} }
@@ -109,13 +109,13 @@ function persistPeers () {
   const key = peersKey()
   if (_fallback || !_idb) {
     try { localStorage.setItem(key, JSON.stringify(_peers)) }
-    catch (e) { console.warn('[cc-identity] persist (ls) falló:', e?.message) }
+    catch (e) { console.warn('[cc-identity] persist (ls) failed:', e?.message) }
     return _writeChain
   }
   const snapshot = _peers
   _writeChain = _writeChain
     .then(() => idbPut(_idb, key, snapshot))
-    .catch(e => console.warn('[cc-identity] persist (idb) falló:', e?.message))
+    .catch(e => console.warn('[cc-identity] persist (idb) failed:', e?.message))
   return _writeChain
 }
 

package/vault/remote.js

@@ -28,6 +28,10 @@ const MSG = {
   ACTA_SEALED: 'vault.acta.sealed',
   ACTA_ADOPTED: 'vault.acta.adopted',
   REVOKED: 'vault.revoked',
+  // Consola remota: administrar el perfil desde un dispositivo (scope `vault:admin`).
+  ADMIN: 'vault.admin',
+  ADMIN_RESULT: 'vault.admin.result',
+  ADMIN_EVENT: 'vault.admin.event',
   ERROR: 'vault.error'
 }
 export { MSG as VAULT_MSG }
@@ -68,9 +72,9 @@ async function identifyAsDevice (client, device, { cert = null, acta = null } =
  */
 async function verificarHola (p, sn) {
   const b = p?.body
-  if (!b?.iss || b.sn !== sn) throw new Error('la bóveda contestó a otro emparejamiento')
+  if (!b?.iss || b.sn !== sn) throw new Error('the vault answered a different pairing')
   if (!(await verifyDeviceSig({ publickey: b.iss, data: b, signature: p.signature }))) {
-    throw new Error('la respuesta de la bóveda no está bien firmada')
+    throw new Error('the vault reply is not properly signed')
   }
   return b
 }
@@ -82,7 +86,7 @@ async function verificarHola (p, sn) {
  */
 async function canjearCita (client, code) {
   const r = await client.redeemPairingCode(code)
-  if (!r?.ok || !r.instance) throw new Error(r?.error || 'ese código de emparejamiento ya no vale')
+  if (!r?.ok || !r.instance) throw new Error(r?.error || 'that pairing code is no longer valid')
   return r.instance
 }
 
@@ -94,7 +98,7 @@ async function askVault (client, qr) {
       if (p?.type === MSG.HELLO_OK) { fin(); verificarHola(p, qr.sn).then((b) => resolve({ iss: b.iss, proxy: b.proxy || qr.proxy, acct: b.acct || '', m: b.m || qr.m }), reject) }
       else if (p?.type === MSG.ERROR) { fin(); reject(new Error(p.error)) }
     })
-    const t = setTimeout(() => { fin(); reject(new Error('la bóveda no contestó: ese código pudo caducar')) }, 15000)
+    const t = setTimeout(() => { fin(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
     const fin = () => { off(); clearTimeout(t) }
     try { client.send(destino, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { fin(); reject(e) }
   })
@@ -109,7 +113,7 @@ async function askVault (client, qr) {
  * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string}>}
  */
 export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, encPub = null, approveTimeoutMs = 180000, intent = 'join', profileId = null, onAdopt = null } = {}) {
-  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('qr inválido: falta la bóveda o el nonce')
+  if (!qr?.sn || !(qr.iss || qr.conn)) throw new Error('invalid qr: missing vault or nonce')
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
   const client = new WebSocketProxyClient({ url: qr.proxy || 'wss://proxy.dotrino.com', enableWebRTC: false, autoReconnect: false })
   await client.connect()
@@ -172,7 +176,7 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
         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)
+      const t = setTimeout(() => { cleanup(); reject(new Error('timeout waiting for approval at the vault')) }, approveTimeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
     })
     client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
@@ -181,14 +185,14 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', conti
     // 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')
+      if (!res.acta) throw new Error('the vault did not return the adopted record')
+      if (res.acta.sealer !== qr.iss) throw new Error('the record is sealed by a vault other than the one you saw')
       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)
+    if (!v.ok) throw new Error('invalid cert: ' + 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, acta: res.acta || null }
@@ -237,7 +241,7 @@ async function vaultRpc ({ master, proxy, device, cert, acta = null, sendType, o
         if (p.type === okType) { 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 t = setTimeout(() => { cleanup(); reject(new Error('the vault did not reply (is it running?)')) }, timeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
     })
     client.sendByPubkey(master, { type: sendType, data: signed, signature, cert })
@@ -267,6 +271,39 @@ export async function requestDevices ({ master, proxy, device, cert, sinceSeq, o
  */
 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')
+  if (!res.cert || res.cert.sub !== device.publickey || res.cert.iss !== master) throw new Error('invalid renewed cert')
   return { cert: res.cert }
 }
+
+/**
+ * CONSOLA REMOTA (`dotrino-vault/docs/consola-remota.md`): administrar el perfil desde
+ * este dispositivo, sin ir al PC. Requiere un cert con scope `vault:admin`, que **no se
+ * recibe al emparejar** — se concede a mano en la bóveda.
+ *
+ * `op`: `pending` · `pair` · `approve` · `reject` · `revoke` · `audit`. Lo que NO existe
+ * aquí es tan importante como lo que sí: cambiar permisos, traspasar el mando y los
+ * secretos de servicios no se administran a distancia.
+ *
+ * El `nonce` de un solo uso va en cada petición porque `approve` y `revoke` cambian
+ * estado, y para eso la ventana de frescura de ±5 min no alcanza.
+ */
+export async function requestAdmin ({ master, proxy, device, cert, op, onRevoked, ...rest } = {}) {
+  const nonce = [...crypto.getRandomValues(new Uint8Array(16))]
+    .map((b) => b.toString(16).padStart(2, '0')).join('')
+  const res = await vaultRpc({
+    master, proxy, device, cert, onRevoked,
+    sendType: MSG.ADMIN, okType: MSG.ADMIN_RESULT,
+    data: { op, ...rest, nonce }
+  })
+  return res.result
+}
+
+/**
+ * ¿Es AUTÉNTICO este `vault.admin.event` (entró o salió alguien del perfil)? Solo si va
+ * firmado por la maestra PINEADA. Un aviso sin firma no se muestra: si no, cualquiera
+ * podría llenar de alarmas falsas los dispositivos del usuario.
+ */
+export async function isAuthenticAdminEvent ({ body, signature, master }) {
+  if (!body || typeof body.ev !== 'string') return false
+  return verifyDeviceSig({ publickey: master, data: body, signature })
+}

package/vault/vault.js

@@ -119,7 +119,11 @@ import { pubkeyId } from './capabilities.js'
     listDelegations: () => handlers.listDelegations({}),
     revokeDelegation: (nonce) => handlers.revokeDelegation({ nonce }),
     admitMember: (m) => handlers.admitMember(m),
-    profileActa: () => handlers.profileActa({})
+    profileActa: () => handlers.profileActa({}),
+    // Camino A (`mode: 'adopt'`): la bóveda se queda con la cuenta que trae el aparato,
+    // y para eso tiene que poder ENTRAR en su acta. Sin esto, adoptar fallaba con un
+    // «no es una función» en vez de con un error del protocolo.
+    joinProfile: (acta) => handlers.joinProfile({ acta })
   }
 
   async function startSelfDaemon () {
@@ -216,7 +220,7 @@ import { pubkeyId } from './capabilities.js'
       return { ok: true, enabled: !!enabled }
     },
     selfVaultPairing: async (opts) => {
-      if (!daemon) throw new Error('esta pestaña no es la bóveda activa; ábrela como pestaña visible')
+      if (!daemon) throw new Error('this tab is not the active vault; open it as a visible tab')
       return daemon.startPairing(opts)
     },
     selfVaultPending: async () => (daemon ? daemon.listPending() : []),
@@ -226,11 +230,11 @@ import { pubkeyId } from './capabilities.js'
       return issued || []
     },
     selfVaultApprove: async ({ deviceId, code }) => {
-      if (!daemon) throw new Error('esta pestaña no es la bóveda activa')
+      if (!daemon) throw new Error('this tab is not the active vault')
       return daemon.approve(deviceId, code)
     },
     selfVaultReject: async ({ deviceId }) => {
-      if (!daemon) throw new Error('esta pestaña no es la bóveda activa')
+      if (!daemon) throw new Error('this tab is not the active vault')
       daemon.reject(deviceId)
       return { ok: true }
     },

package/vault/vendor/vault/VERSION.txt

@@ -1,6 +1,6 @@
-Copia vendorizada de @dotrino/vault@0.7.0 (lib/src/{index,enroll}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.18.0 (lib/src/{index,enroll,protocol}.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.
+resuelve en el navegador sin bundler. index.js importa ./enroll.js y ./protocol.js
+(relativos, se vendorizan tambien) y @dotrino/identity/capabilities (=../../capabilities.js)
+y @dotrino/proxy-client (=../proxy-client/), ambos via el import map de index.html.
+Re-vendorizar LOS TRES archivos al subir @dotrino/vault.

package/vault/vendor/vault/enroll.js

@@ -39,14 +39,20 @@ export const FRESH_WINDOW_MS = 5 * 60 * 1000
 /** Vida por defecto del cert de un dispositivo (tope duro de `MAX_DELEGATION_MS`). */
 export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 
+export const MSG_HELLO = 'vault.hello'
+export const MSG_HELLO_OK = 'vault.hello.ok'
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
+// --- camino A: la cuenta del aparato pasa a vivir en la bóveda ---
+export const MSG_ENROLL_ADOPT = 'vault.enroll.adopt'
+export const MSG_ACTA_SEALED = 'vault.acta.sealed'
+export const MSG_ACTA_ADOPTED = 'vault.acta.adopted'
 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' }
+const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin' }
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 
@@ -63,12 +69,22 @@ export function scopeToCn (scope) {
   return null
 }
 
-/** Token aleatorio de 128 bits en hex. */
-export function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
+/**
+ * Token aleatorio en hex (16 bytes = 128 bits por defecto).
+ *
+ * El emparejamiento pide 12 (96 bits): son de un solo uso, valen 5 minutos y hay
+ * UNA sesión viva a la vez, así que adivinarlo es 2^95 intentos contra una bóveda
+ * que además exige el código de 6 dígitos. A cambio, cada byte de menos son ~1,4
+ * caracteres menos en el QR — y el QR se mide en filas de terminal.
+ */
+export function randToken (bytes = 16) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes))
   return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/** Tamaño del token/nonce de una sesión de emparejamiento (ver `randToken`). */
+const PAIR_TOKEN_BYTES = 12
+
 /** deviceId legible (p. ej. `C440-AC0E`) a partir de una pubkey JWK. */
 export async function deviceIdOf (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -94,27 +110,65 @@ export async function deviceIdOf (pub) {
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {},
-  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
+  // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
+  // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
+  encPub = null, vaultLabel = '',
+  // Token de CONEXIÓN de esta bóveda en el proxy (4 chars): su dirección. Es lo
+  // único que necesita el QR corto para que el aparato le hable punto a punto.
+  connToken = null
 } = {}) {
-  if (!identity) throw new Error('createEnrollDesk: falta identity')
-  if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
+  if (!identity) throw new Error('createEnrollDesk: missing identity')
+  if (!iss) throw new Error('createEnrollDesk: missing iss (master pubkey)')
 
   // token -> { token, exp, scope, ttlMs, label, sn, state, dpub?, deviceId?, commit?, from? }
   // state: 'AWAITING_ENROLL' -> 'PENDING_CONFIRM'
   const pending = new Map()
 
   const fire = (fn, arg) => { try { fn(arg) } catch (_) {} }
-  const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) } }
+  const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] could not reply:', e.message) } }
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
 
-  /** Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía. */
-  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '' } = {}) {
+  /**
+   * Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía.
+   *
+   * `mode` y `account` son LO QUE LA BÓVEDA DECLARA que va a pasar, y viajan en el QR
+   * para que el aparato pueda **decirlo antes de hacerlo** en vez de emparejar a
+   * ciegas (decisión V9 de `docs/vinculacion-de-cuentas.md`: pregunta el vault, el
+   * dispositivo muestra el proceso y sus consecuencias):
+   *
+   *   · `mode: 'join'`  → el dispositivo estrena una cuenta suya y entra a la de la
+   *                       bóveda. Es lo único que existe hoy.
+   *   · `mode: 'adopt'` → la bóveda se quedaría con la cuenta que trae el aparato
+   *                       (camino A). Reservado: todavía no hay protocolo.
+   *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
+   *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
+   *                       identidad de verdad de la cuenta es `iss`.
+   */
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
-    const token = randToken()
-    const sn = randToken()
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, state: 'AWAITING_ENROLL' })
-    return { token, qr: { v: 2, iss, proxy, token, sn }, expiresInMs: PAIRING_TTL_MS }
+    const acct = String(account || '').slice(0, 40)
+    // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
+    // nonce de la sesión. La llave, el proxy y el nombre de la cuenta los pide el
+    // aparato por la red presentando el `sn`. El nonce hace de identificador de
+    // sesión: no hace falta un token de emparejamiento aparte.
+    //
+    // `conn` es una CITA del proxio (6 caracteres, un solo uso, caduca en
+    // minutos), no la dirección de la conexión: esa pasó a ser una instancia de
+    // 24 caracteres, que ni entra cómoda en un QR ni tiene por qué quedar impresa
+    // en algo que circula. Por eso se pide una nueva por emparejamiento, y por
+    // eso esto es asíncrono.
+    const conn = typeof connToken === 'function' ? await connToken() : connToken
+    if (conn) {
+      const sn = randToken(8)
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
+    }
+    const token = randToken(PAIR_TOKEN_BYTES)
+    const sn = randToken(PAIR_TOKEN_BYTES)
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+    return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
   function stopPairing (token) { pending.delete(token) }
@@ -132,6 +186,28 @@ export function createEnrollDesk ({
     return null
   }
 
+  /**
+   * «¿Quién eres?» — la respuesta al QR corto. Solo se contesta a quien presente el
+   * `sn` de una sesión VIVA: el token de conexión son 4 caracteres y se puede acertar
+   * a ciegas, el `sn` no. Fuera de un emparejamiento no hay ninguna sesión y por lo
+   * tanto no hay respuesta: la puerta solo está abierta mientras dura el `pair`.
+   */
+  async function handleHello (from, p) {
+    const pend = pending.get(String(p?.sn || ''))
+    if (!pend || Date.now() > pend.exp) {
+      audit('rejected', { what: 'hello', reason: 'sin-sesion' })
+      return reply(from, { type: MSG_ERROR, error: 'no pairing session open for that code' })
+    }
+    // La respuesta va FIRMADA por la maestra y el `sn` va dentro de lo firmado. Eso ata
+    // la respuesta a ESTA sesión: no se puede reutilizar la de otro emparejamiento ni la
+    // de otra bóveda. Lo que NO hace es demostrar que sea TU bóveda —cualquiera puede
+    // firmar con una llave suya—; eso solo lo demuestra el código de 6 dígitos.
+    const body = { op: 'hello', sn: pend.sn, iss, proxy, acct: pend.account || '', m: pend.mode || 'join', ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    reply(from, { type: MSG_HELLO_OK, body, signature })
+    return { ok: true }
+  }
+
   /**
    * ENROLL: el dispositivo prueba posesión de `D` firmando el sobre y deja el
    * COMPROMISO de su código. Todavía NO se firma ningún cert.
@@ -139,31 +215,42 @@ export function createEnrollDesk ({
   async function handleEnroll (from, p) {
     const d = p?.data
     if (!d || typeof d.dpub !== 'string' || typeof p.signature !== 'string') {
-      return reply(from, { type: MSG_ERROR, error: 'enroll inválido' })
+      return reply(from, { type: MSG_ERROR, error: 'invalid enroll' })
     }
     const pend = pending.get(d.token)
     if (!pend || pend.state === 'DONE' || Date.now() > pend.exp) {
-      return reply(from, { type: MSG_ERROR, error: 'token de emparejamiento inválido o expirado' })
+      return reply(from, { type: MSG_ERROR, error: 'invalid or expired pairing token' })
+    }
+    if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'invalid session' })
+    // V7 · la INTENCIÓN viaja firmada y tiene que coincidir con el modo con el que ESTA
+    // bóveda abrió el emparejamiento. Es lo que garantiza que lo que pasa es lo que el
+    // humano vio anunciado en las dos pantallas, y no algo que se decidió a mitad de camino.
+    const intent = d.intent || 'join'
+    if (intent !== 'join' && intent !== 'adopt') {
+      return reply(from, { type: MSG_ERROR, error: 'unknown intent: ' + intent })
+    }
+    if (intent !== (pend.mode || 'join')) {
+      audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
+      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
     }
-    if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'sesión inválida' })
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
-      return reply(from, { type: MSG_ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
+      return reply(from, { type: MSG_ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
     // PRUEBA DE POSESIÓN: la firma de `data` debe verificar contra `dpub`.
     if (!(await verifyDeviceSig({ publickey: d.dpub, data: d, signature: p.signature }))) {
       audit('rejected', { what: 'enroll', reason: 'bad-device-signature' })
-      return reply(from, { type: MSG_ERROR, error: 'firma de dispositivo inválida' })
+      return reply(from, { type: MSG_ERROR, error: 'invalid device signature' })
     }
     // El COMPROMISO del código es obligatorio: sin él no se puede comprobar al aprobar
     // y volveríamos a emitir certs a ciegas. Un cliente viejo cae acá con un mensaje claro.
     if (typeof d.commit !== 'string' || !/^[0-9a-f]{64}$/.test(d.commit)) {
       audit('rejected', { what: 'enroll', reason: 'no-commit' })
-      return reply(from, { type: MSG_ERROR, error: 'este dispositivo usa una versión antigua del emparejamiento (no envía el compromiso del código). Actualízalo y vuelve a intentarlo.' })
+      return reply(from, { type: MSG_ERROR, error: 'this device speaks an old pairing version (no code commitment). Update it and try again.' })
     }
     // Un solo dispositivo a la vez esperando su código (así aprobar no es ambiguo).
     if (pend.state === 'PENDING_CONFIRM' && pend.dpub && pend.dpub !== d.dpub) {
-      return reply(from, { type: MSG_ERROR, error: 'ya hay un dispositivo usando este emparejamiento' })
+      return reply(from, { type: MSG_ERROR, error: 'another device is already using this pairing session' })
     }
 
     const deviceId = await deviceIdOf(d.dpub)
@@ -182,9 +269,12 @@ export function createEnrollDesk ({
     }
     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)
+    // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
+    // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
+    if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -199,16 +289,16 @@ export function createEnrollDesk ({
    */
   async function approve (code, { deviceId } = {}) {
     code = String(code || '').trim()
-    if (!code) throw new Error('falta el código (los dígitos que muestra el dispositivo)')
+    if (!code) throw new Error('missing code (the digits shown by the device)')
 
     let pend
     if (deviceId) {
       pend = findPending(deviceId)
-      if (!pend) throw new Error('no hay ninguna máquina esperando aprobación con ese identificador')
+      if (!pend) throw new Error('no device awaiting approval with that id')
     } else {
       const waiting = [...pending.values()].filter((p) => p.state === 'PENDING_CONFIRM' && p.dpub)
-      if (waiting.length === 0) throw new Error('no hay ningún dispositivo esperando aprobación')
-      if (waiting.length > 1) throw new Error('hay más de un emparejamiento en curso; reinícialo con dotrino-vault pair')
+      if (waiting.length === 0) throw new Error('no device awaiting approval')
+      if (waiting.length > 1) throw new Error('more than one pairing in flight; restart it with dotrino-vault pair')
       pend = waiting[0]
     }
 
@@ -216,8 +306,22 @@ export function createEnrollDesk ({
     const expected = await commitCode({ code, dpub: pend.dpub, sn: pend.sn })
     if (expected !== pend.commit) {
       audit('rejected', { what: 'approve', device: pend.deviceId, reason: 'bad-code' })
-      log('[vault] código incorrecto para %s: no se emitió ningún certificado', pend.deviceId)
-      throw new Error('el código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Vuelve a mirarlo y prueba otra vez.')
+      log('[vault] wrong code for %s: no certificate was issued', pend.deviceId)
+      throw new Error('code does not match the one shown by the device: no certificate was issued. Check it and try again.')
+    }
+
+    // CAMINO A · aquí la bóveda no entrega un cert: entrega SU IDENTIDAD para que el
+    // aparato la meta en el acta de la cuenta que le está pasando. El código de vuelta es
+    // la misma defensa de siempre, en el otro sentido: el aparato solo hace caso a una
+    // bóveda que demuestre que un humano la aprobó.
+    if ((pend.mode || 'join') === 'adopt') {
+      audit('adopt-approve', { device: pend.deviceId, profile: pend.profileId || null })
+      pend.state = 'AWAITING_ACTA'
+      pend.approvedAt = Date.now()
+      reply(pend.from, { type: MSG_ENROLL_ADOPT, code, pub: iss, encPub: encPub || null, label: vaultLabel || '' })
+      log('[vault] adoption approved for %s: waiting for the sealed record', pend.deviceId)
+      fire(onPendingChange)
+      return { ok: true, deviceId: pend.deviceId, adopting: true }
     }
 
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
@@ -247,13 +351,67 @@ export function createEnrollDesk ({
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
+  /**
+   * CAMINO A · paso 6: llega el acta que el aparato acaba de sellar, con la bóveda dentro
+   * como miembro, la clave de contenido envuelta para ella y el mando ya traspasado.
+   *
+   * Lo que se comprueba antes de guardar nada (y por qué):
+   *   · que el sellador sea ESTA bóveda — si no, no es un traspaso, es un acta ajena;
+   *   · que la selle el aparato que estaba en este emparejamiento — cierra que un tercero
+   *     que vea pasar el mensaje cuele la suya;
+   *   · que sea la cuenta que ese aparato declaró al enrolarse (`profileId`) — cierra el
+   *     cambiazo de cuenta entre el anuncio que leyó el humano y lo que llega después.
+   *
+   * Adoptar la cuenta de otro solo procede sobre un perfil que **nació para eso** (la marca
+   * de `prepareForAdoption`). Es la misma regla del navegador: sin la marca, adoptar sería
+   * pisar una cuenta con datos, y eso no puede pasar por accidente.
+   */
+  async function handleActaSealed (from, p) {
+    const acta = p?.acta
+    const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
+    if (!pend) return reply(from, { type: MSG_ERROR, error: 'no adoption awaiting a record' })
+    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'record missing or unreadable' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'that record does not name this vault as the sealer' })
+    }
+    if (acta.sealedBy !== pend.dpub) {
+      audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
+      return reply(from, { type: MSG_ERROR, error: 'that record was not sealed by the device of this pairing' })
+    }
+    if (pend.profileId && acta.profileId !== pend.profileId) {
+      audit('rejected', { what: 'adopt', reason: 'other-profile' })
+      return reply(from, { type: MSG_ERROR, error: 'that record belongs to an account other than the one the device announced' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'could not adopt')
+      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
+      // dos quedan en la misma versión.
+      const mia = (await identity.profileActa?.())?.acta || acta
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      pend.state = 'DONE'
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
+      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+    } catch (e) {
+      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      reply(pend.from, { type: MSG_ERROR, error: 'the vault could not adopt the account: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   function reject (deviceId) {
     const pend = deviceId
       ? findPending(deviceId)
       : [...pending.values()].find((p) => p.state === 'PENDING_CONFIRM')
     if (!pend) return { ok: false }
-    reply(pend.from, { type: MSG_ERROR, error: 'emparejamiento rechazado' })
+    reply(pend.from, { type: MSG_ERROR, error: 'pairing rejected' })
     pending.delete(pend.token)
     audit('reject', { device: pend.deviceId })
     fire(onPendingChange)
@@ -270,7 +428,7 @@ export function createEnrollDesk ({
     const body = { op: 'revoke', sub: dpub, nonce, iat: Date.now(), exp: Date.now() + DEVICE_TTL_MS }
     const { signature } = await identity.signData(body)
     try { sendByPubkey(dpub, { type: MSG_REVOKED, body, signature }) }
-    catch (e) { log('[vault] no se pudo emitir revoke:', e.message) }
+    catch (e) { log('[vault] could not emit revoke:', e.message) }
   }
 
   /** Revoca una delegación por `nonce` y avisa al dispositivo para que se autoborre. */
@@ -284,7 +442,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, handleHello, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/vault/vendor/vault/index.js

@@ -27,16 +27,13 @@
  */
 import { verifyChain } from '@dotrino/identity/capabilities'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
+// Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
+// local se queda corta, el dispositivo deja de atender mensajes sin que nadie lo note.
+import { MSG, SCOPE } from './protocol.js'
 
-const SIGN_SCOPE = 'vault:sign'
+const SIGN_SCOPE = SCOPE.SIGN
 const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
-
-const MSG = {
-  ENROLL: 'vault.enroll',
-  DEVICES: 'vault.devices',
-  DEVICES_RESULT: 'vault.devices.result',
-  ERROR: 'vault.error'
-}
+const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
 
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
 export { deviceIdOf }
@@ -49,10 +46,11 @@ export { deviceIdOf }
  *   `me.publickey`, `signData`, `signDelegation`, `listDelegations`, `revokeDelegation`.
  * @param {object} [opts]
  * @param {string} [opts.proxyUrl='wss://proxy.dotrino.com']
- * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, approve, reject,
- *   listPending, listMachines, revoke, getSelfCert, onPendingChange, close }
+ * @returns {Promise<object>} handle: { iss, proxy, client, startPairing, stopPairing,
+ *   approve, reject, listPending, listMachines, revoke, getSelfCert, onPendingChange,
+ *   onAdopted, close }
  */
-export async function startDeviceVault (identity, { proxyUrl } = {}) {
+export async function startDeviceVault (identity, { proxyUrl, client: injectedClient } = {}) {
   const iss = identity.me?.publickey
   if (!iss) throw new Error('sin identidad: crea/desbloquea tu identidad antes de usar el dispositivo como bóveda')
   const proxy = proxyUrl || 'wss://proxy.dotrino.com'
@@ -67,12 +65,17 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     return cert
   }
 
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({
-    url: proxy, enableWebRTC: false, autoReconnect: true,
-    maxReconnectAttempts: 100000, reconnectDelay: 4000
-  })
-  await client.connect()
+  // `client` inyectado: solo para las pruebas (transporte de mentira). En producción se
+  // levanta el del ecosistema — no hay otro transporte.
+  const client = injectedClient || await (async () => {
+    const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+    const c = new WebSocketProxyClient({
+      url: proxy, enableWebRTC: false, autoReconnect: true,
+      maxReconnectAttempts: 100000, reconnectDelay: 4000
+    })
+    await c.connect()
+    return c
+  })()
 
   const selfCert = await getSelfCert()
   const identify = async () => {
@@ -87,6 +90,7 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
   const send = (to, obj) => { try { client.send(to, obj) } catch (_) {} }
 
   let _onPendingChange = () => {}
+  let _onAdopted = () => {}
 
   // ENROLL / aprobación / revocación: núcleo COMPARTIDO con el daemon del PC y con la
   // copia vendorizada del iframe (`lib/src/enroll.js`). Un solo sitio donde vive el
@@ -99,9 +103,49 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     sendByPubkey: (pub, obj) => { try { client.sendByPubkey(pub, obj) } catch (_) {} },
     defaultScope: [SIGN_SCOPE],
     defaultTtlMs: DEVICE_TTL_MS,
+    // Camino A (la cuenta del aparato pasa a vivir aquí): sin la llave de cifrado, esta
+    // bóveda entraría mandando una cuenta cuyo contenido no puede abrir.
+    encPub: identity.me?.encryptionPubkey || null,
+    vaultLabel: 'bóveda',
+    // Cita del proxio para la invitación corta (QR). Si el proxio es viejo y no las
+    // conoce, el desk se cae solo a la invitación larga.
+    connToken: async () => {
+      try { return (await client.requestPairingCode())?.code || null }
+      catch (_) { return null }
+    },
+    onAdopted: (info) => { try { _onAdopted(info) } catch (_) {} },
     onPendingChange: () => _onPendingChange()
   })
 
+  /** Nonces revocados, para que un cert revocado no pase ningún `verifyChain`. */
+  async function revocationSet () {
+    const { revoked } = await identity.listDelegations()
+    return new Set((revoked || []).map((r) => r.nonce || r))
+  }
+
+  /**
+   * RENOVACIÓN automática (igual que `dotrino-vault#handleRenew`): un dispositivo con
+   * cert VIGENTE y no revocado pide uno fresco —misma sub-clave y scope— sin QR ni
+   * aprobación: sigue siendo el mismo dispositivo, solo extiende la ventana. Un cert
+   * vencido o revocado NO se renueva (ahí toca re-emparejar con aprobación).
+   *
+   * Sin esto, toda máquina enrolada contra un dispositivo-bóveda caduca a los 30 días.
+   */
+  async function handleRenew (from, p) {
+    const d = p?.data
+    if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'petición inválida' })
+    if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
+      return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
+    }
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss, revoked: await revocationSet() })
+    if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+    // Reusar el label del cert original (si sigue registrado en delegations).
+    const { issued } = await identity.listDelegations()
+    const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
+    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
+    send(from, { type: MSG.RENEWED, cert })
+  }
+
   // Consulta de revocaciones (igual que `vault.devices` del daemon): responde la lista
   // de dispositivos enrolados + revocados para que el dispositivo refresque su set. Y si
   // QUIEN consulta es una máquina ya revocada (reapareció), le re-emite el REVOKED firmado.
@@ -124,7 +168,12 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
 
   client.on('message', (_from, p) => {
     if (!p || typeof p !== 'object') return
-    if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    // El QR corto no lleva la llave: el aparato la pide con un HELLO presentando el `sn`.
+    if (p.type === MSG.HELLO) Promise.resolve(desk.handleHello(_from, p)).catch(() => {})
+    else if (p.type === MSG.ENROLL) desk.handleEnroll(_from, p).catch(() => {})
+    // Camino A: el aparato devuelve su acta sellada admitiendo a esta bóveda.
+    else if (p.type === MSG.ACTA_SEALED) Promise.resolve(desk.handleActaSealed(_from, p)).catch(() => {})
+    else if (p.type === MSG.RENEW) handleRenew(_from, p).catch(() => {})
     else if (p.type === MSG.DEVICES) handleDevices(_from, p).catch(() => {})
   })
 
@@ -148,6 +197,7 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
   return {
     iss, proxy, client,
     startPairing: desk.startPairing,
+    stopPairing: desk.stopPairing,
     // Aprueba TIPEANDO el código que muestra la máquina: el núcleo compartido recompone
     // el compromiso `SHA-256(code‖dpub‖sn)` y solo firma el cert si coincide.
     approve: (deviceId, code) => desk.approve(code, { deviceId }),
@@ -159,6 +209,8 @@ export async function startDeviceVault (identity, { proxyUrl } = {}) {
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },
+    /** Camino A: la cuenta del aparato quedó adoptada por esta bóveda. */
+    onAdopted (fn) { _onAdopted = fn || (() => {}) },
     close () { try { client.close() } catch (_) {} }
   }
 }

package/vault/vendor/vault/protocol.js

@@ -0,0 +1,93 @@
+/**
+ * Protocolo de mensajes entre un dispositivo y el vault (viajan por el proxy,
+ * direccionados por pubkey con `sendByPubkey`). El cuerpo va JSON-serializado en
+ * el campo `message` del sobre del proxy; el cliente lo entrega ya parseado.
+ *
+ * Emparejamiento ENDURECIDO (ver dotrino-vault/docs/pairing-protocol.md):
+ *   1. dispositivo → vault   ENROLL { data:{op,dpub,token,sn,label,ts}, signature }
+ *      (la firma es del dispositivo con su llave D = PRUEBA DE POSESION; un token
+ *       robado ya NO basta para enrolar).
+ *   2. vault → dispositivo   ENROLL_CHALLENGE { deviceId, sas }   (aun NO firma cert)
+ *   3. el dueño compara el SAS (pantalla del dispositivo ↔ del PC) y APRUEBA en el PC
+ *   4. vault → dispositivo   ENROLLED { cert, iss, sas }   (recien aqui firma el cert)
+ *   5. el dispositivo VALIDA la cadena: cert.iss === el iss que vio, cert.sub === D.
+ *
+ * Revocacion (robo): el vault envia REVOKED { body, signature } FIRMADO por la
+ * maestra → el dispositivo se autoborra SOLO si la firma valida contra la maestra
+ * pineada (cierra el wipe-DoS; un ERROR plano jamas borra).
+ */
+export const MSG = Object.freeze({
+  // La invitación corta no lleva la llave: el aparato la pide presentando el `sn` de
+  // la sesión. Una pública es pública — esto no la esconde, solo evita abrirle la
+  // puerta a quien acertó el token de conexión a ciegas.
+  HELLO: 'vault.hello',                       // dispositivo → vault: { sn }
+  HELLO_OK: 'vault.hello.ok',                 // vault → dispositivo: { iss, acct }
+  ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
+  ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
+  ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
+  REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
+  SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
+  SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }
+  GET: 'vault.get',                           // dispositivo → vault: { data, signature, cert }
+  DATA: 'vault.data',                         // vault → dispositivo: { id, node }
+  STORE: 'vault.store',                       // dispositivo → vault: { data:{method,args,publickey,ts}, signature, cert }
+  STORE_RESULT: 'vault.store.result',         // vault → dispositivo: { method, result }
+  DEVICES: 'vault.devices',                   // dispositivo → vault: { data:{publickey,ts}, signature, cert }
+  DEVICES_RESULT: 'vault.devices.result',     // vault → dispositivo: { devices, revoked }
+  RENEW: 'vault.renew',                       // dispositivo → vault: { data:{op,publickey,ts}, signature, cert }
+  RENEWED: 'vault.renewed',                   // vault → dispositivo: { cert }  (cert fresco, misma sub-clave/scope)
+  SECRETS: 'vault.secrets',                   // servicio → vault: { data:{op,ns,ek,publickey,ts}, signature, cert }
+  SECRETS_RESULT: 'vault.secrets.result',     // vault → servicio: { body:{op,ns,enc,ts}, signature } (enc SELLADO a ek; body firmado por la maestra)
+  // AVISO DE CAMBIO (no lleva valores): la bóveda dice «la configuración del ns
+  // cambió». El agente no la recarga en caliente — SALE limpio y su supervisor lo
+  // levanta. Dos razones, y la segunda es la de peso:
+  //   · Lee todo fresco. Recargar en caliente exige que cada sitio que leyó una
+  //     variable sepa releerla, y esa lista hay que mantenerla para siempre.
+  //   · BORRA DE MEMORIA EL VALOR VIEJO. En JavaScript un secreto no se puede
+  //     borrar: los strings son inmutables, no hay zeroize, y el valor queda en el
+  //     heap hasta que al recolector le apetezca — más lo que capturó cada closure
+  //     y cada caché derivada. Una llave se rota casi siempre PORQUE SE FILTRÓ, así
+  //     que dejarla viva en el proceso anula la razón de rotarla. Un proceso nuevo
+  //     empieza con el heap limpio.
+  // Va FIRMADO por la maestra y el agente lo verifica contra su `iss` pineada: un
+  // aviso de reinicio sin autenticar ES un ataque de denegación.
+  SECRETS_CHANGED: 'vault.secrets.changed',   // vault → servicio: { body:{op,ns,ts}, signature }
+  // --- CONSOLA REMOTA (docs/consola-remota.md) — requiere cert `vault:admin` ---
+  // Un solo mensaje con `data.op`: pending · pair · approve · reject · revoke · audit.
+  // Admitir y expulsar, nada más: cambiar permisos, traspasar el mando y los secretos
+  // NO se exponen aquí, y no es un olvido — es el límite (§2 del diseño).
+  ADMIN: 'vault.admin',                       // admin → vault: { data:{op,…,ts,nonce}, signature, cert }
+  ADMIN_RESULT: 'vault.admin.result',         // vault → admin: { op, result }
+  // Aviso a TODOS los miembros de que el perfil cambió (alguien entró o salió). Es la
+  // contrapartida de administrar a distancia: sin esto, un enrolamiento remoto sería
+  // invisible para el resto de tus dispositivos.
+  ADMIN_EVENT: 'vault.admin.event',           // vault → todos: { body:{ev,deviceId,by,ts}, signature }
+  ERROR: 'vault.error'                        // vault → dispositivo: { error }
+})
+
+/** Capacidades que puede llevar un `cert` (scope). Mínimo por defecto. */
+export const SCOPE = Object.freeze({
+  SIGN: 'vault:sign',   // pedir a la maestra que firme datos (identidad)
+  READ: 'vault:read',   // leer nodos del árbol de contenidos
+  STORE: 'vault:store', // leer/escribir el store de hilos + aperturas del usuario
+  // Consola remota (docs/consola-remota.md): admitir y expulsar miembros a distancia.
+  // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
+  // de master y sigue siendo local. No se empareja — se concede desde el PC.
+  ADMIN: 'vault:admin'
+})
+
+/**
+ * Scope de SECRETOS por namespace de servicio: un cert con `vault:secrets:proxy`
+ * solo puede leer los secretos del ns `proxy` — un VPS comprometido no puede
+ * pedir los de otro servicio. ns válido: [a-z0-9-]{1,32}.
+ */
+export const SECRETS_SCOPE_PREFIX = 'vault:secrets:'
+export const secretsScope = (ns) => SECRETS_SCOPE_PREFIX + ns
+export const isValidSecretsNs = (ns) => typeof ns === 'string' && /^[a-z0-9-]{1,32}$/.test(ns)