@dotrino/vaultd 0.38.0 → 0.49.0

package/src/vault.js

@@ -22,6 +22,10 @@ import { createTransport, masterPubkeyOf } from './transport.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'
+import { parsePublicKey, sshSignature } from './sshKeys.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'
@@ -37,7 +41,7 @@ import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
  *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
  *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
  */
-export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, forAdoption = false, onAdopted } = {}) {
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, hasPassword = () => true, deriveAdminKey = null, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
   // CIFRADO EN REPOSO ligado a esta máquina: ningún archivo del dir queda en claro, así
   // que copiarlos a otro equipo no sirve de nada. La identidad se migra AQUÍ (verificando
@@ -59,12 +63,62 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     try { await identity.prepareForAdoption() } catch (e) { log('[vault] could not prepare the profile for adoption:', e.message) }
   }
 
+  // LA LLAVE DE SELLADO (§8.8/§8.9): con ella se FIRMAN los sobres de los secretos. No
+  // abre nada, así que se usa sin la frase; su autoridad se la da el acta, que la nombra
+  // y que sella únicamente la maestra. Se estrena una por acta: aquí está el proveedor.
+  const sealKeys = openSealKeys(dir)
+  identity.setSealKeyProvider?.(() => sealKeys.mint())
+
   const store = openStore(dir)
   const threads = openThreadStore(dir)
-  const secrets = openSecretsStore(dir)
+  const approvals = createApprovals()
+  const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit(g.kind === 'ssh' ? 'ssh.expired' : 'secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId }) }, 30 * 1000); approvalsSweeper.unref?.()
+  const secrets = openSecretsStore(dir, {
+    sealer: makeSealer(),
+    // A QUIÉN se le envuelve la llave de cada cajón: los servicios de ese namespace (o el
+    // propio aparato, si el cajón es suyo) MÁS los aparatos que administran. Sale del
+    // acta, y por eso lo pone el vault: el store no conoce el acta.
+    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))
+  })
+  // 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
+  // con ella. Sin contraseña se cae a la llave de la máquina, que es la protección de
+  // siempre, pero su material vive en este mismo disco: una copia del disco lo abre.
+  // Se dice en voz alta: prometer una protección que no está puesta es peor que no
+  // tenerla (docs/secretos-sellados.md §2.3).
+  try {
+    if (!hasPassword()) {
+      log('[vault] this profile has NO password: private variables are sealed with a key derived from this machine,')
+      log('[vault] so a copy of this disk opens them. Set one with `dotrino-vault profile password`.')
+    }
+  } catch (_) {}
+
   const master = await masterPubkeyOf(identity)
   const fp = (await pubkeyId(master)).slice(0, 16)
 
+  /**
+   * El acta tiene que nombrar una llave de sellado QUE SEA NUESTRA. Si no nombra ninguna
+   * (un acta de antes de esto) o nombra una cuya privada no tenemos (el disco se
+   * restauró, o el acta la selló otro master), se estrena: firmar sobres es de esta
+   * máquina y no puede quedar a medias.
+   *
+   * Solo lo intenta el master —es el único que sella actas— y no bloquea el arranque: sin
+   * llave los sobres salen sin firma, que es lo que ya pasaba antes de §8.8.
+   */
+  try {
+    const info = await identity.profileActa?.()
+    const acta = info?.acta
+    if (info?.isMaster && acta && (!acta.sealPub || !sealKeys.has(acta.sealPub))) {
+      const r = await identity.rotateSealKey()
+      // Sin `%s`: este `log` va con un prefijo por delante, así que el formato no es lo
+      // primero y `console.log` no lo sustituye (salía «record #%s 2»).
+      log(`[vault] new sealing key in record #${r.seq}`)
+    }
+  } catch (e) { log('[vault] could not set up the sealing key:', e.message) }
+
   const { client } = await createTransport({ identity, dir, url: proxyUrl })
 
   async function revocationSet () {
@@ -138,6 +192,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         const n = secrets.forgetDevice(sub)
         if (n) log(`[vault] dropped ${n} variable(s) of the removed device`)
       } catch (e) { log('[vault] could not drop the device variables:', e.message) }
+      // Su cajón propio se va entero y eso es inmediato y completo (estaba sellado solo
+      // a él). Lo que comparte —la CEK de su namespace— hay que ROTARLO, porque quitarle
+      // la envoltura no basta: si guardó la CEK sigue abriendo todo lo cifrado con ella.
+      //
+      // Pero rotar exige la contraseña, y quitar un aparato es el interruptor de
+      // emergencia: el gesto que se hace desde el teléfono cuando se perdió una máquina.
+      // Un interruptor que pide una frase que quizá no tienes a mano no es un
+      // interruptor. Así que se INTENTA, y si no se puede queda anotado y a la vista.
+      markRotationDue(sub).catch((e) => log('[vault] could not rotate after the removal:', e.message))
     },
     defaultScope: [SCOPE.READ],
     onChallenge ({ deviceId, scope }) {
@@ -388,8 +451,46 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // servicio verifica contra su iss pineada — un relay no puede inyectar
   // secretos falsos). Replay inerte: cada petición usa una ek nueva.
   //   data: { op:'secrets', ns, ek, publickey, ts }
+  /**
+   * Un servicio que se enroló antes de que existieran las llaves de cifrado registra la
+   * suya. Es la alternativa a re-enrolarlo: re-enrolar le cambia la pubkey, y su cajón
+   * de variables va indexado por ella — se quedaría sin configuración sin decirlo.
+   */
+  async function handleEncKey (from, p) {
+    const ns = p.data?.ns
+    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'enckey: invalid namespace' })
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: secretsScope(ns), trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'enckey')
+    try {
+      await identity.setMemberEncPub({ pub: chk.device, encPub: p.data.encPub })
+      audit('enckey', { device: await deviceIdOf(chk.device).catch(() => null), ns })
+      log(`[vault] ${ns}: encryption key registered for ${await deviceIdOf(chk.device).catch(() => '????-????')}`)
+      // Ya puede recibir sobres: se le envuelve la llave de su cajón en el acto, o
+      // seguiría sin poder abrir nada hasta la siguiente escritura.
+      await spreadKey(`ns:${ns}`, await nsMembers(ns)).catch((e) => log('[vault] could not hand it the key:', e.message))
+      const body = { op: 'secrets.result', ns, enc: null, ok: true, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+    } catch (e) {
+      reply(from, { type: MSG.ERROR, error: 'enckey: ' + e.message })
+    }
+  }
+
   async function handleSecrets (from, p) {
     if (!isFresh(p.data)) { audit('rejected', { what: 'secrets', reason: 'stale' }); return staleReply(from) }
+    // REGISTRAR LA LLAVE DE CIFRADO de un servicio ya enrolado. Va por aquí, y no por
+    // un mensaje nuevo, para no tocar `protocol.js` — que está vendorizado en el iframe
+    // de identidad y obligaría a re-vendorizar.
+    //
+    // No exige la contraseña del perfil, y el argumento importa: registrar una llave no
+    // da acceso a nada por sí solo. Quien firma esta petición ya tiene la llave de firma
+    // del servicio y su cert, o sea que ya lee ese namespace. No hay escalada.
+    if (p.data?.op === 'enckey') return handleEncKey(from, p)
+    if (['approvals', 'approve', 'deny', 'ssh.keys', 'ssh.key.add', 'ssh.key.rm'].includes(p.data?.op)) return handleApproval(from, p)
+    if (p.data?.op === 'ssh.sign' || p.data?.op === 'ssh.keys.public') return handleSshRemote(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
     if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: missing ek (requester ephemeral key)' })
@@ -406,16 +507,202 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'secrets', ns, reason: 'cn' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
-    let enc
-    try {
-      enc = await seal({ ek: p.data.ek, payload: { secrets: secrets.get(ns, chk.device) } })
-    } catch (e) {
+    // APROBACIÓN POR USO: si el cajón la exige y este aparato no tiene la ventana abierta,
+    // el pedido se apunta, se avisa a quien aprueba y se contesta «pendiente». La respuesta
+    // de verdad sale cuando el teléfono firme (`handleApproval`), sellada a la misma `ek`.
+    if (secrets.policyOf(ns).approval && !approvals.has(ns, chk.device)) {
+      const deviceId = await deviceIdOf(chk.device).catch(() => null)
+      const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
+      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
+      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 })
+      await notifyApprovers(pend, record)
+      return
+    }
+    let res
+    try { res = await resultFor(ns, chk.device, p.data.ek, record) } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
     }
