@dotrino/vaultd 0.53.0 → 0.56.0

package/src/profiles.js

@@ -24,7 +24,9 @@ import fs from 'node:fs'
 import crypto2 from 'node:crypto'
 import path from 'node:path'
 import { dataDir, ensureDir, readJson, writeJson } from './paths.js'
-import { atRestFor, migrateFile, machineKey } from './atrest.js'
+import { atRestFor, migrateFile, kekFor } from './atrest.js'
+import { probe as probeKek, writeConfig as writeKekConfig, configFromEnv } from './atrest.js'
+import { keyDirName, keyOwnerOf } from './keyowner.js'
 
 const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // PBKDF2 del verificador v1 (heredado); v2 usa scrypt
@@ -107,7 +109,16 @@ async function derivePwd (password, saltB64, iter) {
   return b64(bits)
 }
 
-const newId = () => 'p' + crypto.randomUUID().slice(0, 8)
+/**
+ * El nombre de la carpeta DE PASO, la que existe solo mientras se acuña la llave.
+ *
+ * La llave se genera antes de escribirse (`crypto.subtle.generateKey` y luego el kv), pero
+ * la única API que tenemos —`Identity.connect({ dir })`— recibe la carpeta por delante y
+ * hace las dos cosas de un tirón: no hay costura donde meterse a preguntar la huella. Así
+ * que se acuña aquí y en cuanto se sabe de quién es, la carpeta se MUEVE a su nombre.
+ * El punto delante la deja fuera de la lista de perfiles si algo se corta a medias.
+ */
+const stagingName = () => '.new-' + crypto.randomUUID().slice(0, 8)
 const cleanName = (name) => String(name || '').slice(0, MAX_NAME)
 
 /**
@@ -125,7 +136,22 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
   // respaldo o en una carpeta compartida por descuido, que es lo que el códec cubre
   // para el resto. La migración verifica antes de reemplazar y es de una sola vez.
   ensureDir(root)
-  try { migrateFile(file, machineKey(root)) } catch (_) {}
+  // LA RAÍZ TAMBIÉN NECESITA EL PROVEEDOR DEL ENTORNO, y esto lo destapó un contenedor:
+  // los perfiles nacían con la clave en el KMS, pero el REGISTRO de perfiles seguía con
+  // la de la máquina — así que al recrear el contenedor la bóveda no arrancaba igual,
+  // solo que fallando un paso antes. No guarda el contenido de ningún perfil (la lista y
+  // el verificador del candado), pero sin él no hay bóveda.
+  //
+  // Solo si está por estrenar: si el registro ya existe cifrado con la clave de antes,
+  // cambiarle el proveedor lo dejaría ilegible. Ahí se migra con `atrest rekey`.
+  if (!fs.existsSync(path.join(root, 'atrest.json'))) {
+    const kek = configFromEnv()
+    if (kek && !fs.existsSync(file)) {
+      probeKek(root, kek)
+      writeKekConfig(root, kek)
+    }
+  }
+  try { migrateFile(file, kekFor(root)) } catch (_) {}
   const atRest = atRestFor(root)
   let data = readJson(file, null, atRest)
   if (!data || !Array.isArray(data.profiles)) data = { v: 1, current: null, profiles: [] }
@@ -192,6 +218,13 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
       const hits = data.profiles.filter((p) => (p.name || '').toLowerCase() === needle)
       if (hits.length === 1) return hits[0].id
       if (hits.length > 1) throw new Error(`there are ${hits.length} profiles named "${ref}"; use its id (dotrino-vault profile ls)`)
+      // POR PREFIJO. Desde que el id del perfil es el nombre de su carpeta —y ese sale de
+      // la llave— es largo, y nadie va a teclear 24 caracteres para decir `--profile`. El
+      // trozo que sí se lee y se reconoce es la huella de delante (`0571-465F`), que es la
+      // misma que sale en `members`. Ambiguo se rechaza, no se adivina.
+      const porPrefijo = data.profiles.filter((p) => p.id.toLowerCase().startsWith(needle))
+      if (porPrefijo.length === 1) return porPrefijo[0].id
+      if (porPrefijo.length > 1) throw new Error(`"${ref}" matches ${porPrefijo.length} profiles; give more of the id (dotrino-vault profile ls)`)
       throw new Error('profile does not exist: ' + ref)
     },
 
@@ -201,12 +234,18 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
      * navegador, que adopta la identidad vieja como «Perfil 1»). `transport.json`
      * se queda en la raíz: es del proceso, no de la identidad.
      */