+    audit('secrets', { device: await deviceIdOf(chk.device), ns })
+    reply(from, { type: MSG.SECRETS_RESULT, ...res })
+  }
+
+  /** El bundle de `ns` para `devicePub`, sellado a su `ek` y firmado por la maestra. */
+  async function resultFor (ns, devicePub, ek, record) {
+    // Mientras el archivo siga en v3 el cable NO cambia: se mandan los valores como
+    // siempre. Solo tras la migración viajan sobres, y entonces quien los abre es el
+    // agente con su llave. Así el despliegue del daemon se deshace con un reinicio,
+    // porque hasta el primer desbloqueo no ha cambiado nada de lo que ve nadie.
+    const b = secrets.bundleFor(ns, devicePub)
+    // EL ACTA VIAJA CON EL BUNDLE (§8.8): es lo que le permite al agente comprobar que
+    // los sobres los selló esta bóveda, y con qué llave —la que el acta nombra para el
+    // `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.
+    const payload = b.legacy
+      ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])) }
+      : { 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)
-    audit('secrets', { device: await deviceIdOf(chk.device), ns })
-    reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+    return { body, signature }
+  }
+
+  // ---------- LLAVES SSH DEL TELÉFONO (`sshKeys.js`) ----------
+  // Aquí solo viven las PÚBLICAS: la privada está en el aparato que aprueba. `ssh` en este
+  // PC habla con el agente del daemon (`sshAgent.js`), y cada firma es un pedido más.
+  const sshKeysFile = path.join(dir, 'ssh-keys.json')
+  const atRest = atRestFor(dir)
+  const readSshKeys = () => { const d = readJsonAt(sshKeysFile); return Array.isArray(d?.keys) ? d.keys : [] }
+  function readJsonAt (file) { try { return JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8'))) } catch (_) { return null } }
+  const writeSshKeys = (keys) => fs.writeFileSync(sshKeysFile, atRest.encrypt(JSON.stringify({ v: 1, keys })), { mode: 0o600 })
+  const sshKeys = () => readSshKeys().map((k) => ({ id: k.id, type: k.type, blob: k.blob, comment: k.comment, deviceId: k.deviceId, addedAt: k.addedAt }))
+
+  /**
+   * FIRMAR UN RETO SSH: lo pide el agente local (el `ssh` del usuario) y lo resuelve el
+   * teléfono. No hay ventana: cada conexión es un «sí» — para no repetirlo veinte veces
+   * está `ControlMaster` en el `ssh_config`, que reusa la conexión 15 min.
+   */
+  function requestSshSign ({ keyId, data, askedBy = null, onPending = null }) {
+    const key = readSshKeys().find((k) => k.id === keyId)
+    if (!key) return Promise.reject(new Error('ssh: unknown key'))
+    return new Promise((resolve, reject) => {
+      const pend = approvals.request({
+        kind: 'ssh', ns: 'ssh', deviceId: askedBy || (fp.slice(0, 4).toUpperCase() + '-' + fp.slice(4, 8).toUpperCase()), label: 'ssh',
+        ssh: { key: key.id, comment: key.comment, data: Buffer.from(data).toString('base64') },
+        resolve, reject
+      })
+      try { onPending?.(pend) } catch (_) {}
+      audit('ssh.pending', { key: key.id, id: pend.id, device: askedBy || null })
+      log(`[vault] ssh: ${key.comment || key.id} is waiting for the phone to sign (${pend.id})`)
+      identity.profileActa?.().catch(() => null).then((r) => notifyApprovers(pend, r?.acta))
+    })
+  }
+
+  /**
+   * AGENTE SSH DELGADO en otra máquina (`dotrino-env ssh-agent`): un aparato con `vault:sign`
+   * pide que un reto se firme con una llave del teléfono. No hay nada que proteger en el
+   * que pide: solo convierte el reto en un pedido; quien firma es el teléfono.
+   */
+  async function handleSshRemote (from, p) {
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: SCOPE.SIGN, trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'ssh')
+    const answer = async (body) => {
+      body = { ...body, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+    }
+    if (p.data.op === 'ssh.keys.public') return answer({ op: 'ssh.keys.public', items: sshKeys().map((k) => ({ id: k.id, blob: k.blob, comment: k.comment })) })
+    const key = readSshKeys().find((k) => k.id === p.data.key)
+    if (!key || typeof p.data.data !== 'string') return reply(from, { type: MSG.ERROR, error: 'ssh: unknown key' })
+    const asker = await deviceIdOf(chk.device).catch(() => null)
+    let pendId = null
+    const done = requestSshSign({ keyId: key.id, data: Buffer.from(p.data.data, 'base64'), askedBy: asker, onPending: (pend) => { pendId = pend.id } })
+    await answer({ op: 'ssh.pending', id: pendId, exp: Date.now() + 5 * 60 * 1000 })
+    try {
+      const sig = await done
+      await answer({ op: 'ssh.sign.result', sig: Buffer.from(sig).toString('base64') })
+    } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
+  }
+
+  /**
+   * PEDIDOS DE APROBACIÓN (cajones con `approval`). Entran por `vault.secrets` con
+   * `op: approvals | approve | deny`, firmados por un aparato con `vault:approve` — que,
+   * como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`). El acta tiene
+   * que decirlo también, para que quitar el permiso surta efecto en el acto.
+   */
+  async function handleApproval (from, p) {
+    const op = p.data?.op
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: SCOPE.APPROVE, trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'approval')
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (record && !Acta.memberCan(record, chk.device, 'approve')) {
+      audit('rejected', { what: 'approval', reason: 'acta' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member does not approve' })
+    }
+    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 })
+    }
+    if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
+    if (op === 'ssh.keys') return answer({ op: 'ssh.keys', items: sshKeys() })
+    if (op === 'ssh.key.add') {
+      let k
+      try { k = parsePublicKey(p.data?.pub) } catch (e) { return reply(from, { type: MSG.ERROR, error: e.message }) }
+      const keys = readSshKeys().filter((x) => x.id !== k.id)
+      keys.push({ ...k, deviceId: by, addedAt: Date.now() })
+      writeSshKeys(keys)
+      audit('ssh.key.add', { key: k.id, by })
+      log(`[vault] ssh: key ${k.id} (${k.comment || 'no comment'}) registered by ${by}`)
+      return answer({ op: 'ssh.key.add', id: k.id, ok: true })
+    }
+    if (op === 'ssh.key.rm') {
+      const keys = readSshKeys(); const n = keys.length
+      writeSshKeys(keys.filter((x) => x.id !== p.data?.id))
+      if (keys.length !== n) audit('ssh.key.rm', { key: p.data?.id, by })
+      return answer({ op: 'ssh.key.rm', ok: true })
+    }
+    const id = typeof p.data?.id === 'string' ? p.data.id : ''
+    const pend = approvals.take(id)
+    if (!pend) return reply(from, { type: MSG.ERROR, error: 'approval: unknown or expired request' })
+    if (pend.kind === 'ssh') {
+      if (op === 'deny') {
+        audit('ssh.denied', { key: pend.ssh.key, id, by })
+        try { pend.reject?.(new Error('ssh: denied from ' + by)) } catch (_) {}
+        return answer({ op: 'deny.result', id, ok: true })
+      }
+      if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
+      const key = readSshKeys().find((k) => k.id === pend.ssh.key)
+      let blob
+      try { blob = sshSignature({ jwk: key.jwk, data: Buffer.from(pend.ssh.data, 'base64'), rawSig: p.data?.sig }) } catch (e) {
+        try { pend.reject?.(e) } catch (_) {}
+        audit('rejected', { what: 'ssh.sign', reason: e.message })
+        return reply(from, { type: MSG.ERROR, error: e.message })
+      }
+      audit('ssh.signed', { key: key.id, id, by })
+      log(`[vault] ssh: ${key.comment || key.id} signed by ${by}`)
+      try { pend.resolve?.(blob) } catch (_) {}
+      return answer({ op: 'approve.result', id, ok: true })
+    }
+    if (op === 'deny') {
+      audit('secrets.denied', { device: pend.deviceId, ns: pend.ns, id, by })
+      log(`[vault] ${pend.ns}: request of ${pend.deviceId} DENIED by ${by}`)
+      try { client.sendByPubkey(pend.device, { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }) } catch (_) {}
+      return answer({ op: 'deny.result', id, ok: true })
+    }
+    if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
+    const exp = approvals.grant(pend.ns, pend.device)
+    let res
+    try { res = await resultFor(pend.ns, pend.device, pend.ek, record) } catch (e) {
+      return reply(from, { type: MSG.ERROR, error: 'approval: could not seal the reply: ' + e.message })
+    }
+    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by, until: exp })
+    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by} (window until ${new Date(exp).toISOString()})`)
+    // Va por `sendByPubkey`: si el que pedía ya no está conectado, lo recoge al volver.
+    try { client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res }) } catch (_) {}
+    return answer({ op: 'approve.result', id, ok: true, exp })
+  }
+
+  /** Aviso a los aparatos que aprueban (cola del proxio → push nativo si están apagados). */
+  async function notifyApprovers (pend, record) {
+    try {
+      const body = { ev: 'approval', id: pend.id, ns: pend.ns, deviceId: pend.deviceId, label: pend.label, exp: pend.exp, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      const who = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).map((m) => m.pub)
+      if (!who.length) log(`[vault] ${pend.ns}: nobody can approve (grant it with: dotrino-vault caps <ID> +aprueba)`)
+      for (const pub of who) { try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature }) } catch (_) {} }
+    } catch (e) { log('[vault] could not notify approvers:', e.message) }
   }
 
   client.on('message', async (from, payload) => {
@@ -431,6 +718,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.DEVICES) return await handleDevices(from, payload)
       if (payload.type === MSG.RENEW) return await handleRenew(from, payload)
       if (payload.type === MSG.SECRETS) return await handleSecrets(from, payload)
+      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)
     } catch (e) {
@@ -577,6 +865,24 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    *   2. **Lo que sale, sale CIFRADO** con la clave de contenido del perfil: el proxy
    *      transporta el sobre y no ve nada. Igual que el contenido del usuario (`store`).
    */
+  /**
+   * La llave de administración a partir de lo que venga en el sobre de la consola
+   * remota. `undefined` si no trae contraseña — entonces el store cae a la de la
+   * máquina, que es lo correcto para un perfil que no tiene ninguna.
+   *
+   * La contraseña no se guarda: se deriva, se usa y se suelta con el sobre.
+   */
+  /**
+   * La llave derivada de la contraseña, si el sobre la traía. Desde §8 solo la piden las
+   * operaciones que LEEN (ver un valor, cambiar su visibilidad): escribir no.
+   */
+  async function adminKeyFrom (payload) {
+    const pwd = payload?.password
+    if (typeof pwd !== 'string' || !pwd) return undefined
+    if (typeof deriveAdminKey !== 'function') return undefined
+    return deriveAdminKey(pwd)
+  }
+
   const varsDesk = {
     async list () {
       // `listSecrets`/`listDeviceSecrets` ya traen el valor de las públicas y solo de esas:
@@ -585,16 +891,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // aprender cómo se llaman tus variables ni qué servicios corres.
       return {
         enc: await identity.sealContent(JSON.stringify({
-          ns: listSecrets(), dev: await listDeviceSecrets()
+          ns: listSecrets(), dev: await listDeviceSecrets(),
+          // Aparatos que están en el acta pero no pueden abrir lo suyo: hay que
+          // enseñarlo donde se administra, no solo en el log del servicio.
+          incomplete: await incompleteMembers(),
+          // Lo que quedó a deber un sellado: quien administra a distancia tiene que
+          // poder verlo, porque es exactamente lo que él puede saldar (escribiendo una
+          // variable con la contraseña) y la bóveda no.
+          pending: await secretDebts(),
+          // Y si el perfil NO tiene contraseña, decirlo: sus privadas se abren con la
+          // llave de la máquina de la bóveda, cuyo material vive en ese mismo disco.
+          // El comentario de aquí decía «la consola lo dice en voz alta» y la consola
+          // no decía nada — el mismo error que el comentario mentiroso de `atrest.js`.
+          hasPassword: (() => { try { return !!hasPassword() } catch (_) { return true } })()
         }))
       }
     },
-    async set ({ ns, pub, key, enc, public: isPublic }) {
+    async set ({ ns, pub, key, enc, public: isPublic, by: who = null }) {
       const payload = JSON.parse(await identity.openContent(enc))
       const value = payload?.value
       if (typeof value !== 'string' || !value) throw new Error('var.set: the sealed envelope must carry a non-empty value')
-      if (ns) setSecret(ns, key, value, isPublic)
-      else await setDeviceSecret(pub, key, value, isPublic)
+      // NO PIDE LA CONTRASEÑA (§8.1): sellar solo necesita las públicas de quien va a
+      // leer. Lo que se guarda es quién lo escribió, para que el histórico lo diga.
+      if (ns) await setSecret(ns, key, value, isPublic, { by: who })
+      else await setDeviceSecret(pub, key, value, isPublic, { by: who })
       return { ok: true, key }
     },
     /**
@@ -607,7 +927,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * Los NOMBRES también viajan dentro del sobre —no solo los valores—: el proxy
      * transporta y no tiene por qué aprender cómo se llama la configuración de un servicio.
      */
-    async setMany ({ ns, pub, enc, public: isPublic }) {
+    async setMany ({ ns, pub, enc, public: isPublic, by: who = null }) {
       const payload = JSON.parse(await identity.openContent(enc))
       const items = payload?.items
       if (!Array.isArray(items) || !items.length) throw new Error('var.setMany: the sealed envelope must carry the variables')
@@ -620,7 +940,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         value: it?.value,
         ...(typeof it?.public === 'boolean' ? { public: it.public } : (isPublic === undefined ? {} : { public: isPublic }))
       }))
-      const keys = ns ? applySecrets(ns, list) : await applyDeviceSecrets(pub, list)
+      // NO PIDE LA CONTRASEÑA (§8.1). Y sí, `applySecrets` va con `await` — sin él la
+      // escritura quedaba al aire y la respuesta salía antes de guardar nada.
+      const keys = ns ? await applySecrets(ns, list, { by: who }) : await applyDeviceSecrets(pub, list, { by: who })
       return { ok: true, keys }
     }
   }
@@ -694,8 +1016,421 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   // API local de secretos (CLI/UI del dueño; audita cada cambio). `isPublic` es opcional:
   // sin decir nada, la variable conserva su visibilidad (y una nueva nace privada).
-  function setSecret (ns, key, value, isPublic) { secrets.set(ns, key, value, isPublic); audit('secret.set', { ns, key }); scheduleNotice(ns) }
-  function deleteSecret (ns, key) { const ok = secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); scheduleNotice(ns) } return ok }
+  /**
+   * La llave con la que se abre la copia maestra.
+   *
+   * Con contraseña, la deriva quien llama y llega aquí por operación. **Sin
+   * contraseña se cae a la llave de la máquina**, que es exactamente la protección
+   * que había antes de todo esto: el disco sigue cifrado, pero su material vive en
+   * ese mismo disco, así que una copia del disco lo abre.
+   *
+   * Es un default deliberado —un perfil sin contraseña tiene que seguir funcionando—
+   * 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))
+
+  // `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,
+  // listar y borrar no la piden (ver `secretsStore.js`).
+  /**
+   * Los miembros que deben poder abrir un cajón: los SERVICIOS de ese namespace
+   * (miembros del acta con ese `cn`). La bóveda NO entra en la lista — envolverle la
+   * CEK a ella misma sería devolverle la capacidad de leerlo todo, que es justo lo
+   * que este diseño quita.
+   */
+  async function nsMembers (ns) {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    return (record?.members || []).filter((m) => m.cn === ns)
+  }
+
+  /**
+   * Los APARATOS QUE ADMINISTRAN: miembros sin CN (no son servicios) con llave de
+   * cifrado. Son los que pueden VER y REVERTIR desde la consola sin teclear la frase en
+   * ningún sitio, que es todo el punto del §8.2 — la capacidad de leer se muda de una
+   * frase que se escribe en cualquier parte a una llave que no sale del aparato.
+   *
+   * La bóveda NO entra en la lista, ni aquí ni en `nsMembers`: envolverle la llave a
+   * ella misma sería devolverle la capacidad de leerlo todo, que es justo lo que este
+   * diseño quita. Hay un test que lo afirma.
+   */
+  async function adminDevices () {
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    return (record?.members || []).filter((m) => !m.cn && m.encPub && m.pub !== master)
+  }
+
+  /**
+   * Los destinatarios de un cajón. Y la regla que decide quién NO entra, que es la que
+   * importa (decidida por el dueño el 2026-08-22):
+   *
+   * **UN CAJÓN CON DUEÑO NO SE ENVUELVE PARA QUIEN ADMINISTRA.** Si el acta dice que
+   * hay un servicio que consume ese `ns`, sus variables son suyas y de nadie más: el
+   * token de R2 o las llaves de TURN no se pueden abrir desde un navegador, ni aunque
+   * alguien se lleve tu portátil con la sesión puesta.
+   *
+   * Dos cosas que hacen que esto se sostenga:
+   *
+   *  · **No es una negativa, es que no existe.** Se podría haber dejado el envoltorio y
+   *    que la bóveda se negara a entregarlo, pero entonces la protección sería una
+   *    política: el envoltorio seguiría en el disco, y quien tuviera el disco más la
+   *    llave de un aparato que administra lo abriría sin preguntarle a nadie. Lo que no
+   *    se crea no se puede saltar.
+   *  · **El criterio es ESTRUCTURAL, no de tiempo de ejecución.** Se mira el acta —qué
+   *    dice la maestra que existe—, no quién está encendido. «Hay un servicio activo»
+   *    se puede forzar esperando a que ese servicio esté caído.
+   *
+   * Y sigue habiendo quien pueda repartir: el propio SERVICIO re-envuelve para un
+   * miembro nuevo de su cajón (ya tiene la CEK, así que no gana nada), y la frase
+   * abre la envoltura de recuperación, que `wrapAll` añade siempre.
+   */
+  /**
+   * Llega la envoltura que hizo un servicio. Se comprueba QUIÉN la firma —tiene que ser
+   * el aparato al que se le pidió, no cualquiera que pase por el proxy— y se reparte a
+   * quien esté esperándola. Guardarla es cosa de `delegateRewrap`, que es quien sabe
+   * qué pidió; aquí solo se valida el remitente.
+   */
+  async function handleRewrapOk (payload) {
+    const d = payload?.data
+    if (!d || d.op !== 'rewrap.ok' || !d.wrap) return
+    const signer = payload?.cert?.sub
+    if (!signer) return
+    if (!(await verifyDeviceSig({ publickey: signer, data: d, signature: payload.signature }))) {
+      return log('[vault] a handed key arrived BADLY SIGNED: ignored')
+    }
+    // Y que quien firma sea de ese cajón: si no, no tenía por qué poder abrir esa llave.
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    const m = (record?.members || []).find((x) => x.pub === signer)
+    const ns = d.owner?.startsWith('ns:') ? d.owner.slice(3) : null
+    if (!m || (ns && m.cn !== ns)) return log('[vault] a handed key arrived from someone outside that drawer: ignored')
+    for (const fn of [...rewrapWaiters]) { try { fn(d) } catch (_) {} }
+  }
+
+  /** Suscriptores de `vault.rewrap.ok` (la envoltura que devuelve un servicio). */
+  const rewrapWaiters = new Set()
+  const onRewrapOk = (fn) => { rewrapWaiters.add(fn); return () => rewrapWaiters.delete(fn) }
+
+  async function recipientsOf (owner) {
+    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()
+    }
+    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()]
+  }
+
+  /**
+   * Firma un sobre con la LLAVE DE SELLADO que nombra el acta (§8.8). Devuelve el `seq`
+   * del acta junto a la firma: es lo que le dice a quien verifica con qué llave
+   * comprobarla, porque esa llave rota con el acta (§8.9).
+   *
+   * Si no hay llave —o no es nuestra— el sobre sale SIN firma. Guardar la configuración
+   * es más importante que poder demostrar después de dónde salió.
+   */
+  async function signSeal (body) {
+    try {
+      const acta = (await identity.profileActa?.().catch(() => null))?.acta
+      if (!acta?.sealPub) return null
+      const sig = await sealKeys.sign(acta.sealPub, body)
+      return sig ? { seq: acta.seq, sig } : null
+    } catch (_) { return null }
+  }
+
+  /**
+   * Sellar no basta: hay que REPARTIR la llave. Tras cada escritura se envuelve la CEK
+   * del cajón a sus miembros actuales — si no, el servicio recibe sobres que no puede
+   * abrir y se queda reintentando para siempre, sin decir por qué.
+   *
+   * No avisa de cambio a nadie: el texto cifrado de los valores no se mueve, y avisar
+   * reiniciaría a todos los nodos del ns para nada.
+   */
+  /**
+   * Se fue un miembro de un namespace: su CEK deja de ser de fiar. Se intenta rotar en
+   * el acto y, si no se puede (perfil sin desbloquear), el cajón queda MARCADO — la
+   * consola y el CLI lo enseñan, y la siguiente escritura desbloqueada lo salda.
+   *
+   * Una deuda que no se ve es una deuda que no se paga, y aquí la deuda es que alguien
+   * que ya no está podría abrir lo que se escriba mañana.
+   */
+  async function markRotationDue (sub) {
+    const m = await memberOf(sub)
+    const ns = m?.cn
+    if (!ns) return
+    try {
+      const r = await secrets.rotate(`ns:${ns}`, await nsMembers(ns))
+      if (r?.rotated != null) {
+        log(`[vault] ns:${ns}: key rotated after removing a member (${r.rotated} variable(s) re-encrypted)`)
+        audit('secret.rotate', { ns, keys: r.rotated })
+        scheduleNotice(ns)
+        return
+      }
+    } catch (e) {
+      store.setSetting(`rotate-due:${ns}`, String(Date.now()))
+      log(`[vault] ns:${ns}: PENDING ROTATION - a member left and its key could not be rotated (${e.message})`)
+      audit('secret.rotate-due', { ns, reason: e.message })
+    }
+  }
+
+  /**
+   * Lo que este perfil debe volver a sellar, para que las listas puedan DECIRLO. Son dos
+   * deudas distintas y las dos acaban igual —los miembros no leen sus variables— así que
+   * salen juntas:
+   *
+   * - `rotate`: se fue un miembro y no se pudo rotar la llave del namespace.
+   * - `rewrap`: entró uno (o registró su llave de cifrado) y no se le pudo envolver.
+   *
+   * Ambas se saldan solas en la siguiente escritura con contraseña. Mientras tanto,
+   * enseñarlas es la diferencia entre un servicio mal configurado y uno mal configurado
+   * que además nadie ve.
+   */
+  /**
+   * Los aparatos INCOMPLETOS: los que están en el acta pero no pueden abrir alguna de
+   * las variables que les tocan (§8.7). Pasa siempre que entra uno nuevo — envolverle su
+   * llave exige abrir la CEK, y eso pide la frase, que por el camino del enrolamiento no
+   * hay quien la teclee.
+   *
+   * Que no puedan leer es CORRECTO y no se relaja. Lo que se arregla aquí es que se
+   * vea: hasta ahora un servicio recién enrolado aparecía en la lista como cualquier
+   * otro y arrancaba sin configuración, repitiendo un error en su propio log que nadie
+   * mira. Con esto, la consola y la TUI pueden decir exactamente qué falta y qué hacer
+   * (`dotrino-vault secret settle`, que sí pide la frase).
+   *
+   * @returns {Promise<Array<{ pub: string, cn: string|null, owners: Record<string, string[]> }>>}
+   */
+  async function incompleteMembers () {
+    if (secrets.isLegacy?.()) return []
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    const out = []
+    for (const m of record?.members || []) {
+      if (!m.encPub || m.pub === master) continue
+      const owners = {}
+      // Un servicio lee su cajón de ns y el suyo propio; un aparato que administra
+      // puede DESTAPAR cualquiera, así que se le miran todos: sin envoltura, el botón
+      // «Ver» de la consola le fallaría sin explicar por qué.
+      // Un aparato que administra NO debe tener envoltura de los cajones con dueño
+      // (`recipientsOf`), así que no se le cuenta como falta: lo que ahí falta es a
+      // propósito y ponerlo en la lista sería pedir que se «arregle» lo correcto.
+      const ownedNs = new Set((record?.members || []).filter((x) => x.cn).map((x) => x.cn))
+      const drawers = m.cn
+        ? [`ns:${m.cn}`, `dev:${m.pub}`]
+        : [...Object.keys(secrets.list()).filter((ns) => !ownedNs.has(ns)).map((ns) => `ns:${ns}`), `dev:${m.pub}`]
+      for (const owner of drawers) {
+        const missing = secrets.missingFor(owner, m.pub)
+        if (missing.length) owners[owner] = missing
+      }
+      if (Object.keys(owners).length) out.push({ pub: m.pub, cn: m.cn || null, owners })
+    }
+    return out
+  }
+
+  /**
+   * Lo que quedó a deber una ROTACIÓN: un aparato salió conociendo la llave vigente y
+   * no se pudo rotar en ese momento. Eso sí es una nota, porque es un hecho pasado que el
+   * estado de hoy no enseña (quitarle la envoltura no le quita lo que ya supo).
+   */
+  function rotationsDue () {
+    const out = {}
+    for (const [k, v] of Object.entries(store.listSettings?.() || {})) {
+      // La salida va SIEMPRE por owner (`ns:proxy`), aunque el ajuste guarde solo el
+      // nombre del namespace: una sola forma para quien lo lee.
+      if (k.startsWith('rotate-due:')) out['ns:' + k.slice('rotate-due:'.length)] = { kind: 'rotate', at: Number(v) || 0 }
+    }
+    return out
+  }
+
+  /**
+   * TODO lo que está a deber, por cajón: las rotaciones anotadas y, CALCULADO, cada
+   * envoltura que falta. La falta de una envoltura no se anota nunca: se mira. Una nota
+   * se desincroniza en cuanto alguien salda la deuda por un camino que no pasa por donde
+   * se anotó (pasó dos veces: el reparto por el hermano y el rehacer al abrir), y
+   * entonces la consola avisa de algo que ya no existe. Lo que se calcula no miente.
+   * @returns {Promise<Record<string, { kind: 'rotate'|'rewrap', at?: number, members?: { pub: string, keys: string[] }[] }>>}
+   */
+  async function secretDebts () {
+    const out = rotationsDue()
+    for (const m of await incompleteMembers()) {
+      for (const [owner, keys] of Object.entries(m.owners)) {
+        if (out[owner]?.kind === 'rotate') continue
+        out[owner] = out[owner] || { kind: 'rewrap', members: [] }
+        out[owner].members.push({ pub: m.pub, keys })
+      }
+    }
+    return out
+  }
+
+  async function spreadKey (owner, members, adminKey) {
+    if (secrets.isLegacy()) return null
+    // Si este cajón quedó a deber una rotación (se fue alguien y no se pudo rotar),
+    // se salda AHORA, que es cuando hay con qué. Rotar incluye re-envolver, así que
+    // sustituye al reparto en vez de sumarse.
+    const ns = owner.startsWith('ns:') ? owner.slice(3) : null
+    if (ns && store.getSetting(`rotate-due:${ns}`)) {
+      const rot = await secrets.rotate(owner, members, adminKey)
+      store.setSetting(`rotate-due:${ns}`, undefined)
+      log(`[vault] ns:${ns}: pending rotation settled (${rot?.rotated ?? 0} variable(s) re-encrypted)`)
+      audit('secret.rotate', { ns, keys: rot?.rotated ?? 0, pending: true })
+      return rot
+    }
+    try {
+      const r = await secrets.rewrap(owner, members, adminKey)
+      if (r?.sinLlave?.length) {
+        log(`[vault] ${owner}: ${r.sinLlave.length} member(s) without an encryption key - they will NOT be able to read their variables`)
+        audit('secret.nokey', { owner, count: r.sinLlave.length })
+      }
+      return r
+    } catch (e) {
+      // SIN la contraseña no hay forma de envolverle su llave, y esto pasa por caminos
+      // donde no hay a quién pedírsela: un servicio que acaba de registrar su llave de
+      // cifrado llega por el proxio, no por una consola. Antes se perdía en un `.catch`
+      // del que llamaba y el servicio se quedaba sin variables SIN QUE NADIE SE ENTERARA
+      // — el modo de fallo que más caro sale aquí. Se dice y se audita; la deuda no se
+      // anota: se CALCULA (`secretDebts`), así no hay nota que se quede vieja cuando la
+      // salde un hermano o el abrir la bóveda.
+      log(`[vault] ${owner}: could not hand out its key (${e.message}); its members will not read their variables until a sibling hands it out or the vault is opened`)
+      audit('secret.rewrap-due', { owner, reason: e.message })
+      throw e
+    }
+  }
+
+  /**
+   * Escribir NO pide la frase (§8.1): el sobre se sella con las públicas de quien lo va
+   * a leer. `by` es el aparato que lo escribió, y va al histórico.
+   */
+  async function setSecret (ns, key, value, isPublic, { by = null } = {}) {
+    await secrets.set(ns, key, value, isPublic, { by })
+    await settleDebts(`ns:${ns}`, () => nsMembers(ns))
+    audit('secret.set', { ns, key }); scheduleNotice(ns)
+  }
+
+  /**
+   * SALDAR LAS DEUDAS DEL PERFIL, con la frase en la mano. Es lo que hay que llamar tras
+   * desbloquear: heredarle a un aparato nuevo lo que ya estaba guardado, y rotar de
+   * verdad el cajón del que salió alguien. Las dos cosas exigen ABRIR, y abrir es lo
+   * único que la frase guarda (§8.3).
+   *
+   * No lanza: devuelve qué pasó con cada cajón, porque una deuda que no se puede saldar
+   * tiene que seguir viéndose en la lista en vez de tumbar la operación entera.
+   */
+  /**
+   * PIDE AL SERVICIO QUE REPARTA la llave de su cajón a un miembro nuevo (§8.11).
+   *
+   * Es la única forma de completar a un aparato sin la frase y sin que nadie guarde
+   * llaves de más: la bóveda no puede abrir la CEK, pero el servicio que la consume la
+   * tiene abierta, y re-envolverla no le da ningún poder que no tuviera.
+   *
+   * La bóveda manda su propia envoltura de esa generación —la del servicio, que él ya
+   * podía abrir— junto al ACTA firmada. El servicio saca de ahí la pública del
+   * destinatario y contesta con la envoltura nueva, que se guarda con `putWrap`, que
+   * solo AÑADE. Si el servicio no está encendido, la deuda se queda a la vista.
+   *
+   * @returns {Promise<{ done: number, asked: number }>}
+   */
+  async function delegateRewrap (owner, targetPub, { timeoutMs = 15000 } = {}) {
+    const ns = owner.startsWith('ns:') ? owner.slice(3) : null
+    if (!ns) return { done: 0, asked: 0 }
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (!record) return { done: 0, asked: 0 }
+    // Quien puede repartir: un miembro de ESE cajón que no sea el propio destinatario.
+    const helpers = (record.members || []).filter((m) => m.cn === ns && m.pub !== targetPub && m.encPub)
+    const pending = secrets.wrapsToShare(owner, targetPub, helpers[0]?.pub || '')
+    if (!helpers.length || !pending.length) return { done: 0, asked: 0 }
+
+    let done = 0
+    for (const gen of pending) {
+      const body = { op: 'rewrap', owner, gen: gen.gen, wrap: gen.mine, target: targetPub, acta: record, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      const answer = new Promise((resolve) => {
+        const off = onRewrapOk((d) => {
+          if (d.owner !== owner || d.gen !== gen.gen || d.target !== targetPub) return
+          off(); resolve(d.wrap)
+        })
+        setTimeout(() => { off(); resolve(null) }, timeoutMs).unref?.()
+      })
+      try { client.sendByPubkey(helpers[0].pub, { type: MSG.REWRAP, body, signature }) } catch (e) {
+        log(`[vault] ${owner}: could not ask for the key to be handed out (${e.message})`)
+        continue
+      }
+      const wrap = await answer
+      if (!wrap) continue
+      try { secrets.putWrap(owner, gen.gen, targetPub, wrap); done++ } catch (e) {
+        log(`[vault] ${owner}: the handed key was refused (${e.message})`)
+      }
+    }
+    if (done) {
+      audit('secret.delegated', { owner, target: await deviceIdOf(targetPub).catch(() => null), gens: done })
+      log(`[vault] ${owner}: ${done} key(s) handed out by its own service`)
+    }
+    return { done, asked: pending.length }
+  }
+
+  async function resealAll (adminKey = null) {
+    const out = { drawers: 0, wrapped: 0, dropped: 0, sinLlave: [] }
+    for (const owner of secrets.owners?.() || []) {
+      const before = new Set(secrets.recipientsIn(owner))
+      const members = await recipientsOf(owner)
+      try {
+        const r = await secrets.rewrap(owner, members, adminKey, { exact: true })
+        const after = new Set(secrets.recipientsIn(owner))
+        out.drawers++
+        out.wrapped += r?.wrapped || 0
+        out.dropped += [...before].filter((p) => !after.has(p)).length
+        for (const p of r?.sinLlave || []) out.sinLlave.push(p)
+      } catch (e) {
+        log(`[vault] ${owner}: could not reseal (${e.message})`)
+      }
+    }
+    if (out.dropped) audit('secret.reseal', { drawers: out.drawers, dropped: out.dropped })
+    return out
+  }
+
+  async function settleSecretDebts (adminKey = null) {
+    const out = {}
+    // Las deudas ANOTADAS más las que se ven MIRANDO: un aparato puede quedarse sin
+    // envoltura sin que nadie llegara a anotar nada (basta con que el apunte se pierda
+    // por un camino que no pase por `spreadKey`), y entonces `settle` contestaba «nada
+    // pendiente» mientras el servicio repetía en su log que no podía leer. Se calcula,
+    // que es barato y no depende de que alguien se acordara de apuntarlo.
+    const debts = new Set(Object.keys(rotationsDue()))
+    for (const m of await incompleteMembers()) for (const owner of Object.keys(m.owners)) debts.add(owner)
+
+    for (const owner of debts) {
+      const k = owner.slice(owner.indexOf(':') + 1)
+      // Los destinatarios de un cajón no son solo quien lo consume: también quien lo
+      // administra (`recipientsOf`). Envolver solo para los primeros dejaba a la consola
+      // sin poder destapar lo que ella misma acababa de saldar.
+      const members = await recipientsOf(owner)
+      try { out[owner] = await spreadKey(owner, members, adminKey) } catch (e) {
+        // Sin frase, el último recurso es pedírselo a quien sí puede: el propio servicio.
+        let delegated = 0
+        for (const m of await incompleteMembers()) {
+          if (!m.owners[owner]) continue
+          delegated += (await delegateRewrap(owner, m.pub).catch(() => ({ done: 0 }))).done
+        }
+        out[owner] = delegated ? { delegated } : { error: e.message }
+      }
+    }
+    return out
+  }
+
+  /**
+   * Si este cajón quedó a deber un re-envoltorio o una rotación, se intenta saldar ahora.
+   * Sin frase solo se puede en un perfil que no tiene contraseña —ahí la copia de
+   * recuperación se abre con la llave de la máquina—, y en uno que sí la tiene se queda
+   * anotado, que es lo que las listas enseñan. No se propaga el error: la variable YA se
+   * guardó, y el que escribe no tiene por qué enterarse de una deuda vieja.
+   */
+  async function settleDebts (owner, membersFn) {
+    const ns = owner.startsWith('ns:') ? owner.slice(3) : null
+    const owed = (ns && store.getSetting(`rotate-due:${ns}`)) ||
+      (await incompleteMembers()).some((m) => m.owners[owner])
+    if (!owed) return null
+    try { return await spreadKey(owner, await membersFn(), null) } catch (_) { return null }
+  }
+  async function deleteSecret (ns, key) { const ok = await secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); scheduleNotice(ns) } return ok }
 
   /**
    * CARGAR CONFIGURACIÓN ES UNA TRANSACCIÓN: muchas variables, UN aviso.
@@ -716,40 +1451,44 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * @returns {string[]} las claves que efectivamente cambiaron (un `rm` de lo que no
    *   estaba no cambia nada, y no tiene por qué reiniciar a nadie).
    */
-  function applySecrets (ns, items) {
+  async function applySecrets (ns, items, { by = null } = {}) {
     const list = assertItems(items)
     const changed = []
-    secrets.batch(() => {
+    await secrets.batch(async () => {
       for (const it of list) {
         if (it.op === 'rm') {
-          if (secrets.delete(ns, it.key)) { audit('secret.rm', { ns, key: it.key }); changed.push(it.key) }
+          if (await secrets.delete(ns, it.key)) { audit('secret.rm', { ns, key: it.key }); changed.push(it.key) }
         } else {
-          secrets.set(ns, it.key, it.value, it.public)
+          await secrets.set(ns, it.key, it.value, it.public, { by })
           audit('secret.set', { ns, key: it.key })
           changed.push(it.key)
         }
       }
     })
-    if (changed.length) scheduleNotice(ns)
+    if (changed.length) {
+      await settleDebts(`ns:${ns}`, () => nsMembers(ns))
+      scheduleNotice(ns)
+    }
     return changed
   }
 
   /** Lo mismo para el cajón de UN aparato (el aviso va solo a él). */
-  async function applyDeviceSecrets (pub, items) {
+  async function applyDeviceSecrets (pub, items, { by = null } = {}) {
     const list = assertItems(items)
     const m = await requireService(pub)
     const changed = []
-    secrets.batch(() => {
+    await secrets.batch(async () => {
       for (const it of list) {
         if (it.op === 'rm') {
-          if (secrets.deleteDevice(pub, it.key)) changed.push(it.key)
+          if (await secrets.deleteDevice(pub, it.key)) changed.push(it.key)
         } else {
-          secrets.setDevice(pub, it.key, it.value, it.public)
+          await secrets.setDevice(pub, it.key, it.value, it.public, { by })
           changed.push(it.key)
         }
       }
     })
     if (changed.length) {
+      await settleDebts(`dev:${pub}`, async () => [m].filter(Boolean))
       const device = await deviceIdOf(pub).catch(() => null)
       for (const it of list) {
         if (!changed.includes(it.key)) continue
@@ -786,12 +1525,21 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return out
   }
   /** Cambiar SOLO quién puede ver el valor (no toca el valor ni avisa: el servicio lee lo mismo). */
-  function setSecretVisibility (ns, key, isPublic) {
-    const ok = secrets.setVisibility(ns, key, isPublic)
+  async function setSecretVisibility (ns, key, isPublic, adminKey) {
+    const ok = await secrets.setVisibility(ns, key, isPublic, adminKey)
     if (ok) audit('secret.visibility', { ns, key, public: !!isPublic })
     return ok
   }
 
+  /**
+   * El bundle de un ns ABIERTO, para diagnosticar y para las pruebas. No lo usa el
+   * camino de servir —ahí los sobres salen cerrados y los abre el agente—, y por eso
+   * este sí pide poder abrir la copia maestra.
+   */
+  async function openSecrets (ns, devicePub = null, adminKey) {
+    return secrets.openBundle(ns, devicePub, adminKey)
+  }
+
   /** El miembro del acta con esa llave, o `null` (también si la bóveda todavía no tiene acta). */
   async function memberOf (pub) {
     const record = (await identity.profileActa?.().catch(() => null))?.acta
@@ -816,16 +1564,17 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return m
   }
 
-  async function setDeviceSecret (pub, key, value, isPublic) {
+  async function setDeviceSecret (pub, key, value, isPublic, { by = null } = {}) {
     const m = await requireService(pub)
-    secrets.setDevice(pub, key, value, isPublic)
+    await secrets.setDevice(pub, key, value, isPublic, { by })
+    await settleDebts(`dev:${pub}`, async () => [await memberOf(pub)].filter(Boolean))
     audit('secret.set', { device: await deviceIdOf(pub).catch(() => null), ns: m?.cn || null, key, scope: 'device' })
     scheduleDeviceNotice(pub)
   }
 
   async function deleteDeviceSecret (pub, key) {
     const m = await memberOf(pub)
-    const ok = secrets.deleteDevice(pub, key)
+    const ok = await secrets.deleteDevice(pub, key)
     if (ok) {
       audit('secret.rm', { device: await deviceIdOf(pub).catch(() => null), ns: m?.cn || null, key, scope: 'device' })
       scheduleDeviceNotice(pub)
@@ -833,8 +1582,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return ok
   }
 
-  async function setDeviceSecretVisibility (pub, key, isPublic) {
-    const ok = secrets.setDeviceVisibility(pub, key, isPublic)
+  async function setDeviceSecretVisibility (pub, key, isPublic, adminKey) {
+    const ok = await secrets.setDeviceVisibility(pub, key, isPublic, adminKey)
     if (ok) audit('secret.visibility', { device: await deviceIdOf(pub).catch(() => null), key, public: !!isPublic, scope: 'device' })
     return ok
   }
@@ -864,14 +1613,38 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   return {
-    identity, client, store, threads, secrets, master, fingerprint: fp,
+    identity, client, store, threads, secrets, master, fingerprint: fp, dir,
     startPairing: desk.startPairing,
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
+    // Cajones con aprobación por uso (`approvals.js`).
+    secretPolicy: (ns) => secrets.policyOf(ns),
+    setSecretPolicy: async (ns, patch) => { const r = secrets.setPolicy(ns, patch); audit('secret.policy', { ns, ...r }); return r },
+    secretPolicies: () => secrets.policies(),
+    listApprovals: () => approvals.list(),
+    sshKeys,
+    requestSshSign,
     // Aprobar desde el PC avisa igual que aprobar a distancia: el resto de tus
     // dispositivos se entera de que entró alguien, venga de donde venga.
-    approveDevice: async (code) => {
+    approveDevice: async (code, adminKey) => {
       const r = await desk.approve(code)
+      // Un servicio que ENTRA a un namespace que ya tiene variables necesita su
+      // envoltura de la CEK, o recibirá sobres que no puede abrir y se quedará
+      // reintentando en silencio. Se reparte aquí, que es por donde pasan las dos
+      // puertas de aprobar (el PC y la consola remota), y no en `enroll.js`, que es
+      // el archivo vendorizado en el iframe de identidad.
+      const m = r?.cert?.sub ? await memberOf(r.cert.sub) : null
+      if (m?.cn) {
+        await spreadKey(`ns:${m.cn}`, await nsMembers(m.cn), adminKey).catch(async (e) => {
+          log('[vault] could not hand the key to the new service:', e.message)
+          // Sin la frase la bóveda no puede envolvérsela… pero un HERMANO suyo sí: otro
+          // servicio del mismo cajón ya tiene la llave abierta (§8.11). Si contesta, el
+          // recién llegado arranca completo; si no hay ninguno encendido, la deuda queda
+          // a la vista y se salda al abrir la bóveda.
+          const r2 = await delegateRewrap(`ns:${m.cn}`, m.pub).catch(() => ({ done: 0 }))
+          if (!r2.done) log(`[vault] ns:${m.cn}: nobody could hand it the key — it stays in debt until the vault is opened`)
+        })
+      }
       await notifyMembers('enrolled', { deviceId: r?.deviceId || null, by: 'pc' })
       return r
     },
@@ -879,13 +1652,43 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // El mostrador que atiende a la consola remota. Se expone para poder probar la
     // frontera de verdad (que el valor de una privada no salga ni dentro del sobre).
     vars: varsDesk,
-    setSecret, deleteSecret, listSecrets, setSecretVisibility,
+    setSecret, deleteSecret, listSecrets, setSecretVisibility, openSecrets,
+    // Sella un `secrets.json` v3 entero. Es el punto de no retorno del despliegue y
+    // por eso es una operación con nombre propio, no algo que ocurra de refilón al
+    // desbloquear: deja `secrets.json.v3.bak` para poder volver.
+    /**
+     * Convierte el archivo de secretos al formato nuevo. `membersOf` es opcional y lo
+     * normal es NO pasarlo: por defecto se usa la misma lista de destinatarios que
+     * cualquier escritura —los servicios del cajón MÁS los aparatos que administran—.
+     *
+     * Pasarla a mano fue un error real: la conversión envolvía solo a los servicios, y
+     * entonces la consola del dueño no podía ver nada de lo que ya había, aunque el
+     * diseño dice que sí (§8.2). Lo de siempre: dos sitios decidiendo lo mismo.
+     */
+    resealAll,
+    delegateRewrap,
+    incompleteMembers,
+    migrateSecrets: (membersOf, adminKey) => secrets.migrate(
+      membersOf || ((owner) => recipientsOf(owner)), adminKey
+    ),
+    settleSecretDebts,
+    revealSecret: (owner, key, adminKey) => secrets.reveal(owner, key, adminKey),
+    secretHistory: (owner, key) => secrets.history(owner, key),
+    revealSecretHistory: (owner, key, ts, adminKey) => secrets.revealHistory(owner, key, ts, adminKey),
+    revertSecret: (owner, key, ts, opts) => secrets.revert(owner, key, ts, opts),
+    // Cambiar la contraseña del perfil obliga a volver a cerrar la copia maestra con
+    // la llave nueva, o los secretos quedarían ilegibles. No toca los sobres.
+    rekeySecrets: (oldKey, newKey) => secrets.rekeyRecovery(oldKey, newKey),
     setDeviceSecret, deleteDeviceSecret, listDeviceSecrets, setDeviceSecretVisibility,
     applySecrets, applyDeviceSecrets,
     listDevices: () => identity.listDelegations(),
     // Acta del perfil (quién es del perfil y qué puede cada uno): lo que muestran
     // `dotrino-vault members` y la consola de vault.dotrino.com.
     profileMembers: () => identity.profileMembers(),
+    // Los namespaces que quedaron a deber una rotación (se fue un miembro y no se pudo
+    // rotar su llave). Lo enseñan `secret list` y la consola: si no se ve, no se salda.
+    rotationsDue,
+    secretDebts,
     // ¿Es ESTA bóveda la que sella el acta? Lo usa el freno de borrado (D12).
     isMaster: () => identity.isMaster(),
     setCaps: async (pub, caps) => {
@@ -920,6 +1723,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return r
     },
     close () {
+      clearInterval(approvalsSweeper)
       for (const t of pendingNotices.values()) clearTimeout(t)
       pendingNotices.clear()
       try { client.close() } catch (_) {} identity.destroy()