-    migrate () {
+    async migrate (mintKey) {
       if (data.profiles.length) return null
       const legacy = fs.existsSync(path.join(root, 'identity.json'))
-      const id = newId()
-      const dir = dirOf(id)
-      ensureDir(dir)
+      // EL PROVEEDOR DEL ENTORNO, y SOLO en una instalación nueva. Es lo que hace que un
+      // contenedor levantado con `DOTRINO_KMS_KEY_ID` tenga su primer perfil ya con la
+      // clave en el KMS, sin entrar a configurar nada.
+      //
+      // En una MIGRACIÓN no se toca, y el matiz importa: esos archivos ya están cifrados
+      // con la clave de la máquina, así que ponerles ahora un proveedor distinto los
+      // dejaría ilegibles —el guardia lo pararía, pero el usuario se quedaría con una
+      // bóveda que no arranca tras actualizar—. Ahí se migra con `atrest rekey`, a la vista.
+      const dir = api.stage({ fromEnv: !legacy })
       if (legacy) {
         for (const f of LEGACY_FILES) {
           const from = path.join(root, f)
@@ -217,12 +256,23 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
           if (/^peers\..+\.json$/.test(f)) { try { fs.renameSync(path.join(root, f), path.join(dir, f)) } catch (_) {} }
         }
       }
-      // «Perfil 1» tanto al migrar como en una instalación nueva: es un nombre que
-      // el dueño puede cambiar, y evita que la CLI salude con «(sin nombre)».
-      data.profiles.push({ id, name: 'Perfil 1', createdAt: Date.now() })
-      data.current = id
-      save()
-      return { id, migrated: legacy }
+      try {
+        // Al migrar, la llave ya existe y esto solo la lee; en una instalación nueva, la crea.
+        const pub = await mintKey(dir)
+        // «Perfil 1» tanto al migrar como en una instalación nueva: es un nombre que
+        // el dueño puede cambiar, y evita que la CLI salude con «(sin nombre)».
+        const p = await api.commit(dir, 'Perfil 1', { pub })
+        data.current = p.id
+        save()
+        return { id: p.id, migrated: legacy }
+      } catch (e) {
+        // En una instalación NUEVA no hay nada que perder y la carpeta de paso se va. En
+        // una MIGRACIÓN sí lo hay —los archivos del dueño ya están dentro—, así que se
+        // queda donde está y se dice en voz alta: borrarla sería borrar su bóveda.
+        if (!legacy) { try { fs.rmSync(dir, { recursive: true, force: true }) } catch (_) {} }
+        else e.message += ` (your data is safe in ${dir}; it could not be given its final name)`
+        throw e
+      }
     },
 
     /**
@@ -233,15 +283,110 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
      * leería como pisar una cuenta con datos y se rechazaría, que es lo que tiene que
      * pasar cuando nadie lo pidió.
      */
-    add (name, { adopt = false } = {}) {
-      const id = newId()
-      ensureDir(dirOf(id))
+    /**
+     * `kek`: el proveedor de la clave del disco, si el perfil tiene que NACER con él.
+     *
+     * Se escribe aquí y no después porque ese es justo el momento que importa: el
+     * directorio existe y todavía no hay un solo byte dentro. La maestra que genere
+     * `open()` un instante más tarde ya nace bajo esa clave y NUNCA existe bajo otra.
+     *
+     * Migrar un perfil que ya tiene identidad NO da esto, y por eso no se ofrece como
+     * si lo diera: su maestra ya se escribió bajo la clave vieja, y una copia del disco
+     * anterior a la migración la sigue abriendo para siempre. Un perfil con raíz en el
+     * KMS **nace** así (dueño, 2026-08-30).
+     */
+    stage ({ kek = null, fromEnv = true } = {}) {
+      const dir = path.join(root, 'p', stagingName())
+      ensureDir(dir)
+      // Sin `--kms` explícito, manda el entorno: es lo que permite levantar un contenedor
+      // con KMS pasando variables, sin entrar a escribir un JSON dentro. Solo al CREAR:
+      // un perfil que ya existe manda con su `atrest.json`.
+      kek = kek || (fromEnv ? configFromEnv() : null)
+      if (kek) {
+        // Comprobar ANTES de dejar rastro: un KMS que no responde no puede dejar a
+        // medio crear un perfil cuya maestra no se va a poder volver a abrir.
+        try {
+          probeKek(dir, kek)
+          writeKekConfig(dir, kek)
+        } catch (e) {
+          try { fs.rmSync(dir, { recursive: true, force: true }) } catch (_) {}
+          throw e
+        }
+      }
+      return dir
+    },
+
+    /**
+     * La carpeta de paso ya tiene su llave: se le pone SU nombre y entra en el registro.
+     * El `id` del perfil ES el nombre de su carpeta, y sale de la llave (`keyDirName`).
+     */
+    async commit (staging, name, { adopt = false, pub } = {}) {
+      if (!pub) throw new Error('cannot name the folder: the key is missing')
+      const id = await keyDirName(pub)
+      const dest = dirOf(id)
+      // Esa llave ya tiene carpeta. No es un choque de nombres: es la MISMA llave dos
+      // veces, que es justo lo que este esquema existe para que no pase.
+      if (fs.existsSync(dest)) {
+        try { fs.rmSync(staging, { recursive: true, force: true }) } catch (_) {}
+        throw Object.assign(new Error('that key already has a folder here: ' + id), { code: 'key-exists' })
+      }
+      fs.renameSync(staging, dest)
       data.profiles.push({ id, name: cleanName(name), createdAt: Date.now(), ...(adopt ? { adopt: true } : {}) })
       if (!data.current) data.current = id
       save()
       return entry(find(id))
     },
 
+    /**
+     * Crea un perfil entero: hace el sitio, deja que `mintKey` acuñe la llave dentro y
+     * mueve la carpeta a su nombre. `mintKey(dir)` devuelve la pública, y es cosa de quien
+     * llama porque generar una identidad no es asunto del registro.
+     */
+    async add (name, { adopt = false, kek = null, mintKey } = {}) {
+      if (typeof mintKey !== 'function') throw new Error('add() needs mintKey to know whose folder it is')
+      const staging = api.stage({ kek })
+      try {
+        const pub = await mintKey(staging)
+        return await api.commit(staging, name, { adopt, pub })
+      } catch (e) {
+        // Nada a medias: la carpeta de paso se va con el intento fallido.
+        try { fs.rmSync(staging, { recursive: true, force: true }) } catch (_) {}
+        throw e
+      }
+    },
+
+    /**
+     * PONERLE A UNA CARPETA VIEJA EL NOMBRE DE SU LLAVE.
+     *
+     * Es toda la migración: mover la data a la carpeta que le toca. Se hace con la
+     * identidad CERRADA —antes de abrirla—, porque la identidad se queda con la ruta como
+     * texto y renombrar por debajo la deja escribiendo en una carpeta que ya no existe.
+     *
+     * De quién es la carpeta se sabe por la marca (`key.json`); si no la tiene —una
+     * instalación anterior a que existiera— se abre un momento solo para preguntárselo.
+     */
+    async ensureNamedByKey (id, mintKey) {
+      const dir = dirOf(id)
+      if (!fs.existsSync(dir)) return id
+      let pub = keyOwnerOf(dir)
+      if (!pub && typeof mintKey === 'function') {
+        try { pub = await mintKey(dir) } catch (_) { return id }
+      }
+      if (!pub) return id
+      const quiere = await keyDirName(pub)
+      if (quiere === id) return id
+      if (fs.existsSync(dirOf(quiere))) {
+        throw Object.assign(new Error(`cannot rename ${id}: ${quiere} already exists`), { code: 'key-exists' })
+      }
+      fs.renameSync(dir, dirOf(quiere))
+      const p = find(id)
+      if (p) p.id = quiere
+      if (data.current === id) data.current = quiere
+      if (unlocked.has(id)) { unlocked.set(quiere, unlocked.get(id)); unlocked.delete(id) }
+      save()
+      return quiere
+    },
+
     /** Quita la marca de «nació para adoptar» (ya adoptó, o se canceló). */
     clearAdopt (id) {
       const p = find(id)

package/src/vault.js

@@ -19,15 +19,20 @@ import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.j
 import { createAdminDesk } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
 import { createTransport, masterPubkeyOf } from './transport.js'
+import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar } from './secretsStore.js'
-import { createApprovals } from './approvals.js'
+// `PENDING_TTL_MS` se usa abajo, al esperar la firma del aprobador: sin importarlo, esa
+// espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
+// llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
+// que lo recorriera hasta que la hubo (dotrino-test, smoke:demonio, 2026-08-30).
+import { createApprovals, PENDING_TTL_MS } from './approvals.js'
 import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { seal } from '../lib/src/sealed.js'
 import { dataDir, ensureDir } from './paths.js'
-import { atRestFor, machineKey, migrateFile } from './atrest.js'
+import { atRestFor, kekFor, migrateFile } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
 
 /**
@@ -56,10 +61,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // máquina (puede leer el mismo material); es subir el listón, no una imposibilidad.
   // La migración verifica antes de reemplazar: si algo falla, el original queda intacto.
   try {
-    const r = migrateFile(path.join(dir, 'identity.json'), machineKey(dir))
+    const r = migrateFile(path.join(dir, 'identity.json'), kekFor(dir))
     if (r === 'migrado') log('[vault] identity encrypted at rest (bound to this machine)')
   } catch (e) { log('[vault] could not encrypt the identity at rest:', e.message) }
   const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
+  // ESTE DIRECTORIO ES DE ESTA LLAVE. Es lo único que hay que proteger cuando varias
+  // bóvedas viven en un mismo disco: cada una con el suyo, para que nunca se mezclen.
+  assertKeyOwnsDir(dir, identity.me?.publickey || null)
   if (!identity.me?.publickey) await identity.setMyNickname('')
   // CAMINO A: este perfil nació para adoptar la cuenta de un aparato. La identidad se crea
   // igual (su llave es la que entrará como miembro), pero se marca para que `joinProfile`
@@ -168,7 +176,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     recipients: (owner) => recipientsOf(owner),
     // La FIRMA del sobre: dice que salió de esta bóveda y con qué acta (§8.8).
     signer: (body) => signSeal(body),
-    defaultKey: () => new Uint8Array(machineKey(dir))
+    defaultKey: () => new Uint8Array(kekFor(dir))
   })
   // SIN CONTRASEÑA NO HAY SECRETO. Escribir no la pide (sellar solo necesita públicas,
   // §8.1), pero la copia de recuperación —la que deja al dueño VER sus valores— se cierra
@@ -629,8 +637,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('secrets.pending', { device: deviceId, ns, id: pend.id })
       log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
       const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
-      const { signature } = await identity.signData(body)
-      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+      // El acta viaja también aquí: es con lo que el agente sabe qué llave podía firmar
+      // esto. En `secrets.result` va dentro del sobre; en un «pendiente» no hay sobre.
+      reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record || null })
       await notifyApprovers(pend, record)
       return
     }
@@ -654,13 +663,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `seq` con el que se firmaron—. No es un dato secreto: el acta es pública dentro
     // del perfil y el agente ya es miembro. Sin ella podría abrir igual, pero no sabría
     // de dónde salió lo que abre.
+    // El acta va en LOS DOS caminos, también en el v3 heredado: ya no sirve solo para
+    // decir de dónde salieron los sobres, sino para saber qué llave podía firmar esta
+    // respuesta. Sin ella el agente no puede comprobar quién le contestó.
     const payload = b.legacy
-      ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])) }
+      ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])), acta: record || null }
       : { sealed: b, acta: record || null }
     const enc = await seal({ ek, payload })
     const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
-    const { signature } = await identity.signData(body)
-    return { body, signature }
+    // LA MAESTRA NO FIRMA ESTO. Su trabajo es sellar el acta y reenvolver sobres; servir
+    // no es suyo. Quien firma es la LLAVE DE SELLADO que el acta nombra (`sealPub`), la
+    // misma que ya firma cada sobre — y por eso esto se puede servir con el perfil
+    // bloqueado, y algún día desde una réplica que no tiene la maestra ni debe tenerla.
+    return { body, seal: await sealOrFail(body) }
+  }
+
+  /**
+   * Firma con la llave de sellado, o revienta. No hay repliegue a la maestra: si el acta
+   * no nombra una llave de sellado que sea nuestra, esta bóveda no está en condiciones de
+   * servir, y decirlo es mejor que servir firmado por quien no toca.
+   */
+  async function sealOrFail (body) {
+    const s = await signSeal(body)
+    if (!s) throw new Error('this vault has no sealing key named by the record: it cannot serve')
+    return s
   }
 
   /**
@@ -684,8 +710,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const by = await deviceIdOf(chk.device).catch(() => null)
     const answer = async (body) => {
       body = { ...body, ts: Date.now() }
-      const { signature } = await identity.signData(body)
-      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+      reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body) })
     }
     if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
     const id = typeof p.data?.id === 'string' ? p.data.id : ''
@@ -748,11 +773,34 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.REWRAP_OK) return await handleRewrapOk(payload)
       if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
       if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
+      if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
   })
 
+  /**
+   * AVISO DE OTRA BÓVEDA de la misma cuenta (multivault). Trae el acta nueva y aquí se
+   * ADOPTA, que es lo que hace que conceder un permiso surta efecto en la otra máquina en
+   * vez de esperar a que renueve su cert.
+   *
+   * No se comprueba quién lo manda y no hace falta: `adoptActa` aplica §2.4.1 —firma,
+   * encadenado, `seq` que no baja y desempate— así que un acta ajena o vieja se rechaza
+   * sola. Fiarse del remitente sería la comprobación débil; fiarse del acta es la fuerte.
+   */
+  async function handleAdminEvent (payload) {
+    const acta = payload?.acta
+    if (!acta || typeof acta !== 'object') return
+    try {
+      const r = await identity.adoptActa?.(acta)
+      if (r?.adopted) log(`[vault] adopted record #${acta.seq} announced by another vault (${r.reason})`)
+      // Y el RECHAZO también se dice. Callarlo dejaría el peor fallo de todos: se concede
+      // un permiso en una máquina, la otra no se entera, y no hay una sola línea que lo
+      // explique — que es exactamente lo que costó encontrar esto.
+      else log(`[vault] IGNORED the record #${acta.seq} announced by another vault: ${r?.reason || 'no reason given'}`)
+    } catch (e) { log('[vault] could not adopt the announced record:', e.message) }
+  }
+
   // ----- LA BÓVEDA DE CONTRASEÑAS -----
   //
   // Se monta al final y envuelto: es una pieza opcional y un fallo suyo no puede tumbar
@@ -961,17 +1009,45 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     try {
       const body = { ev, ...info, ts: Date.now() }
       const { signature } = await identity.signData(body)
+      // EL ACTA VIAJA CON EL AVISO. Sin esto, un miembro se enteraba de que «algo cambió»
+      // pero no de QUÉ, y no veía el acta nueva hasta renovar su cert — hasta 30 días.
+      // Para un aparato eso era lento; para OTRA BÓVEDA es fatal: se le concede `sella` y
+      // no puede sellar, porque su copia del acta no lo dice todavía.
+      // No es un dato secreto (es pública dentro del perfil y estos son sus miembros), y
+      // quien la recibe la adopta por las reglas de §2.4.1, así que una vieja o ajena no
+      // hace daño: se rechaza sola.
+      const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
       const { issued } = await identity.listDelegations()
+      // A QUIÉN SE AVISA: a los MIEMBROS DEL ACTA, no solo a quien esta bóveda enroló.
+      //
+      // Esto avisaba únicamente por `issued` —las delegaciones que emitió esta bóveda—, y
+      // eso deja fuera exactamente el caso del multivault: la segunda bóveda entró por
+      // `join`, así que la delegación la emitió la PRIMERA. Cuando la segunda sellaba un
+      // acta nueva (admitir un aparato con su permiso `sella`), su lista de emitidas no
+      // tenía a la primera dentro y el cambio no llegaba a ninguna parte: las dos bóvedas
+      // quedaban con actas distintas y la del dueño sin enterarse de nada.
+      //
+      // El acta es la lista de quién es del perfil: esa es la lista correcta. `issued` se
+      // suma porque cubre a quien tiene cert y todavía no aparece ahí.
+      const miembros = (await identity.profileMembers?.().catch(() => null))?.members || []
+      const yo = identity.me?.publickey || null
       // UNO POR LLAVE, no uno por delegación: renovar emite una delegación nueva para la
       // MISMA sub-clave, así que un aparato que lleve tiempo enrolado aparece varias veces
       // y recibía el mismo aviso repetido —una vez por renovación acumulada—. Mismo
       // cuidado que en `notifyNsChange`.
       const seen = new Set()
-      for (const d of issued || []) {
-        if (!d.sub || seen.has(d.sub)) continue
-        seen.add(d.sub)
-        try { client.sendByPubkey(d.sub, { type: MSG.ADMIN_EVENT, body, signature }) } catch (_) {}
+      const avisar = (pub) => {
+        if (!pub || pub === yo || seen.has(pub)) return
+        seen.add(pub)
+        // El fallo NO se traga. Que un aviso no salga es exactamente lo que deja a dos
+        // bóvedas con actas distintas sin que nadie se entere, y encontrarlo sin una línea
+        // de log cuesta días (la última vez, tres).
+        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature, acta }) }
+        catch (e) { log(`[vault] could not notify ${pub.slice(0, 24)}… of "${ev}": ${e.message}`) }
       }
+      for (const m of miembros) avisar(m.pub)
+      for (const d of issued || []) avisar(d.sub)
+      log(`[vault] notified ${seen.size} member(s) of "${ev}" (record #${acta?.seq ?? '?'})`)
     } catch (e) { log('[vault] could not notify members of the change:', e.message) }
   }
 
@@ -1150,7 +1226,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * pero NO es equivalente, y por eso la consola lo dice en voz alta (§2.3 del
    * diseño). Prometer una protección que no está puesta es peor que no tenerla.
    */
-  const adminKeyOr = (adminKey) => adminKey || new Uint8Array(machineKey(dir))
+  const adminKeyOr = (adminKey) => adminKey || new Uint8Array(kekFor(dir))
 
   // `adminKey` es la llave derivada de la contraseña del perfil, y va POR OPERACIÓN: se
   // usa para sellar y se suelta. Solo hace falta para escribir una privada — servir,
@@ -1231,18 +1307,48 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const rewrapWaiters = new Set()
   const onRewrapOk = (fn) => { rewrapWaiters.add(fn); return () => rewrapWaiters.delete(fn) }
 
+  /**
+   * LAS OTRAS BÓVEDAS —los miembros con el permiso `sella`— entran en TODOS los cajones,
+   * también en los que tienen dueño. Decidido por el dueño el 2026-08-30.
+   *
+   * Y no contradice la regla de agosto —«un cajón con dueño no se envuelve para quien
+   * administra»—, porque un cosellador **no es quien administra**: es un master. Aquella
+   * regla saca a los aparatos de consola (un navegador, un portátil con la sesión puesta),
+   * cuyo compromiso es probable y cuya necesidad es comodidad. Una segunda bóveda existe
+   * justamente para poder REGENERAR los sobres el día que la primera no esté, y regenerar
+   * exige abrir: dejarla fuera la haría inútil para el único desastre que viene a cubrir.
+   *
+   * El precio, que se dice y no se esconde: a partir de aquí son DOS los discos cuya
+   * captura abre ese cajón. Eso es exactamente lo que cuesta sobrevivir a perder uno.
+   */
+  async function cosealerMembers () {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (!record) return []
+    // Sin `encPub` no hay a dónde envolver: se queda en deuda y se ve como `sinLlave`,
+    // igual que cualquier otro miembro incompleto.
+    return (record.members || []).filter((m) =>
+      m.pub !== master && m.encPub && Acta.memberCan(record, m.pub, 'sealer'))
+  }
+
+  /** Sin duplicar: un cosellador puede ser además el dueño del cajón. */
+  const conCoselladores = (base, co) => {
+    const vistos = new Set(base.map((m) => m.pub))
+    return [...base, ...co.filter((m) => !vistos.has(m.pub))]
+  }
+
   async function recipientsOf (owner) {
+    const co = await cosealerMembers()
     if (owner.startsWith('ns:')) {
       const owned = await nsMembers(owner.slice(3))
       // Sin dueño (un cajón personal, o uno cuyo servicio ya no está) sí entra quien
       // administra: si no, no quedaría nadie que pudiera abrirlo sin la frase.
-      return owned.length ? owned : await adminDevices()
+      return conCoselladores(owned.length ? owned : await adminDevices(), co)
     }
     const pub = owner.slice(owner.indexOf(':') + 1)
     const m = await memberOf(pub)
     // El cajón propio de un aparato de SERVICIO es tan suyo como el de su ns.
-    if (m?.cn) return [m]
-    return [...(m ? [m] : []), ...await adminDevices()]
+    if (m?.cn) return conCoselladores([m], co)
+    return conCoselladores([...(m ? [m] : []), ...await adminDevices()], co)
   }
 
   /**
@@ -1818,6 +1924,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     isMaster: () => identity.isMaster(),
     setCaps: async (pub, caps) => {
       const r = await identity.setCaps(pub, caps)
+      // ¿SE QUEDÓ ALGUNO POR EL CAMINO? El acta tiene una lista CERRADA de permisos y
+      // `cleanCaps` descarta los que no conoce — correcto al recibir un acta ajena, y
+      // pésimo aquí: conceder `+sella` con una versión del pilar que no sabe qué es
+      // devolvía «Listo», resellaba el acta y no concedía nada. Costó una tarde en un
+      // contenedor, porque la imagen traía la versión de npm y el árbol local otra.
+      try {
+        const quedaron = new Set((await identity.profileMembers()).members.find((m) => m.pub === pub)?.caps || [])
+        const perdidos = caps.filter((c) => !quedaron.has(c))
+        if (perdidos.length) {
+          log(`[vault] WARNING these permissions were DROPPED: ${perdidos.join(', ')} — this build's @dotrino/identity does not know them (record unchanged for those)`)
+        }
+      } catch (_) { /* comprobar es un extra: si falla, no rompe el cambio */ }
       audit('caps', { device: await deviceIdOf(pub).catch(() => null), caps })
       await notifyMembers('caps', { deviceId: await deviceIdOf(pub).catch(() => null), caps })
       return r