@dotrino/vaultd 0.155.0 → 0.157.0

package/src/vault.js

@@ -1,4459 +1,14 @@
 /**
- * dotrino-vault — núcleo del certificador personal (daemon headless).
- *
- * Custodia la clave MAESTRA del usuario (vía `@dotrino/identity`) y la expone como
- * CA propia. EMPAREJAMIENTO ENDURECIDO (ver docs/pairing-protocol.md): el token de
- * 5 min ya NO es autoridad suficiente — para obtener un cert el dispositivo debe
- * (1) PROBAR posesión de su llave D firmando el ENROLL, y (2) el dueño debe APROBAR
- * en el PC tras comparar un SAS (código de 6 dígitos) entre las dos pantallas. La
- * maestra solo firma el cert DESPUÉS de esa aprobación humana.
- *
- * Toda la cripto es de `@dotrino/identity`. Este módulo solo orquesta.
+ * LA BÓVEDA DEL BINARIO: el núcleo compartido (`lib/src/core/vault.js`) con lo que pone
+ * Node (`./platform.js`). La pestaña y la extensión corren el MISMO núcleo con la
+ * plataforma del navegador, y por eso las tres bóvedas hacen lo mismo.
  */
-import fs from 'node:fs'
-import nodeCrypto from 'node:crypto'
-import path from 'node:path'
-import { Identity } from '@dotrino/identity/node'
-import { verifyChain as verifyChainRaw, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
-import { createLoginDesk, registerLogin, vaultChannel, accountFingerprint } from '../lib/src/passwordLogins.js'
-import * as ActaPilar from '@dotrino/identity/acta'
-import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, scopeToCaps, scopeToCn } from '../lib/src/enroll.js'
-import { createAdminDesk, authorBody } from '../lib/src/admin.js'
-import { shouldNotifyRevoked } from '../lib/src/revocation.js'
-// El sobre del gestor, el mismo que usan la bóveda-en-pestaña y la extensión.
-import { identitySealing } from '@dotrino/passmanager'
-import { createTransport, masterPubkeyOf } from './transport.js'
-import { startSealersPublisher } from './sealers.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, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
-import { openSubacta } from './subacta.js'
-import { openBlocked } from './blocked.js'
-import { openNotifiable } from './notifiable.js'
-import { openMachines } from './machines.js'
-import { machineLine } from '@dotrino/identity/machine'
-import { openNotices } from './notices.js'
-import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
-import { VERSION } from './version.js'
-import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
-import { loadManifest, brokenOf } from '@dotrino/roadmap'
-// `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, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_TTL_MS, UPDATE_TTL_MS } from './approvals.js'
-import { readProcContext, sanitizeContext, commandFingerprint, commandLine } from '../lib/src/proc.js'
-import { makeContentKey, encryptWithCek, wrapForMember } from '@dotrino/identity/content'
-import { makeSealer } from './sealer.js'
-import { openSealKeys } from './sealKey.js'
-import { openCommKey, COMM_CN, COMM_CAPS } from './commKey.js'
-import { seal } from '../lib/src/sealed.js'
-import { localSocketPath, socketDir } from '../lib/src/localdesk.js'
-import { dataDir, ensureDir } from './paths.js'
-import net from 'node:net'
-import os from 'node:os'
-import { atRestFor, kekFor, migrateFile, encryptText, decryptText } from './atrest.js'
-import { MSG, SCOPE, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
+import { startVault as startVaultCore } from '../lib/src/core/vault.js'
+import { nodePlatform } from './platform.js'
+import { dataDir } from './paths.js'
 
-/**
- * Tope de una respuesta de la bóveda por el transporte. El proxio (`PROXY_MAX_FRAME_BYTES`)
- * corta el frame a 1 MB, y el sobre del proxio (destinatarios, tipos) va por encima de esto:
- * se deja margen en vez de apurar el límite.
- */
-const MAX_REPLY_BYTES = 768 * 1024
-
-/**
- * Abre UN perfil del vault (una maestra, un dir, una conexión al proxy). El
- * daemon multi-perfil (`manager.js`) levanta uno de estos por perfil.
- *
- * @param {Object} [opts]
- * @param {string} [opts.dir]        Dir de datos de ESTE perfil.
- * @param {() => boolean} [opts.isLocked]  Candado del perfil (contraseña opcional).
- *   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, hasPassword = () => true, deriveAdminKey = null, openKey = null, secondaryParams = null, openWithSecondary = null, hasSecondary = () => false, 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
-  // antes de reemplazar); el resto —`vault.json`, `threads.json`, `secrets.json`— lo hace
-  // su propio store al abrirse. No protege contra quien ya tiene ESTA
-  // 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'), 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) }
-  /**
-   * EL CANDADO DE LA MAESTRA. La mitad privada se guarda sellada con la llave que sale de
-   * la contraseña del perfil (`openKey`), no con la de la máquina: cerrada, la maestra no
-   * está en memoria y no hay con qué sacarla del disco.
-   *
-   * `open` devuelve `null` con el perfil cerrado, y el pilar entonces carga la identidad
-   * SIN con qué firmar — se sabe quién eres, no se puede hablar por ti. Un perfil sin
-   * contraseña no tiene `openKey`: se queda como estaba, bajo la llave de máquina, y la
-   * consola ya lo dice en voz alta.
-   */
-  const keyLock = {
-    seal: async (texto) => { const k = openKey?.(); return k ? encryptText(texto, k) : null },
-    open: async (blob) => { const k = openKey?.(); if (!k) return null; try { return decryptText(blob, k) } catch (_) { return null } }
-  }
-  const identity = await Identity.connect({ dir, atRest: atRestFor(dir), keyLock })
-  // 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`
-  // acepte cambiar su acta recién nacida por la que traiga el dispositivo. Sin la marca,
-  // adoptar sería pisar una cuenta con datos y se rechaza — que es lo correcto por defecto.
-  if (forAdoption) {
-    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)
-  const commKey = openCommKey(dir)
-  identity.setSealKeyProvider?.(() => sealKeys.mint())
-
-  const store = openStore(dir)
-  const threads = openThreadStore(dir)
-  /**
-   * LO QUE SIRVE LA BÓVEDA VA CON LA LLAVE VIGENTE (dueño, 2026-09-30). Tras una rotación
-   * de la llave de la cuenta, los sobres (`t: 'dotrino-cek'`) de generaciones anteriores
-   * que haya en el almacén se vuelven a cerrar con la vigente. Se llama al abrir y después
-   * de quitar un aparato. Si la bóveda no tiene la llave de contenido, no hay nada que
-   * hacer y se dice; si un sobre no abre, se para y se dice — no se deja a medias.
-   */
-  async function resealStaleThreads (why) {
-    const mine = await identity.contentKey?.()
-    if (!mine) { log(`[vault] ${why}: no content key on this vault, envelopes not resealed`); return null }
-    const r = await threads.resealStaleEnvelopes({
-      gen: mine.gen,
-      reseal: async (env) => identity.sealContent(await identity.openContent(env))
-    })
-    if (r.changed) {
-      audit('resealed', { envelopes: r.changed, entries: r.entries, gen: mine.gen })
-      log(`[vault] ${why}: resealed ${r.changed} envelope(s) in ${r.entries} entr${r.entries === 1 ? 'y' : 'ies'} with content key generation ${mine.gen}`)
-    }
-    if (r.skipped) log(`[vault] ${why}: ${r.skipped} unmarked envelope(s) that the account key does not open were left as they are`)
-    return r
-  }
-  const approvals = createApprovals()
-  /**
-   * LO QUE YA SE APROBÓ: comando + carpeta, por una hora desde el último uso.
-   *
-   * En memoria a propósito. Reiniciar la bóveda las borra todas, que es lo correcto: un
-   * permiso que sobrevive a un reinicio es un permiso que nadie recuerda haber dado.
-   */
-  const grants = createGrants()
-
-  /**
-   * Pedidos de aprobación que NO son de un cajón de secretos: quien espera es una
-   * promesa dentro del vault (la bóveda de contraseñas), no un aparato aguardando un
-   * sobre sellado. `id` del pedido → `resolve(boolean)`.
-   *
-   * Aparte a propósito: `approvals` es un módulo puro y no tiene por qué saber que hay
-   * dos clases de espera.
-   */
-  const waiters = new Map()
-  /**
-   * ¿ESTE APARATO TIENE QUE PEDIR PERMISO PARA RECIBIR CLAVES PRIVADAS?
-   *
-   * Lo dice el ACTA, con el permiso `unattended`: quien lo tiene se las lleva solo; quien
-   * no, espera a que un aparato con `approve` lo firme.
-   *
-   * Antes era al revés y vivía aquí: una lista local de «estos SÍ piden permiso», así que
-   * un aparato nuevo nacía pudiendo llevarse las claves y nadie elegía eso — se elegía por
-   * omisión. Ahora hay que conceder a propósito quién puede llevárselas solo, y **si falta
-   * el dato se pide permiso**, que es lo que hay que hacer cuando no se sabe (dueño,
-   * 2026-09-01).
-   *
-   * Y al estar en el acta lo respeta cualquier bóveda de la cuenta, se ve en la pantalla de
-   * permisos como los demás, y se quita quitándolo — sin acordarse de un registro escondido
-   * en una máquina.
-   */
-  /** ¿Hay en el acta alguien que pueda aprobar? Sin nadie, no se pide aprobación. */
-  function hasApprover (record) {
-    return !!record?.members?.some((m) => Acta.memberCan(record, m.pub, 'approve'))
-  }
-
-  function needsApproval (pub, record) {
-    if (!record) return true          // sin acta no se decide que sí: se pide permiso
-    // SIN NADIE QUE APRUEBE, NO SE NECESITA APROBACIÓN (dueño, 2026-09-24: «la regla es, si
-    // no hay aprobador no se necesita aprobación»). Es la misma que ya seguía la
-    // actualización automática: esperar un sí que nadie puede dar solo deja al servicio
-    // colgado. Aquí se decide para las tres puertas —entregar claves, contraseñas y guardar
-    // variables— y por eso no hay un «nadie aprueba» aparte en ninguna de ellas.
-    if (!record.members?.some((m) => Acta.memberCan(record, m.pub, 'approve'))) return false
-    return !Acta.memberCan(record, pub, 'unattended')
-  }
-
-  /**
-   * APUNTA UN PEDIDO QUE NO ENTREGA UN CAJÓN, avisa a quien aprueba y deja la respuesta en
-   * `onAnswer(sí|no)`. Lo usan la bóveda de contraseñas (un aparato espera su sí) y guardar
-   * variables (la escritura se aplica al aprobar). Si nadie contesta, vence solo con un no:
-   * nada se queda colgado para siempre.
-   */
-  async function awaitApproval ({ device, ns, kind, what, op = null, ctx = null, onAnswer, ttlMs = PENDING_TTL_MS }) {
-    const deviceId = await deviceIdOf(device).catch(() => null)
-    const record = await refreshActa()
-    const label = (record?.members || []).find((m) => m.pub === device)?.label || ''
-    const pend = approvals.request({ ns, device, deviceId, label, ek: '', ctx, kind, ttlMs })
-    audit(`${what}.pending`, { device: deviceId, ns, id: pend.id, op })
-    log(`[vault] ${what}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
-    waiters.set(pend.id, onAnswer)
-    const t = setTimeout(() => {
-      if (waiters.delete(pend.id)) {
-        audit(`${what}.expired`, { device: deviceId, ns, id: pend.id })
-        onAnswer(false)
-      }
-    }, ttlMs)
-    t.unref?.()
-    await notifyApprovers(pend, record)
-    return pend
-  }
-
-  /**
-   * QUÉ COMANDO ESTÁ PIDIENDO LAS CLAVES, Y DESDE QUÉ CARPETA — medido, no creído.
-   *
-   * Quien aprueba no puede decidir con «el aparato 904C-1002 pide el cajón proxy»: necesita
-   * ver qué se está ejecutando (dueño, 2026-09-11). El que pide lo cuenta en el pedido, pero
-   * contar no es probar, así que **si dice estar en esta misma máquina la bóveda lo lee del
-   * kernel** (`/proc/<pid>`) y lo compara. Si no cuadra, no es un matiz: es una mentira, y se
-   * deniega con un código que se puede buscar.
-   *
-   * SE MIRA EL PEDIDO, NUNCA EL CANAL. Sería más cómodo comprobar «vino por el socket local»,
-   * y está prohibido: el día que un handler decide algo por dónde entró el mensaje, el atajo
-   * local deja de ser un atajo y pasa a ser una puerta de atrás (`test/mostrador-local.test.mjs`).
-   * El `host` es un dato del pedido como cualquier otro, y mentirlo no consigue nada: lo que
-   * se gana es quedar marcado como no comprobado, que es exactamente lo que se quería evitar.
-   *
-   * Tres resultados, y son tres cosas distintas:
-   *   · `null` — no dijo nada. Se pide aprobación como siempre y no hay concesión posible.
-   *   · `verified: 'proc'` — lo leyó el kernel de esta máquina. Es lo que hay que enseñar.
-   *   · `verified: 'declared'` — lo dice quien pide y no hay forma de comprobarlo (otra
-   *     máquina, o un sistema sin `/proc`). Vale para decidir, pero la pantalla lo marca.
-   *
-   * Y EL LÍMITE, QUE NO SE ESCONDE: esto no autoriza nada. Cualquier proceso del mismo
-   * usuario puede leer el `service-identity.json` del servicio y pedir con esa llave, y puede
-   * llamarse como quiera. La frontera es el usuario, no el proceso: esto existe para que
-   * quien aprueba decida mirando lo que pasa, y para que quede rastro.
-   */
-  function contextoDelPedido (declarado) {
-    const dicho = sanitizeContext(declarado)
-    if (!dicho) return null
-    // Otra máquina: aquí no hay ningún `/proc` que hable de ese proceso.
-    if (!dicho.host || dicho.host !== os.hostname()) return { ...dicho, verified: 'declared' }
-    const medido = sanitizeContext(readProcContext(dicho.pid))
-    // El proceso ya no está, o no se puede mirar: no se sabe, y no saber se dice como no
-    // saber. Inventar un «comprobado» aquí sería el repliegue de siempre.
-    if (!medido) return { ...dicho, verified: 'declared' }
-    if (commandFingerprint(medido) !== commandFingerprint(dicho)) {
-      throw new Error(`ctx — it says it is running "${commandLine(dicho, 60)}" but pid ${dicho.pid} is "${commandLine(medido, 60)}"`)
-    }
-    return { ...medido, user: dicho.user, host: dicho.host, verified: 'proc' }
-  }
-  // LA BÓVEDA DE CONTRASEÑAS: entradas y su llave, en el dir del perfil y cifradas en
-  // reposo como todo lo demás. QUIÉN PUEDE PEDIR LO DICE EL ACTA (capacidad
-  // `passwords`), como cualquier otro permiso: aquí no hay una segunda lista de
-  // aparatos. Tenerla obligaba a acordarse de dos sitios al quitar un aparato, y era
-  // además un emparejamiento paralelo al del ecosistema.
-  const passwordsFile = path.join(dir, 'passwords.json')
-  const passwordsAtRest = atRestFor(dir)
-  // Los aparatos BLOQUEADOS por un aprobador (`src/blocked.js`). Cifrado en reposo como lo demás.
-  const blocked = openBlocked({ dir, atRest: passwordsAtRest })
-  // Qué aprobadores dijeron que pueden recibir avisos (`src/notifiable.js`). No decide nada: se enseña.
-  const notifiable = openNotifiable({ dir, atRest: passwordsAtRest })
-  // Dónde corre cada aparato, según lo último que dijo firmado (`src/machines.js`). Se enseña.
-  const machines = openMachines({ dir, atRest: passwordsAtRest })
-  // Lo que hay que contarle a quien aprueba y no es un pedido (`src/notices.js`): hoy, «me actualicé».
-  const notices = openNotices({ dir, atRest: passwordsAtRest })
-  const readPasswordsFile = () => {
-    try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
-  }
-  const writePasswordsFile = (d) => {
-    fs.writeFileSync(passwordsFile, passwordsAtRest.encrypt(JSON.stringify(d)), { mode: 0o600 })
-  }
-
-  /** El almacén que espera `@dotrino/passmanager`. Todo en un archivo, cifrado en reposo. */
-  const passwordsStore = {
-    async get (k) { return readPasswordsFile()?.data?.[k] },
-    async set (k, v) {
-      const d = readPasswordsFile() || { v: 1, data: {} }
-      d.data = { ...(d.data || {}), [k]: v }
-      writePasswordsFile(d)
-    },
-  }
-
-  // ENTRAR CON USUARIO Y CONTRASEÑA (`passwordLogins.js`). Va cifrado en reposo con la llave
-  // de la MÁQUINA y no con la de la contraseña del perfil, por lo mismo que la llave de
-  // comunicación: entrar tiene que funcionar con el perfil cerrado. Lo que hay dentro no
-  // abre nada por sí solo — el registro de OPAQUE no deja probar contraseñas sin el
-  // protocolo, y el paquete de llaves está cerrado con la llave que sale de la contraseña.
-  const loginsFile = path.join(dir, 'logins.json')
-  const loginsAtRest = atRestFor(dir)
-  const logins = createLoginDesk({
-    load: () => { try { return JSON.parse(loginsAtRest.decrypt(fs.readFileSync(loginsFile, 'utf8'))) } catch (_) { return null } },
-    save: (state) => fs.writeFileSync(loginsFile, loginsAtRest.encrypt(JSON.stringify(state)), { mode: 0o600 })
-  })
-
-  /** Los aparatos que el acta autoriza a pedir credenciales (`caps <ID> +contraseñas`). */
-  const passwordDevices = () => (actaCache?.members || []).filter((m) => Acta.memberCan(actaCache, m.pub, 'passwords'))
-
-  /**
-   * A QUIÉN SE LE ENVUELVE LA LLAVE DE UNA CONTRASEÑA — Y LA BÓVEDA NUNCA ESTÁ EN LA LISTA.
-   *
-   * Es la comprobación que sostiene todo el modelo sellado: si la maestra o la llave de
-   * comunicación de esta máquina recibieran envoltura, el demonio volvería a poder leer las
-   * contraseñas y no habríamos arreglado nada —solo lo habríamos escrito más bonito—. Por
-   * eso se filtran explícitamente aquí, que es donde se construye la lista, y no en quien la
-   * consume (`sealed-passwords.md` §2.1).
-   *
-   * `main` son los aparatos con `contraseñas`; `passkeys`, los que además pueden abrir la
-   * privada de una passkey (§2.8). Un miembro sin llave de cifrado no puede recibir nada: se
-   * queda fuera y se ve en `incompleteMembers`.
-   */
-  const noEsLaBoveda = (pub) => pub !== master && pub !== commKey.pub()
-  const passwordRecipients = (kind = 'main') => (actaCache?.members || [])
-    .filter((m) => m.encPub && noEsLaBoveda(m.pub) && Acta.memberCan(actaCache, m.pub, 'passwords'))
-    .filter((m) => kind !== 'passkeys' || Acta.memberCan(actaCache, m.pub, 'passkeys'))
-    .map((m) => ({ pub: m.pub, encPub: m.encPub }))
-
-  /**
-   * El acta vigente, en caché.
-   *
-   * `isAllowed`/`encPubOf` del responder son SÍNCRONOS (se llaman por cada mensaje que
-   * entra, y leer el acta ahí sería un await por mensaje), así que se refresca aparte.
-   * Se relee cada pocos segundos: revocar un aparato tarda eso en cortarle el acceso,
-   * no un reinicio.
-   */
-  let actaCache = null
-  const refreshActa = async () => {
-    try { actaCache = (await identity.profileActa?.().catch(() => null))?.acta || null } catch (_) {}
-    return actaCache
-  }
-
-  /**
-   * LA LLAVE VIEJA DE LA BÓVEDA DE CONTRASEÑAS, la que había que quitar.
-   *
-   * Vivía DENTRO del mismo archivo que las entradas, cifrada con la llave de la máquina y
-   * no con la contraseña del perfil. O sea: el demonio con el perfil cerrado seguía
-   * descifrando, y una copia del disco las abría todas. Esto ya no la crea — solo la LEE,
-   * y solo para convertir lo que quedó escrito con ella; en cuanto la conversión termina,
-   * `soltarLlaveVieja` la borra del archivo.
-   */
-  async function llaveViejaDeContrasenas () {
-    const d = readPasswordsFile()
-    if (!d?.cek) return null
-    const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
-    return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
-  }
-  const soltarLlaveVieja = () => {
-    const d = readPasswordsFile()
-    if (!d?.cek) return
-    delete d.cek
-    writePasswordsFile(d)
-    log('[vault] passwords: the old vault key is gone from the disk')
-    audit('passwords.converted', {})
-  }
-
-  const approvalsSweeper = setInterval(() => {
-    for (const g of approvals.sweep()) audit('secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId })
-    // Las concesiones vencidas también se anotan: si un servicio vuelve a timbrar el
-    // teléfono, esta línea es la que explica por qué (estuvo una hora sin pedir).
-    for (const g of grants.sweep()) audit('secrets.grant.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, opts) => recipientsOf(owner, opts),
-    // La FIRMA del sobre: dice que salió de esta bóveda y con qué acta (§8.8).
-    signer: (body) => signSeal(body),
-    // CON QUÉ se cierra la copia de recuperación cuando quien llama no trajo la frase:
-    // la llave del perfil si está ABIERTO, y si no la de la máquina. El orden importa —
-    // un perfil CON contraseña no se abre con la llave de la máquina, así que sin lo
-    // primero un aparato enrolado con la bóveda abierta se quedaba sin su cajón y solo
-    // se enteraba al arrancar (dueño, 2026-08-31).
-    defaultKey: () => openKey?.() || 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
-  // 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)
-  /**
-   * LA HUELLA DE LA CUENTA, no la de esta bóveda. Sale del `profileId` del acta (la pieza
-   * compartida la calcula), y con ella se arman la dirección `nombre@AB12-CD34-EF56` y el
-   * canal donde se anuncia esta cuenta.
-   *
-   * Antes salía de la llave de ESTA bóveda. Coinciden mientras la cuenta haya nacido aquí,
-   * y dejan de coincidir en cuanto hay una réplica o la bóveda adoptó la cuenta de otro
-   * aparato: cada bóveda daba entonces una dirección distinta para la misma cuenta, y el
-   * canal las separaba justo cuando lo que hace falta es que se junten.
-   */
-  const fp = await accountFingerprint(identity)
-
-  /**
-   * 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
-    // CON EL PERFIL ABIERTO. Estrenar la llave de sellado SELLA EL ACTA, y una bóveda
-    // cerrada no sella nada — la misma regla que el bloque de abajo. Cerrada se queda sin
-    // llave y los sobres salen sin firma (lo que ya pasaba antes de §8.8), y se arregla sola
-    // la primera vez que alguien abra el perfil.
-    if (info?.isMaster && acta && !isLocked() && (!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) }
-
-  /**
-   * LA LLAVE DE COMUNICACIÓN, dentro del acta.
-   *
-   * La maestra sella el acta y reenvuelve sobres; hablar por la red no es suyo. Esta es la
-   * que se identifica ante el proxio, y su autoridad la dice el ACTA: entra como un miembro
-   * más, con `cn: 'vault'`, así que el acta la trata como un servicio del perfil — puede
-   * hablar por la bóveda, no firmar por la persona.
-   *
-   * Solo se puede meter con el perfil ABIERTO (admitir un miembro es sellar el acta, y eso
-   * es de la maestra). Con el perfil cerrado no se toca nada: si ya está, se usa; y si no,
-   * `identify` se repliega a la maestra y lo dice. Por eso una bóveda que se actualiza
-   * tiene que abrirse UNA vez, y a partir de ahí ya puede vivir cerrada.
-   */
-  /**
-   * METER LA LLAVE DE COMUNICACIÓN EN EL ACTA, si el perfil está abierto.
-   *
-   * `isLocked()` es la pregunta correcta — no `masterLocked`. Se coló así: en la PRIMERA
-   * arrancada tras actualizar, la maestra todavía está guardada en claro (se sella al abrir
-   * el perfil), o sea que `masterLocked` es `false` aunque el perfil esté cerrado. Con ese
-   * guardián, la bóveda de producción admitió su llave de comunicación y SELLÓ UN ACTA
-   * NUEVA (#76 → #77) estando cerrada — justo lo que la regla prohíbe, y encima rotando de
-   * paso la llave de sellado sin que nadie lo pidiera.
-   *
-   * SE LLAMA TAMBIÉN AL ABRIR, y esa es la mitad que faltaba. Antes solo corría al arrancar
-   * el servicio, y **un perfil con contraseña arranca cerrado siempre**: nunca pasaba por
-   * aquí, así que jamás llegaba a tener su llave. O sea que los perfiles que MÁS la
-   * necesitan —los protegidos, los que no pueden firmar con la maestra estando cerrados—
-   * eran precisamente los únicos que se quedaban sin ella, y seguían identificándose con la
-   * maestra o quedándose mudos. Se vio el 2026-09-02: de dos perfiles, el que tenía
-   * contraseña era el que no tenía `commkey.json`.
-   */
-  async function ensureCommKeyInActa () {
-    try {
-      const info = await identity.profileActa?.()
-      const acta = info?.acta
-      if (!acta || isLocked() || identity.masterLocked) return false
-      const pub = await commKey.ensure()
-      if ((acta.members || []).some((m) => m?.pub === pub)) return false
-      if (!info?.isMaster) return false
-      await identity.admitMember({ pub, label: 'esta bóveda', cn: COMM_CN, caps: [...COMM_CAPS] })
-      log('[vault] this vault is now a member of its own record: it talks with its own key, not the master one')
-      return true
-    } catch (e) {
-      log('[vault] could not put the communication key in the record:', e.message)
-      return false
-    }
-  }
-  await ensureCommKeyInActa()
-
-  // `announce`: el canal de ESTA cuenta, para que una máquina prestada —que no tiene
-  // ninguna llave y solo sabe la dirección `nombre@AB12-CD34-EF56`— pueda encontrar a quien
-  // la atiende. Lo construye la pieza compartida, porque quien lo busca es la extensión.
-  const { client, identify: reidentificar, isIdentified } = await createTransport({
-    identity, dir, url: proxyUrl, commKey, log, announce: vaultChannel(fp)
-  })
-
-  // El registro público de cadenas de selladores: deposita, si hay a dónde, los eslabones
-  // que le dicen a un tercero si esta cuenta sigue sellada por quien él cree. Ver
-  // `sealers.js` — es una comodidad para quien lee, nunca una dependencia de la bóveda.
-  startSealersPublisher({ identity, client, log })
-
-  async function revocationSet () {
-    const { revoked } = await identity.listDelegations()
-    return new Set(revoked.map((r) => r.nonce))
-  }
-
-  /**
-   * CONTESTAR SIN MATAR LA CONEXIÓN.
-   *
-   * El proxio corta los frames a 1 MB (`maxPayload`), y `ws` no «descarta» el que se pasa:
-   * CIERRA EL SOCKET con un 1009. La bóveda se queda muda, sin un solo error en su log, y
-   * desde fuera se ve igual que si estuviera apagada. Eso ya pasó y duró tres días.
-   *
-   * Así que una respuesta que no quepa no se manda: se sustituye por un error, que sí cabe.
-   * Una bóveda que dice «no cabe» se arregla; una muda no se puede ni diagnosticar.
-   */
-  /**
-   * QUIÉN CONTESTA A QUIÉN. Por defecto el proxio; un remitente LOCAL (el socket de esta
-   * máquina) se apunta aquí con su propia forma de contestar.
-   *
-   * Que haya dos transportes no cambia NADA de quién puede pedir qué: la autorización sale
-   * del certificado y del acta, igual por los dos caminos. Alcanzar el socket no autoriza
-   * nada — es la misma puerta, con el camino más corto.
-   */
-  const canales = new Map()
-
-  /**
-   * QUÉ SOMOS, Y QUÉ CORRE CADA APARATO (CONVENCIONES §14, `@dotrino/compat`).
-   *
-   * El agujero que esto tapa: una incompatibilidad de versiones se manifestaba como
-   * SILENCIO. El que llamaba no sabía si estábamos apagados, ocupados o hablando otro
-   * idioma, así que reintentaba para siempre — y aquí no se sabía que nos hablaban.
-   *
-   * **Informa, no bloquea** (dueño, 2026-09-04): el dictamen se enseña y se le pega a los
-   * errores, y no hay ni un `if` que deje de atender por él. Si algún día se decide
-   * bloquear, se decide arriba y se escribe aquí a propósito.
-   *
-   * La lista de rotas sale del registro común (`@dotrino/roadmap`), que viaja DENTRO de
-   * esta versión: la compatibilidad es política del código, no de la cuenta.
-   */
-  const MI_VERSION = compatDeclare({
-    product: 'vaultd', version: VERSION, protocol: VAULT_PROTOCOL, speaks: VAULT_SPEAKS
-  })
-  let ROTAS = []
-  try { ROTAS = brokenOf(loadManifest()) } catch (e) { log('[vault] no compatibility registry: ' + e.message) }
-
-  /**
-   * Lo que dice correr cada aparato, por llave. Se apunta de lo que viene FIRMADO
-   * (`p.data.v`, dentro del sobre) y no del envoltorio: una versión que cualquiera puede
-   * escribir no vale para enseñarla como si fuera un dato.
-   */
-  const versiones = new Map()
-  const apuntarVersion = (pub, v) => {
-    if (!pub || !v) return
-    const dictamen = compatCheck({ mine: MI_VERSION, theirs: v, broken: ROTAS })
-    versiones.set(pub, { ...v, at: Date.now(), compatible: dictamen.compatible, reason: dictamen.reason })
-    if (!dictamen.compatible) log(`[vault] ${v.product} ${v.version}: ${dictamen.reason}`)
-    return dictamen
-  }
-  /** El dictamen de un aparato, para enseñarlo o para pegárselo a un error. */
-  const versionDe = (pub) => versiones.get(pub) || null
-  /** Dónde corre un aparato: lo último que dijo firmado (`machines`) o, si no, lo del acta. */
-  const machineOf = (pub, record) => machines.of(pub) || (record?.members || []).find((m) => m.pub === pub)?.machine || null
-
-  // ----- LA SUBACTA: lo decidido que todavía no selló el acta (`src/subacta.js`) -----
-  //
-  // Sellar es de la maestra, así que con el perfil CERRADO una renuncia no surtía ningún
-  // efecto: el aparato conservaba todos sus permisos hasta que alguien fuera a la máquina
-  // a teclear la contraseña. Justo el caso que la renuncia existe para cubrir.
-  //
-  // Se honra ya, sin sellar, y es seguro porque una entrada de la subacta SOLO PUEDE
-  // QUITAR: no concede nada a nadie, y va firmada por el miembro al que afecta.
-  const subacta = openSubacta(dir, atRestFor(dir))
-
-  /**
-   * EL ACTA, LEÍDA CON LA SUBACTA EN LA MANO.
-   *
-   * Envuelve al pilar en UN sitio en vez de pasar la lista en los diecisiete mostradores:
-   * una comprobación repetida diecisiete veces son dieciséis sitios donde olvidarla, y
-   * olvidarla aquí significa atender a un aparato que ya renunció.
-   *
-   * Solo se tocan las cinco que DECIDEN. El resto del pilar pasa tal cual.
-   */
-  const Acta = {
-    ...ActaPilar,
-    memberCan: (acta, pub, cap) => ActaPilar.memberCan(acta, pub, cap, subacta.forMember(pub)),
-    memberCanScope: (acta, pub, scope) => ActaPilar.memberCanScope(acta, pub, scope, subacta.forMember(pub)),
-    memberCanReadSecrets: (acta, pub, ns) => ActaPilar.memberCanReadSecrets(acta, pub, ns, subacta.forMember(pub)),
-    memberCanSign: (acta, pub, ns = null) => ActaPilar.memberCanSign(acta, pub, ns, subacta.forMember(pub)),
-    memberScopes: (acta, pub) => ActaPilar.memberScopes(acta, pub, subacta.forMember(pub)),
-    effectiveCaps: (acta, pub) => ActaPilar.effectiveCaps(acta, pub, subacta.forMember(pub))
-  }
-
-  /**
-   * ABSORBER lo pendiente en el acta. Solo con la bóveda abierta, que es la única que
-   * sella. Se vacía DESPUÉS y solo lo absorbido: mientras se sella puede entrar una nueva,
-   * y tirarla sería perder una renuncia sin aplicar.
-   */
-  async function absorberSubacta (motivo = 'unlock') {
-    const pendientes = subacta.drain()
-    if (!pendientes.length) return 0
-    const hechas = []
-    for (const e of pendientes) {
-      try { await identity.absorbRenounce(e); hechas.push(e) }
-      catch (err) { log(`[vault] ${motivo}: could not absorb a pending renounce: ${err.message}`) }
-    }
-    if (hechas.length) {
-      subacta.clear(hechas)
-      log(`[vault] ${motivo}: ${hechas.length} pending renounce(s) absorbed into the record`)
-    }
-    return hechas.length
-  }
-
-  /**
-   * LA VERSIÓN SE APUNTA DONDE YA SE COMPRUEBA LA FIRMA, y por eso esto envuelve a
-   * `verifyChain` en vez de mirar el envoltorio del mensaje: `data` va firmado, así que
-   * lo que se apunta es lo que ese aparato dijo **con su llave**, no lo que cualquiera
-   * pueda escribir por fuera. Un inventario de versiones que se puede falsificar no es un
-   * inventario, es una pantalla bonita.
-   *
-   * Va envuelto y no repetido en los ocho mostradores porque una comprobación copiada
-   * ocho veces son siete sitios donde olvidarla.
-   */
-  const verifyChain = async (args) => {
-    const chk = await verifyChainRaw(args)
-    if (chk.ok && args?.data?.v) apuntarVersion(chk.device, args.data.v)
-    // DÓNDE CORRE, por el mismo motivo: se apunta de lo firmado. Un fallo al guardarlo no
-    // puede tumbar el pedido —es un dato para la lista—, pero se dice.
-    if (chk.ok && args?.data?.machine) {
-      try { machines.note(chk.device, args.data.machine) } catch (e) { log(`[vault] could not record where a device runs: ${e.message}`) }
-    }
-    // UN BLOQUEADO NO PASA POR NINGÚN MOSTRADOR. Sigue en el acta —bloquear no la toca,
-    // porque la bóveda vive cerrada y eso lo decide un aprobador desde el teléfono—, así que
-    // el papel verifica; la puerta se cierra aquí, que es por donde entra todo, y con su
-    // propio `reason` para que el otro lado sepa qué le pasa y no lo confunda con un papel
-    // viejo (que se arregla renovando) ni con una revocación (que se arregla emparejando).
-    if (chk.ok && blocked.has(chk.device)) return { ok: false, reason: 'blocked', device: chk.device }
-    return chk
-  }
-
-
-  const reply = (to, obj) => {
-    try {
-      const enviar = canales.get(to) || ((o) => client.send(to, o))
-      // ANUNCIAMOS EN CADA RESPUESTA: el otro lado decide con esto, y decide él porque es
-      // el que puede tener la lista al día (§14). Va en el envoltorio y no dentro de un
-      // cuerpo firmado a propósito — es un dato para enseñar y para explicar un fallo, no
-      // una credencial: nada se autoriza con él.
-      obj = { ...obj, v: MI_VERSION }
-      const bytes = Buffer.byteLength(JSON.stringify(obj))
-      if (bytes > MAX_REPLY_BYTES) {
-        log(`[vault] the reply to ${obj?.type} does not fit (${bytes} bytes > ${MAX_REPLY_BYTES}): sending an error instead of killing the connection`)
-        audit('reply-too-big', { type: obj?.type || null, bytes })
-        return enviar({ type: MSG.ERROR, error: `reply too big (${bytes} bytes): ask for less at a time` })
-      }
-      enviar(obj)
-    } catch (e) { log('[vault] could not reply:', e.message) }
-  }
-
-  // FRESCURA anti-replay: toda petición firmada debe traer `data.ts` dentro de una
-  // ventana de ±5 min (mismo criterio que el identify del proxy). Sin esto, un
-  // relay malicioso podía REPRODUCIR mensajes firmados viejos (re-pedir firmas,
-  // abrir renovaciones…) durante toda la vida del cert.
-  // AUDITORÍA: bitácora de actividad de seguridad (activity.log, JSONL) — qué
-  // dispositivo firmó/renovó/enroló y qué se rechazó. `dotrino-vault activity`
-  // la muestra. Sin contenido de payloads (privacidad): solo op, dispositivo, hora.
-  //
-  // VA CIFRADA, y una línea a la vez. Antes era el único archivo excluido del reposo, con
-  // el argumento de que «no guarda payloads»: no guarda valores, pero sí el mapa entero de
-  // la cuenta —qué aparatos hay, con qué permisos, contra qué cajones y a qué hora—, que
-  // es justo lo que quiere quien está eligiendo por dónde entrar. Y encima se creaba 0664,
-  // legible por cualquier usuario de la máquina.
-  //
-  // Cifrar por línea (y no el archivo entero) es lo que deja seguir AÑADIENDO: cada
-  // entrada se cierra sola, así que un `appendFileSync` sigue costando lo mismo y la
-  // rotación no necesita abrir nada.
-  const activityFile = path.join(dir, 'activity.log')
-  const activityAtRest = atRestFor(dir)
-  // MIGRACIÓN de las bitácoras escritas antes de 0.89, que están en claro. Se convierten
-  // de una vez al arrancar: es un archivo acotado (rota al MB) y así «nada en claro» es
-  // cierto también para lo que ya estaba escrito, no solo para lo que se escriba desde
-  // ahora. Se agota sola — cuando no queda ninguna línea en claro, no vuelve a tocar nada.
-  try {
-    const raw = fs.readFileSync(activityFile, 'utf8')
-    const lines = raw.split('\n')
-    if (lines.some((l) => l && !l.startsWith('DOTRINO-ATREST-v1.'))) {
-      const sealedLines = lines.map((l) => (l && !l.startsWith('DOTRINO-ATREST-v1.') ? activityAtRest.encrypt(l) : l))
-      // Escribir aparte y renombrar: a medio convertir, la bitácora sería ilegible entera.
-      fs.writeFileSync(activityFile + '.tmp', sealedLines.join('\n'), { mode: 0o600 })
-      fs.renameSync(activityFile + '.tmp', activityFile)
-      // Sin `%d`: el `log` de la bóveda no formatea, así que el placeholder salía literal.
-      log(`[vault] activity log: ${sealedLines.filter(Boolean).length} line(s) sealed at rest`)
-    }
-    // Y el modo, que hasta 0.89 se creaba 0664: legible por cualquier usuario.
-    if ((fs.statSync(activityFile).mode & 0o077) !== 0) fs.chmodSync(activityFile, 0o600)
-  } catch (_) { /* no hay bitácora todavía */ }
-  /**
-   * LA BITÁCORA ES UNA CADENA, no una lista de líneas sueltas.
-   *
-   * Cifrarla (0.89) le dio confidencialidad y ninguna integridad: quien tenga la llave de
-   * la máquina puede reescribir una línea y nadie lo nota. Como evidencia no valía nada, y
-   * eso es justo lo que un auditor mira (`CUMPLIMIENTO.md` §2).
-   *
-   * Cada entrada lleva su `seq` y el **hash de la anterior**, así que tocar o quitar una
-   * rompe la cadena de ahí en adelante y se ve. Se encadena el TEXTO exacto de la línea,
-   * no un objeto re-serializado: así verificar no depende de que las claves salgan en el
-   * mismo orden.
-   *
-   * **Lo que esto NO resuelve, dicho para no venderlo de más:** quien tenga la máquina
-   * puede cortar el final de la cadena y quedarse con un prefijo válido. Eso no se cierra
-   * en local — pide anclar el último hash fuera (un TSA, otro aparato). Lo que sí cierra
-   * es reescribir el pasado sin dejar rastro, que es el caso que importaba.
-   */
-  const AUDIT_MAX_BYTES = 1024 * 1024
-  /** Cuántos archivos viejos se guardan. Es la RETENCIÓN, y va declarada. */
-  const AUDIT_KEEP = 5
-  const sha256 = (text) => nodeCrypto.createHash('sha256').update(text, 'utf8').digest('hex')
-
-  let auditSeq = 0
-  let auditPrev = null
-
-  /** Reconstruye el estado de la cadena leyendo la última entrada que haya. */
-  try {
-    const lines = fs.readFileSync(activityFile, 'utf8').split('\n').filter(Boolean)
-    for (let i = lines.length - 1; i >= 0; i--) {
-      try {
-        const text = activityAtRest.decrypt(lines[i])
-        const e = JSON.parse(text)
-        if (typeof e.logSeq === 'number') { auditSeq = e.logSeq; auditPrev = sha256(text); break }
-      } catch (_) { /* una línea vieja o ilegible: se sigue hacia atrás */ }
-    }
-  } catch (_) { /* no hay bitácora todavía */ }
-
-  /**
-   * ROTA ARCHIVANDO, NO TIRANDO. Antes se quedaba con la mitad del archivo y la otra mitad
-   * desaparecía sin que nada lo dijera: una bitácora que pierde historia en silencio es
-   * peor que no tenerla, porque parece completa. Ahora los viejos se corren a `.1`…`.N` y,
-   * cuando uno se cae del borde, **queda anotado que se cayó**.
-   */
-  const rotateAudit = () => {
-    let dropped = null
-    const older = `${activityFile}.${AUDIT_KEEP}`
-    try { if (fs.existsSync(older)) { fs.rmSync(older); dropped = `activity.log.${AUDIT_KEEP}` } } catch (_) {}
-    for (let i = AUDIT_KEEP - 1; i >= 1; i--) {
-      try { if (fs.existsSync(`${activityFile}.${i}`)) fs.renameSync(`${activityFile}.${i}`, `${activityFile}.${i + 1}`) } catch (_) {}
-    }
-    try { fs.renameSync(activityFile, `${activityFile}.1`) } catch (_) {}
-    return dropped
-  }
-
-  const audit = (op, info = {}) => {
-    try {
-      // LOS CAMPOS DE LA CADENA VAN AL FINAL Y CON NOMBRE PROPIO, y las dos cosas por el
-      // mismo motivo: que quien llama no pueda pisarlos.
-      //
-      // Estaban delante y se llamaban `seq`/`prev`, así que `...info` los sobrescribía. Y
-      // no era hipotético: `renew` ya mandaba un `seq` —el del ACTA, que no tiene nada que
-      // ver— y dejaba dos entradas seguidas numeradas igual. Lo cazó el propio verificador
-      // contra la bitácora de producción a los diez minutos de desplegarlo, que es
-      // exactamente para lo que sirve.
-      const entry = { ...info, ts: Date.now(), op, logSeq: ++auditSeq, logPrev: auditPrev }
-      const text = JSON.stringify(entry)
-      fs.appendFileSync(activityFile, activityAtRest.encrypt(text) + '\n', { mode: 0o600 })
-      auditPrev = sha256(text)
-      // El `mode` de `appendFileSync` solo aplica al CREAR: las bitácoras de antes de
-      // 0.89 ya existen con 0664 y hay que estrecharlas a mano.
-      try { if ((fs.statSync(activityFile).mode & 0o077) !== 0) fs.chmodSync(activityFile, 0o600) } catch (_) {}
-      if (fs.statSync(activityFile).size > AUDIT_MAX_BYTES) {
-        const dropped = rotateAudit()
-        // La primera entrada del archivo nuevo dice de dónde viene, y si se perdió algo.
-        audit('log.rotated', { keep: AUDIT_KEEP, ...(dropped ? { dropped } : {}) })
-      }
-    } catch (_) {}
-  }
-
-  const FRESH_WINDOW_MS = 5 * 60 * 1000
-  const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
-  const staleReply = (from) => reply(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
-
-  // --- ENROLL / aprobación / revocación: núcleo COMPARTIDO (lib/src/enroll.js) ---
-  // El mismo módulo lo usan «este dispositivo es bóveda» (@dotrino/vault) y la copia
-  // vendorizada del iframe de identidad: un solo sitio donde vive el flujo, y por lo
-  // tanto un solo sitio donde se comprueba el código antes de firmar el cert.
-  const desk = createEnrollDesk({
-    identity,
-    iss: master,
-    proxy: client.url,
-    send: (to, obj) => reply(to, obj),
-    sendByPubkey: (pub, obj) => client.sendByPubkey(pub, obj),
-    audit,
-    log,
-    // Camino A: lo que esta bóveda le manda al aparato para entrar en SU acta. La llave de
-    // cifrado es lo que le permite leer el contenido de la cuenta que va a custodiar; sin
-    // ella entraría mandando una cuenta que no puede abrir.
-    encPub: identity.me?.encryptionPubkey || null,
-    vaultLabel: 'bóveda',
-    // Lo único que lleva el QR corto: una CITA del proxio, que es un código de 6
-    // caracteres de un solo uso y con minutos de vida. Antes iba la dirección de
-    // la conexión, que eran 4 caracteres; hoy esa dirección es una instancia de
-    // 24 (para poder rutearla entre proxios) y no cabe cómoda en un QR ni
-    // conviene dejarla impresa en algo que circula. Se pide una por
-    // emparejamiento: si el proxio es viejo y no las conoce, se cae solo a la
-    // invitación larga, que sigue funcionando.
-    connToken: async () => {
-      try { return (await client.requestPairingCode())?.code || null }
-      catch (_) { return null }
-    },
-    onAdopted: (info) => { try { onAdopted?.(info) } catch (_) {} },
-    // Se va el aparato, se van SUS variables. Guardarlas sería configuración de una llave
-    // que ya no entra, y volvería a la vida sola el día que se enrole otro aparato con esa
-    // misma llave. Va aquí porque a quitar se entra por dos puertas (el PC y la consola
-    // remota) y las dos pasan por `desk.revokeDevice`.
-    onDeviceRemoved: (sub) => {
-      try {
-        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, machine }) {
-      log(`\n[vault] Un dispositivo quiere conectarse:`)
-      log(`        deviceId: ${deviceId}`)
-      if (machine) log(`        machine: ${machineLine(machine)}`)
-      log(`        Ingresa el código que MUESTRA el dispositivo:`)
-      log(`          dotrino-vault approve <código>    (o rechaza: dotrino-vault reject ${deviceId})\n`)
-      try { onEnrollChallenge?.({ deviceId, scope, machine: machine || null }) } catch (_) {}
-    }
-  })
-
-  /**
-   * EL ACTA MANDA, EL PAPEL SOLO ACOMPAÑA. Se pregunta DESPUÉS de verificar la cadena y
-   * ANTES de hacer nada, en todos los mostradores.
-   *
-   * El certificado dice a qué se comprometió esta bóveda cuando conectó el aparato; el
-   * acta dice lo que puede HOY. Y no coinciden: `caps <ID> -lee` sella el acta pero no
-   * reemite ni revoca el papel, que vive hasta 30 días. Sin esto, quitarle un permiso a un
-   * aparato no se lo quitaba — seguía leyendo, guardando o firmando un mes más.
-   *
-   * Va por `memberCanScope` (el pilar) y no a mano en cada sitio: la regla es la misma en
-   * las dos bóvedas y se comprobaba mal en las dos.
-   *
-   * @returns {boolean} `true` si puede seguir; si no, ya contestó el «no».
-   */
-  /**
-   * CON QUÉ SE JUZGA UN PAPEL: el acta que tiene esta bóveda.
-   *
-   * Sustituye a `trustedIssuer: master`, que comparaba contra UNA llave fija y por eso el
-   * multivault no podía existir — una segunda selladora sellaba el acta y luego sus papeles
-   * los rechazaban los diez mostradores. Ahora se compara contra la lista que dice el acta.
-   *
-   * Sin acta se devuelven nulos a propósito: `verifyDelegation` responde `no-acta` y el
-   * mostrador deniega. Es lo contrario de un repliegue — no hay con qué decidir, así que no
-   * se decide que sí.
-   */
-  async function contextoActa () {
-    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
-    if (!acta) return { actaSeq: null, sealers: null }
-    return { actaSeq: acta.seq, sealers: Acta.sealersOf(acta) }
-  }
-
-  async function actaAllows (from, chk, scope, what) {
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-    // SIN ACTA NO SE ATIENDE. Esto era `if (!record || puede())`, o sea: sin acta, pasa. Un
-    // repliegue no dice «por si falta el dato», dice «si falta el dato, di que sí» — y el
-    // acta falta justo cuando algo se rompió (un archivo a medias, un `catch` que devolvió
-    // null), que es cuando menos hay que fiarse. Toda cuenta tiene acta desde hace versiones.
-    if (!record) {
-      audit('rejected', { what, reason: 'sin-acta' })
-      reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
-      return false
-    }
-    if (Acta.memberCanScope(record, chk.device, scope)) return true
-    audit('rejected', { what, reason: 'acta' })
-    reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member no longer has that permission' })
-    return false
-  }
-
-  // --- handleSign / handleGet: idénticos (verifyChain de la cadena D←maestra) ---
-  async function handleSign (from, p) {
-    if (!isFresh(p.data)) { audit('rejected', { what: 'sign', reason: 'stale' }); return staleReply(from) }
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: SCOPE.SIGN, ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'sign')
-
-    // MANDA EL ACTA, NO EL PAPEL. Esto miraba solo el certificado, y era el único
-    // mostrador que lo hacía —`approve` y los secretos ya preguntaban al acta—. El agujero
-    // que dejaba: `caps <ID> -firma` quita `sign` del acta pero NO reemite ni revoca el
-    // cert del aparato, que sigue diciendo `vault:sign` hasta 30 días. Entonces su
-    // `signData` local veía que ya no puede y se lo PEDÍA a la bóveda… que decía que sí.
-    // O sea que quitarle el permiso de firmar no se lo quitaba: lo cambiaba de firmar él
-    // a que firmaras tú por él.
-    if (!await actaAllows(from, chk, SCOPE.SIGN, 'sign')) return
-
-    // Y CERRADA NO FIRMA NADA (dueño, 2026-08-31). La regla de antes —«el daemon sigue
-    // firmando con el perfil bloqueado, para que un reinicio no deje las apps muertas»— es
-    // ANTERIOR AL MODELO DE SOBRES y queda derogada: con los sobres la bóveda no necesita
-    // firmar nada para servir. Lo que hace abierta es rehacer los sobres.
-    //
-    // Y las apps no se quedan muertas por esto: un aparato al que el acta le da `sign`
-    // firma con SU llave y no pasa por aquí (ver `signData` en el pilar). Leer y guardar
-    // tampoco pasan por aquí, y siguen funcionando con el candado echado.
-    if (isLocked()) {
-      audit('rejected', { what: 'sign', reason: 'locked' })
-      return reply(from, { type: MSG.ERROR, error: 'vault locked: the master key does not sign while the vault is closed' })
-    }
-    const toSign = p.data?.payload
-    if (toSign == null) return reply(from, { type: MSG.ERROR, error: 'data.payload required' })
-    const { signature, publickey } = await identity.signData(toSign)
-    audit('sign', { device: await deviceIdOf(chk.device) })
-    reply(from, { type: MSG.SIGNED, signature, publickey, device: chk.device })
-  }
-
-  async function handleGet (from, p) {
-    if (!isFresh(p.data)) return staleReply(from)
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: SCOPE.READ, ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'get')
-    if (!await actaAllows(from, chk, SCOPE.READ, 'get')) return
-    const id = p.data?.id || 'root'
-    reply(from, { type: MSG.DATA, id, node: store.getNode(id) })
-  }
-
-  // Store de hilos+aperturas (Fase 3): escrituras requieren vault:store; lecturas
-  // aceptan vault:store o vault:read. Cada op va firmada por D + cert (cadena D←maestra).
-  /**
-   * LOS DATOS DEL PERFIL (`docs/datos-del-perfil.md`). Tres métodos y ninguno más:
-   *
-   *   · `profilePut`      — guarda un dato. Privado = sobre ya sellado; público = en claro.
-   *   · `profileBundle`   — los sobres de ESTE aparato, para que arme su perfil.
-   *   · `profilePublic`   — lo público en claro, que puede pedir cualquiera.
-   *
-   * Lo que NO se comprueba aquí: el candado. Un sobre sellado no lo puede leer ni fabricar
-   * la bóveda, así que guardarlo no es una decisión suya y no necesita su maestra. Ese era
-   * el motivo real por el que editar el perfil exigía abrirla, y es el síntoma que abrió
-   * todo esto: se cerraba sola a los cinco minutos y editar dejaba de funcionar.
-   */
-  /**
-   * ABRIR LA BÓVEDA DESDE EL ADMIN (`docs/abrir-a-distancia.md`).
-   *
-   * Dos pasos, y el segundo no se puede reproducir por DOS candados distintos:
-   *
-   *   · el **nonce** hace que se NIEGUE a atenderlo dos veces (memoria, 10 min);
-   *   · la **efímera** hace que no se PUEDA abrir dos veces — se tira al usarla, así que
-   *     ese sobre queda inabrible hasta para nosotros, incluso con el disco en la mano.
-   *
-   * Por qué una efímera y no la llave de cifrado fija de la bóveda: esa cede a la llave de
-   * la máquina (modelo de amenazas §4.2), o sea que cae con el disco. La contraseña es
-   * justo lo único que un ladrón de disco NO tiene — cifrarla con algo que el disco
-   * entrega sería regalársela a quien grabe el tráfico hoy y robe el disco mañana.
-   *
-   * Y el molino lo hace el ADMIN: aquí llega la derivada, nunca la contraseña.
-   */
-  const EPHEMERAL_TTL_MS = 60 * 1000
-  const aperturas = new Map()   // nonce -> { privateKey, exp }
-
-  const unlockDesk = (typeof openWithSecondary === 'function' && typeof secondaryParams === 'function')
-    ? {
-        async begin ({ by }) {
-          const params = secondaryParams()
-          if (!params) {
-            throw new Error('this profile has no admin password: set one with `dotrino-vault profile admin-password`')
-          }
-          // Se barre lo vencido aquí y no con un temporizador: es barato, y un temporizador
-          // más es una cosa más que puede quedarse corriendo cuando el perfil ya no existe.
-          const t = Date.now()
-          for (const [n, v] of aperturas) if (v.exp <= t) aperturas.delete(n)
-          const eph = await makeEphemeralKey()
-          aperturas.set('pendiente', { privateKey: eph.privateKey, exp: t + EPHEMERAL_TTL_MS })
-          audit('unlock.begin', { by })
-          return { ...params, ek: eph.ek }
-        },
-
-        async open ({ nonce, enc, by }) {
-          const guardada = aperturas.get('pendiente')
-          aperturas.delete('pendiente')
-          if (!guardada || guardada.exp <= Date.now()) {
-            return { ok: false, error: 'unlock: ask for a key first, and use it within a minute' }
-          }
-          let payload = null
-          try { payload = await openSealed({ privateKey: guardada.privateKey, enc }) } catch (_) { payload = null }
-          // EL NONCE VA DENTRO DEL SOBRE. Si fuera solo por fuera, un sobre capturado se
-          // reenvía con un nonce nuevo y el candado del nonce no sirve de nada.
-          if (!payload || payload.nonce !== nonce || typeof payload.key !== 'string') {
-            audit('rejected', { what: 'unlock', by, reason: 'sobre' })
-            return { ok: false, error: 'unlock: the envelope does not check out' }
-          }
-          const derivada = new Uint8Array(Buffer.from(payload.key, 'base64'))
-          try {
-            const r = await openWithSecondary(derivada)
-            audit('unlock', { by })
-            log(`[vault] opened from the admin by ${by || '????-????'}`)
-            return { ok: true, result: { ok: true, locked: false } }
-          } catch (e) {
-            audit('rejected', { what: 'unlock', by, reason: e.code || 'error' })
-            // El freno viaja con el rechazo: sin él, el admin reintenta contra una puerta
-            // que ya no responde y no sabe por qué.
-            return { ok: false, code: e.code || null, error: e.message, tries: e.tries ?? null, waitSec: e.waitSec ?? null }
-          } finally {
-            derivada.fill(0)
-          }
-        }
-      }
-    : null
-
-  const PROFILE_METHODS = new Set(['profilePut', 'profileBundle', 'profilePublic', 'profileRecipients'])
-
-  async function handleProfile (from, p, d) {
-    // LO PÚBLICO NO PIDE NADA. Es lo que ve quien pregunta desde fuera y no tiene ninguna
-    // llave tuya: pedir un papel para leerlo sería contradecir lo que significa «público».
-    // Va firmado, así que quien lo recibe comprueba que es tuyo sin fiarse de nadie.
-    if (d.method === 'profilePublic') {
-      return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: secrets.profilePublic() })
-    }
-    const revoked = await revocationSet()
-    // `vault:sign` — hablar por ti. No `vault:store`, que es guardar cosas.
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.SIGN, ...(await contextoActa()), revoked })
-    if (!chk.ok) return denyChain(from, chk, p, 'profile')
-    if (!await actaAllows(from, chk, SCOPE.SIGN, 'profile')) return
-
-    // A QUIÉN HAY QUE ENVOLVERLE. Lo pide el aparato ANTES de sellar, porque sellar lo hace
-    // él: envolver solo necesita públicas, así que puede hacerlo un navegador sin que
-    // ninguna privada ande suelta. Sale de aquí y no de una lista suya para que conceder
-    // `firma` a un aparato nuevo baste — sin que nadie tenga que acordarse de nada.
-    //
-    // VA DETRÁS DEL CONTROL, y estuvo delante. Que solo haga falta material PÚBLICO para
-    // envolver no significa que la lista sea pública: lo que devuelve es el INVENTARIO
-    // —cuántas máquinas tienes, sus llaves, y la de recuperación— y eso la bóveda no se lo
-    // enseña ni a un servicio de la casa (`modelo-de-amenazas.md` §2.5). Cualquiera que
-    // supiera la llave de la cuenta, que es pública, lo sacaba entero preguntando. Y no
-    // costaba nada evitarlo: la consola YA manda su firma y su papel en esta misma llamada
-    // (`requestStore` de `@dotrino/identity`), solo que aquí no se miraban.
-    if (d.method === 'profileRecipients') {
-      const members = await recipientsOf(PROFILE_OWNER)
-      return reply(from, {
-        type: MSG.STORE_RESULT,
-        method: d.method,
-        result: { recoveryPub: secrets.recoveryPub(), members: members.map((m) => ({ pub: m.pub, encPub: m.encPub })) }
-      })
-    }
-
-    try {
-      if (d.method === 'profileBundle') {
-        const b = secrets.profileBundleFor(chk.device)
-        return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: b })
-      }
-      // profilePut
-      const { key, cls, sobre, value } = d.args || {}
-      const quien = await deviceIdOf(chk.device).catch(() => null)
-      let r
-      if (cls === 'public') {
-        r = await secrets.profilePutPublic(key, value, { by: quien })
-      } else {
-        r = await secrets.putSealed(PROFILE_OWNER, key, sobre, { by: quien })
-      }
-      audit('profile.put', { key, cls: cls || 'private', by: quien, gen: r?.gen ?? null })
-      // Y a los demás aparatos, que si no se enteran al arrancar y vuelve la divergencia.
-      await notifyMembers('profile', { key, by: quien })
-      return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: r })
-    } catch (e) {
-      return reply(from, { type: MSG.ERROR, error: 'profile: ' + e.message })
-    }
-  }
-
-  async function handleStore (from, p) {
-    const d = p.data
-    // `Object.hasOwn` y no `threads.methods[d.method]`: con la comprobación laxa,
-    // `method: 'toString'` (o cualquier miembro heredado de Object) pasaba el filtro y
-    // se llamaba como si fuera del store.
-    if (!d || typeof d.method !== 'string' || !Object.hasOwn(threads.methods, d.method)) {
-      // Con `code`: un aparato más nuevo que esta bóveda pide métodos que aquí no existen, y
-      // tiene que poder decir «actualiza la bóveda» en vez de enseñar la frase.
-      return reply(from, { type: MSG.ERROR, error: 'store: invalid method', code: 'store-unknown-method' })
-    }
-    if (!isFresh(d)) return staleReply(from)
-    // EL PERFIL VA POR OTRO CAMINO, y por eso se atiende antes que nada
-    // (`docs/datos-del-perfil.md`). Dos diferencias, y las dos son el arreglo:
-    //
-    //   · **No hace falta abrir la bóveda.** Lo que llega es un sobre ya sellado y
-    //     firmado, que ella no puede leer ni falsificar: aceptarlo no es una decisión
-    //     suya. El candado estaba ahí porque guardaba el perfil en claro; ya no.
-    //   · **Lo gatea `firma`, no `guarda`.** Escribir tu identidad es hablar por ti, no
-    //     guardar un archivo en tu bóveda (dueño, 2026-09-03). El proxio tiene `guarda`
-    //     para lo suyo y no debe poder cambiar quién eres.
-    if (PROFILE_METHODS.has(d.method)) return await handleProfile(from, p, d)
-    // EL ALMACÉN SOLO ENTRA CIFRADO. Lo que va por aquí —hilos de las apps, contraseñas,
-    // el `me` heredado— viaja por el proxio, que no cifra; en claro lo leería quien lo
-    // opere. Los clientes del ecosistema cifran desde @dotrino/identity 0.91.0, y hasta
-    // entonces uno sin la clave de contenido mandaba en claro «como antes»: aceptarlo aquí
-    // era dejar ese camino abierto para cualquier cliente viejo. El perfil (arriba) va
-    // aparte a propósito: lo privado viaja en sobres y lo público es público.
-    if (!d.enc) {
-      audit('rejected', { what: 'store', method: d.method, reason: 'unsealed' })
-      return reply(from, { type: MSG.ERROR, error: 'store: requests must be sealed with the profile content key', code: 'store-unsealed' })
-    }
-    // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil heredado
-    // (`profileSet`, el `me` plano). Un dispositivo enrolado puede seguir firmando,
-    // leyendo y guardando contenido.
-    if (PROFILE_EDIT_METHODS.has(d.method) && isLocked()) {
-      audit('rejected', { what: 'store', method: d.method, reason: 'locked' })
-      return reply(from, { type: MSG.ERROR, error: 'profile locked: unlock it on the vault machine (dotrino-vault unlock) to edit it' })
-    }
-    const revoked = await revocationSet()
-    let chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.STORE, ...(await contextoActa()), revoked })
-    if (!chk.ok && STORE_READ_METHODS.has(d.method)) {
-      chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.READ, ...(await contextoActa()), revoked })
-    }
-    if (!chk.ok) return denyChain(from, chk, p, 'store')
-    // El scope que valió es el que hay que preguntarle al acta: un método de lectura pudo
-    // pasar con `read` en vez de `store`, y exigirle `store` al acta lo rechazaría a pesar
-    // de tener permiso para lo que pidió.
-    if (!await actaAllows(from, chk, chk.scope === SCOPE.READ ? SCOPE.READ : SCOPE.STORE, 'store')) return
-    try {
-      // CIFRADO de punta a punta con la clave de contenido del perfil: el proxy transporta
-      // pero no ve nada de lo que el usuario guarda. Se abre aquí con la clave de la bóveda
-      // (que también es miembro) y la respuesta vuelve igual.
-      const cek = await identity.contentKey()
-      if (!cek) return reply(from, { type: MSG.ERROR, error: 'store: this vault does not hold the profile content key', code: 'vault-no-content-key' })
-      const args = JSON.parse(await identity.openContent(d.enc))
-      const result = await threads.methods[d.method](args)
-      // Que un aparato ESCRIBA en tu bóveda queda anotado. Antes solo se auditaba el
-      // rechazo, así que la bitácora contaba quién entró pero no qué hizo después.
-      // Solo la operación y el aparato: nunca el contenido (`activity` es un registro
-      // de seguridad, no una copia de lo que guardas).
-      if (!STORE_READ_METHODS.has(d.method)) {
-        audit('store', { device: await deviceIdOf(chk.device), method: d.method })
-      }
-      const enc = await identity.sealContent(JSON.stringify(result ?? null))
-      reply(from, { type: MSG.STORE_RESULT, method: d.method, result: { __enc: enc } })
-    } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
-  }
-
-  // Lista (solo lectura) de dispositivos enrolados, para un panel en el navegador.
-  // Cualquier cert válido tuyo puede verla; REVOCAR sigue siendo solo desde el PC.
-  /**
-   * Un aparato REVOCADO que vuelve a aparecer: se le reemite el `vault.revoked` FIRMADO
-   * para que se entere y se auto-borre.
-   *
-   * Un «unauthorized: revoked» suelto no basta y no debe bastar: no va firmado, así que
-   * el dispositivo tiene prohibido borrar nada con él (si no, cualquiera destruiría datos
-   * ajenos con un mensaje). Lo único que puede borrar es un aviso firmado por la maestra
-   * — y hasta ahora el daemon no lo reemitía nunca. Si el aparato estaba apagado cuando lo
-   * quitaste, no se enteraba jamás: seguía enseñando el perfil como si nada.
-   */
-  async function notifyIfRevoked (pubkey, nonce = null, certIss = null, reason = 'revoked') {
-    if (typeof pubkey !== 'string') return
-    try {
-      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-      // Sin acta (bóveda anterior al acta) hay que mirar las delegaciones, que es lo único
-      // que queda. OJO con dónde se buscan: desde identity 0.42 `issued` es «lo que HOY
-      // sirve para entrar», así que los retirados NO están ahí — viven en `revokedCerts`.
-      let knownRevoked = false
-      let fallbackNonce = null
-      if (!record) {
-        const delegations = await identity.listDelegations()
-        const revoked = await revocationSet()
-        const candidates = [...(delegations.revokedCerts || []), ...(delegations.issued || [])]
-        const theirs = candidates.filter((x) => x.sub === pubkey && (x.revokedAt || revoked.has(x.nonce)))
-        knownRevoked = theirs.length > 0
-        fallbackNonce = theirs[0]?.nonce || null
-      }
-      if (!shouldNotifyRevoked({ reason, pubkey, master, certIss, members: record?.members || null, knownRevoked })) return
-      // El aviso nombra el certificado que el aparato ACABA de presentar: es el que tiene
-      // en la mano, y es contra ese contra el que comprueba antes de borrarse.
-      await desk.emitRevoke(pubkey, nonce || fallbackNonce)
-      audit('revoke.notified', { device: await deviceIdOf(pubkey).catch(() => null), reason })
-    } catch (e) { log('[vault] could not re-emit the revocation:', e.message) }
-  }
-
-  /**
-   * Rechaza una petición y, si el aparato ya no es del perfil, SE LO DICE con el aviso
-   * firmado — sea cual sea la operación que estuviera intentando.
-   *
-   * Un dispositivo que fue tuyo tiene que poder llegar hasta aquí precisamente para que se
-   * le pueda mandar a paseo: es el único mensaje que le borra la cuenta, porque es el único
-   * que va firmado por la maestra (un «unauthorized» suelto no borra nada y no debe: sería
-   * destruir datos ajenos con un mensaje, el wipe-DoS de `docs/pairing-protocol.md §2.3`).
-   *
-   * Antes esto solo pasaba en `devices` —la pantalla de dispositivos— y solo si el papel
-   * estaba REVOCADO. Un aparato quitado que estuviera guardando notas nunca preguntaba por
-   * ahí, y uno al que simplemente se le venció el certificado no entraba en el caso: los
-   * dos se quedaban enseñando la cuenta indefinidamente.
-   */
-  async function denyChain (from, chk, p, what) {
-    await notifyIfRevoked(p.data?.publickey, p.cert?.nonce || null, p.cert?.iss || null, chk.reason)
-    if (what) audit('rejected', { what, reason: chk.reason })
-    // `code` + `reason` como campos: quien llama decide por ellos, no por la frase.
-    return reply(from, { type: MSG.ERROR, code: 'unauthorized', reason: chk.reason, error: 'unauthorized: ' + chk.reason })
-  }
-
-  /**
-   * «¿SIGO SIENDO DE ESTA CASA?» — la única pregunta que se atiende SIN certificado.
-   *
-   * Existe por el aparato que se quedó sin papel: no puede firmar, ni leer, ni renovar, y
-   * —esto es lo grave— tampoco tenía forma de enterarse de que lo echaron, porque todo lo
-   * demás exige el certificado que ya no tiene. Se quedaba enseñando para siempre una
-   * cuenta que ya no era suya. Va firmada con la llave del propio aparato, que es
-   * exactamente lo que el acta nombra, así que decir quién pregunta no necesita más.
-   *
-   * La respuesta es sí o no, y nada más: al que sigue dentro no se le manda el acta —no la
-   * pidió, y contarle el perfil entero a quien no trae papel es attach de más—. Al que ya no
-   * está se le manda el aviso FIRMADO de expulsión, que es lo único que le borra la cuenta.
-   * Que un desconocido pregunte no cuesta nada: lo que se le puede contestar es un aviso a
-   * nombre de SU propia llave, que no le sirve contra nadie más (`verifyRevoke` exige que
-   * el aviso nombre al aparato que lo recibe).
-   */
-  // --- ENTRAR CON USUARIO Y CONTRASEÑA ---------------------------------------------------
-  //
-  // Los tres únicos mensajes que se atienden SIN certificado, porque quien pregunta todavía
-  // no tiene llaves: están dentro del paquete que solo abre su contraseña. La bóveda no ve
-  // la contraseña en ningún momento (OPAQUE), y responde igual exista o no el usuario.
-  //
-  // Funcionan con el perfil CERRADO: el paquete se devuelve tal cual, sin abrir nada. Lo que
-  // sí exige la bóveda abierta es CREAR el aparato, porque eso sella el acta.
-
-  function loginError (from, e) {
-    if (e?.code === 'too-many-tries') {
-      return reply(from, { type: MSG.ERROR, error: e.message, code: e.code, waitMs: e.waitMs || 0 })
-    }
-    if (e?.code === 'login-failed' || e?.code === 'no-exchange' || e?.code === 'bad-input' || e?.code === 'bad-user') {
-      return reply(from, { type: MSG.ERROR, error: e.message, code: e.code })
-    }
-    log('[vault] login: %s', e?.message || e)
-    reply(from, { type: MSG.ERROR, error: 'login failed', code: 'login-error' })
-  }
-
-  async function handleLoginStart (from, p) {
-    try {
-      const { lid, response } = await logins.loginBegin({ user: p?.user, request: p?.request })
-      audit('login.start', { user: String(p?.user || '').slice(0, 32) })
-      reply(from, { type: MSG.LOGIN_RESPONSE, lid, response })
-    } catch (e) { loginError(from, e) }
-  }
-
-  async function handleLoginFinish (from, p) {
-    try {
-      const r = await logins.loginEnd({ lid: p?.lid, finalization: p?.finalization, label: p?.label })
-      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-      audit('login.ok', { user: r.user, sid: r.sid.slice(0, 8) })
-      log('[vault] login: %s entered (session %s)', r.user, r.sid.slice(0, 8))
-      reply(from, { type: MSG.LOGIN_OK, sid: r.sid, blob: r.blob, cert: r.cert, iss: r.iss || identity.me?.publickey || null, acta: record })
-    } catch (e) { loginError(from, e) }
-  }
-
-  /**
-   * SALIR. Va firmado con la llave del propio aparato —la que acaba de abrir— porque cerrar
-   * la sesión de otro sería echarlo de su cuenta.
-   */
-  async function handleLoginClose (from, p) {
-    if (!isFresh(p?.data)) return staleReply(from)
-    const d = p.data
-    if (d?.op !== 'login.close' || typeof d.publickey !== 'string' || typeof d.user !== 'string' || typeof d.sid !== 'string') {
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: shape', code: 'bad-input' })
-    }
-    if (!(await verifyDeviceSig({ publickey: d.publickey, data: d, signature: p.signature }))) {
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: bad-signature', code: 'bad-signature' })
-    }
-    const mine = logins.list().find((x) => x.user === d.user)
-    if (!mine || mine.pub !== d.publickey) {
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: that key does not own this login', code: 'not-yours' })
-    }
-    const r = logins.closeSession({ user: d.user, sid: d.sid })
-    audit('login.close', { user: d.user, sid: d.sid.slice(0, 8), by: 'device' })
-    reply(from, { type: MSG.LOGIN_CLOSED, ok: r.ok })
-  }
-
-  async function handleCheck (from, p) {
-    if (!isFresh(p?.data)) return staleReply(from)
-    const pub = p.data.publickey
-    if (typeof pub !== 'string') return reply(from, { type: MSG.ERROR, error: 'unauthorized: shape' })
-    if (!(await verifyDeviceSig({ publickey: pub, data: p.data, signature: p.signature }))) {
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: bad-signature' })
-    }
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-    const inside = (record?.members || []).some((m) => m?.pub === pub)
-    audit('check', { device: await deviceIdOf(pub).catch(() => null), in: inside })
-    if (inside) return reply(from, { type: MSG.CHECKED, in: true })
-    await notifyIfRevoked(pub, null, null, 'revoked')
-    reply(from, { type: MSG.CHECKED, in: false })
-  }
-
-  async function handleDevices (from, p) {
-    if (!isFresh(p.data)) return staleReply(from)
-    const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
-    if (!chk.ok) return denyChain(from, chk, p, null)
-    // DOS RESPUESTAS, PORQUE SON DOS PREGUNTAS DISTINTAS.
-    //
-    // Un SERVICIO pregunta aquí para enterarse de dos cosas suyas: si le revocaron el papel
-    // y cuál es el acta vigente. Eso no es tu inventario y no puede exigir `lee` — se lo
-    // exigí, y en producción dejó ciegos a los servicios (`rejected devices/acta` en la
-    // bitácora del VPS, dos veces, antes de que lo viera).
-    //
-    // La LISTA DE APARATOS sí es el perfil —cómo se llama cada máquina y qué puede— y esa
-    // sigue pidiendo `lee`. Antes no preguntaba nada, así que un aparato al que le quitaste
-    // el permiso seguía viéndolo todo hasta que su papel caducara.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-    // LA CADENA DE SELLADORES VIAJA CON LA LISTA, también para quien solo puede ver
-    // revocaciones. Es lo que un aparato de Node necesita para FIRMAR a nombre de la cuenta
-    // de forma que un extraño lo compruebe (`verifySignedFor` exige la cadena desde el
-    // génesis), y hasta ahora ningún agente headless podía: solo el navegador la tenía. Es
-    // corta a propósito (génesis, cambios de sellador, actual), así que no pasa por `fitChain`.
-    const sealerChainOf = async () => { try { return (await identity.sealerChain?.()) || null } catch (e) { log('[vault] could not build the sealer chain:', e.message); return null } }
-    const puedeVerTodo = !!record && Acta.memberCanScope(record, chk.device, SCOPE.READ)
-    const { issued, revoked } = await identity.listDelegations()
-    if (!puedeVerTodo) {
-      if (!record) {
-        audit('rejected', { what: 'devices', reason: 'sin-acta' })
-        return reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
-      }
-      audit('devices', { device: await deviceIdOf(chk.device).catch(() => null), solo: 'revocaciones' })
-      return reply(from, { type: MSG.DEVICES_RESULT, devices: [], revoked, blocked: blocked.pubs(), acta: record, sealerChain: await sealerChainOf() })
-    }
-    // El acta viaja con la lista: así cada dispositivo se entera de los cambios de
-    // política (quién manda, quién puede qué) sin un canal aparte.
-    // Si el dispositivo estuvo apagado y viene con un `seq` viejo, se le manda la CADENA
-    // que falta (ventana de retención, §1.3) para que compruebe el encadenamiento en vez
-    // de tragarse un salto a ciegas. Si se salió de la ventana, llega vacía y toca
-    // re-emparejar — que es justo lo que debe pasar.
-    // El `.catch()` de antes NO protegía de nada: si `actaHistory` no existe, el
-    // TypeError es SÍNCRONO y salta antes de que haya promesa que encadenar. Pasó: el
-    // método vivía en el núcleo pero no en el envoltorio de Node, así que esta línea
-    // tiraba toda la respuesta y ningún navegador ya emparejado —que manda `sinceSeq`
-    // siempre— volvía a sincronizar su acta. Un try/catch de verdad, y opcional.
-    let chain = null
-    if (typeof p.data?.sinceSeq === 'number') {
-      try { chain = (await identity.actaHistory?.({ sinceSeq: p.data.sinceSeq }))?.chain || null }
-      catch (e) { log('[vault] could not build the record chain:', e.message) }
-    }
-    // `sub` (pubkey completa) va incluida: es la DIRECCIÓN de cada dispositivo en el
-    // proxy → permite a las apps AUTODESCUBRIR tus máquinas (p. ej. la terminal
-    // lista tus agentes sin pegar nada). Solo la ve quien presenta un cert tuyo válido.
-    // QUÉ CORRE CADA UNO, y si cuadra con lo que corremos aquí (CONVENCIONES §14). Va con
-    // la lista porque es donde se mira: el dueño lo pidió en el administrador Y en la
-    // lista de dispositivos de la bóveda. `null` significa «todavía no ha hablado desde
-    // que arrancamos», que es distinto de «no declara» — y se dice distinto.
-    const devices = await Promise.all(issued.map(async (x) => ({
-      deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce,
-      running: x.sub ? versionDe(x.sub) : null,
-      machine: x.sub ? machineOf(x.sub, record) : null,
-      notifiedAt: x.sub ? notifiable.since(x.sub) : null
-    })))
-    // LA SUBACTA VIAJA CON EL ACTA. Es la mitad de «se comparte entre todos los
-    // dispositivos»: sin esto, una renuncia sin sellar solo la respeta esta máquina.
-    // Cada entrada va firmada por su sujeto, así que quien la recibe la verifica sola.
-    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, blocked: blocked.pubs(), acta: record, chain, sealerChain: await sealerChainOf(), vault: MI_VERSION, subacta: subacta.entries() }))
-  }
-
-  /**
-   * NADA DE FRAMES QUE NO CABEN. El proxio corta a 1 MB y cierra la conexión con un 1009:
-   * la respuesta no llega, la bóveda reconecta y no queda ni una línea de log de su lado.
-   * Así estuvo muda tres días para todo el ecosistema (2026-08-24) mientras el bot social
-   * repetía «no tienes ningún node de contenido enrolado».
-   *
-   * La cadena de actas es lo único que puede crecer sin techo aquí —cada acta es un
-   * snapshot completo de los miembros—, así que se recorta por el FINAL: el tramo que sale
-   * sigue siendo contiguo desde el `seq` del que pregunta, que es lo que necesita para
-   * encadenar, y en la siguiente pregunta seguirá desde donde llegó.
-   */
-  function fitChain (msg) {
-    const size = (m) => JSON.stringify(m).length
-    if (size(msg) <= MAX_REPLY_BYTES) return msg
-    const full = msg.chain?.length || 0
-    while (msg.chain?.length && size(msg) > MAX_REPLY_BYTES) msg.chain = msg.chain.slice(0, -1)
-    if (!msg.chain?.length) msg.chain = null
-    const left = msg.chain?.length || 0
-    log(`[vault] record chain trimmed to fit the transport: ${left}/${full} link(s), ${size(msg)} bytes`)
-    // Si tras podar la cadena SIGUE sin caber, no se avisa y se manda igual —eso mataba la
-    // conexión—: se devuelve tal cual y `reply` lo sustituye por un error. El aviso de aquí
-    // sobra porque el de `reply` dice lo mismo y además dice qué hizo.
-    return msg
-  }
-
-  // RENOVACIÓN automática: un dispositivo con cert VIGENTE y no revocado pide un
-  // cert fresco (misma sub-clave y scope) sin QR ni aprobación — sigue siendo el
-  // mismo dispositivo enrolado, solo extiende la ventana. Un cert vencido o
-  // revocado NO puede renovarse (ahí sí toca re-emparejar con aprobación).
-  async function handleRenew (from, p) {
-    if (!isFresh(p.data)) { audit('rejected', { what: 'renew', reason: 'stale' }); return staleReply(from) }
-    const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
-    if (!chk.ok) return denyChain(from, chk, p, 'renew')
-    // 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)
-    // EL SCOPE SALE DEL ACTA, no del cert viejo. El acta es la política (lo que el dueño
-    // decidió con `caps`); el cert es su reflejo, y solo dura 30 días para poder cambiar.
-    // Copiar `p.cert.scope` congelaba la política en el momento del emparejamiento: attach
-    // `administra` no llegaba nunca al cert (la consola remota no podía funcionar) y
-    // QUITARLO tampoco surtía efecto hasta que el cert caducara, hasta un mes después.
-    // Si el miembro ya no está en el acta, no se renueva nada: lo echaron.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    // Sin acta no se renueva: caer al scope del papel viejo es reconceder a ciegas lo que
-    // el acta ya no dice. Un repliegue así no protege de nada, tapa.
-    if (!record) {
-      audit('rejected', { what: 'renew', device: await deviceIdOf(p.cert.sub), reason: 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
-    }
-    const scope = Acta.memberScopes(record, p.cert.sub)
-    if (!scope.length) {
-      audit('rejected', { what: 'renew', device: await deviceIdOf(p.cert.sub), reason: 'not-a-member' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: the record no longer lists this device' })
-    }
-    // RENOVAR NO RETIRA EL PAPEL ANTERIOR (`supersede: false`), y esto costó dos servicios.
-    //
-    // Retirarlo al emitir parece limpio —un aparato, un papel— pero convierte cualquier
-    // renovación que falle DESPUÉS de emitirse en una expulsión permanente: la máquina se
-    // queda con el papel viejo, que acaba de quedar revocado, y ya no puede ni pedir otro.
-    // Pasó dos veces en la migración del VPS (el registro de selladores y el bot social):
-    // el papel nuevo salió, la respuesta no llegó a guardarse, y al reintentar la bóveda
-    // contestaba `unauthorized: revoked`. Re-emparejar a mano, con TTY, por una renovación.
-    //
-    // Que convivan dos papeles del mismo aparato ya no es el problema que era: ninguno
-    // vence, pero lo que pueden hacer lo decide el ACTA en cada mostrador, así que el
-    // viejo no autoriza nada que el nuevo no autorice. Y quitar el aparato de verdad sigue
-    // siendo `revokeDevice`, que los retira TODOS de una vez.
-    const { cert } = await identity.signDelegation(p.cert.sub, scope, { label: prev?.label || '', supersede: false })
-    audit('renew', { device: await deviceIdOf(p.cert.sub), label: prev?.label || '', scope, seq: cert.seq })
-    log(`[vault] cert renewed for ${await deviceIdOf(p.cert.sub)} · record #${cert.seq}`)
-    // El acta viaja con el papel: sin ella quien lo recibe no puede comprobar que lo firmó
-    // una selladora del perfil, que es lo que sustituyó a «lo firmó la maestra».
-    reply(from, { type: MSG.RENEWED, cert, acta: record })
-  }
-
-  // SECRETOS de servicios: un servicio enrolado (cert `vault:secrets:<ns>`)
-  // pide el bundle de su namespace — el del SCOPE (que comparten todos los
-  // aparatos que sirven ese ns) con el SUYO PROPIO encima (`secretsStore.js`).
-  // Lo suyo se indexa por la llave que firma esta misma petición, así que no hay
-  // manera de pedir lo de otro aparato. La respuesta va SELLADA a la llave ECDH
-  // efímera `ek` que vino en el sobre firmado (el proxy transporta pero no
-  // puede leer los valores) y el cuerpo va FIRMADO por la maestra (el
-  // 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), ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'enckey')
-    // MISMA FRONTERA QUE SERVIR EL CAJÓN, y por la misma razón: esto no solo apunta una
-    // llave pública, acto seguido le ENVUELVE la del cajón (`spreadKey`, más abajo). Aquí
-    // solo se miraba el certificado, así que a un aparato al que el acta ya le había
-    // quitado `secrets` se le entregaba la llave igual, hasta 30 días. Es el mismo fallo
-    // que se cerró en `handleSign`, en otro mostrador.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: 'enckey', ns, reason: record ? 'cn' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
-    }
-    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 sus cajones en el acto, o
-      // seguiría sin poder abrir nada hasta la siguiente escritura.
-      //
-      // Va por `recipientsOf` —el único sitio que sabe quién debe tener envoltura de un
-      // cajón—, que incluye a los SELLADORES. Con `nsMembers` se envolvía solo para los del
-      // ns y los selladores se quedaban con lo viejo (dueño, 2026-09-01).
-      //
-      // Y su cajón PROPIO también: un aparato con variables suyas se quedaba sin poder
-      // abrirlas, que es el mismo agujero por otra puerta.
-      for (const owner of [`ns:${ns}`, `dev:${chk.device}`]) {
-        await spreadKey(owner, (esPublica) => recipientsOf(owner, { public: esPublica }))
-          .catch((e) => log(`[vault] ${owner}: could not hand it the key: ${e.message}`))
-      }
-      // Con la llave de sellado, como todo lo que sirve la bóveda: la maestra no firma con la
-      // bóveda cerrada, y esto tiene que funcionar cerrada.
-      const body = { op: 'secrets.result', ns, enc: null, ok: true, ts: Date.now() }
-      reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
-    } catch (e) {
-      reply(from, { type: MSG.ERROR, error: 'enckey: ' + e.message })
-    }
-  }
-
-  /**
-   * UN SERVICIO GUARDA VARIABLES EN SU PROPIO CAJÓN (dueño, 2026-09-29: «para facilitar la
-   * migración de ENVs a Dotrino»). Es lo que usa `dotrino-env import`: el `.env` que ya
-   * existe en la máquina del servicio sube tal cual, sin copiarlo a mano en la consola.
-   *
-   * Va por el canal del servicio —el mismo que lee el cajón— y con SUS fronteras: el cert
-   * con `vault:secrets:<ns>` y el CN del acta. Así un servicio solo escribe en su cajón y
-   * nunca en el de otro. La guarda la hace la MISMA pieza que la consola (`varsDesk`): la
-   * firma del autor, las envolturas, la espera de aprobación. Aquí no hay otra puerta.
-   *
-   * Los límites (dueño, 2026-09-29):
-   *   · AÑADIR una variable nueva es directo, haya o no quien apruebe (dueño, 2026-10-12);
-   *   · EDITAR una que ya existe pide aprobación —`unattended` no exime—;
-   *   · si nadie puede aprobar, no se pide y lo que ya existe no se toca (`exists`);
-   *   · BORRAR, nunca: eso es de la consola y del CLI de la bóveda.
-   *
-   * Dos operaciones: `store.recipients` (para quién se sella: solo públicas, nada que ocultar)
-   * y `store` (los sobres ya hechos; la bóveda no los abre).
-   */
-  /**
-   * LA HUELLA DE UN CAJÓN, tal como lo recibiría este aparato: nombres y GENERACIÓN de cada
-   * variable, sin un solo valor. La visibilidad NO entra: taparla no cambia lo que el servicio
-   * lee (y no sube la generación ni avisa). La generación la sube el almacén al
-   * escribir, así que la huella cambia cuando cambia la configuración y no cuando la
-   * bóveda solo rehace envolturas al abrirse. (Una rotación de llaves —al quitar un
-   * aparato— sí la sube: el servicio se reinicia una vez, que es raro y no hace daño.)
-   */
-  function drawerDigest (ns, devicePub) {
-    const b = secrets.bundleFor(ns, devicePub)
-    const filas = Object.entries(b.entries || {})
-      .map(([k, e]) => [k, b.legacy ? nodeCrypto.createHash('sha256').update(String(e.v)).digest('hex') : (e.gen ?? null)])
-      .sort((a, c) => (a[0] < c[0] ? -1 : 1))
-    return nodeCrypto.createHash('sha256').update(JSON.stringify(filas)).digest('hex')
-  }
-
-  /**
-   * ¿CAMBIÓ MI CONFIGURACIÓN? Sin llevarse nada (dueño, 2026-09-30: «revisa que no se pidan
-   * aprobaciones sin motivo»).
-   *
-   * El servicio lo pregunta al reconectarse, por si se perdió un aviso. Antes lo preguntaba
-   * pidiendo el cajón ENTERO —privadas incluidas— para sacarle una huella, y eso es un
-   * pedido de claves: a un servicio que pide aprobación le sonaba el teléfono al dueño en
-   * cada despliegue del proxio, para aprobar algo que no entregaba nada que el servicio no
-   * tuviera ya. La huella no revela nada, así que no se aprueba: quien pregunta tiene que
-   * ser igualmente el servicio de ese cajón (cert + CN del acta).
-   */
-  async function handleDigest (from, p) {
-    const ns = p.data?.ns
-    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'digest: invalid namespace' })
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: secretsScope(ns), ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'digest')
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: 'digest', ns, reason: record ? 'cn' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
-    }
-    const body = { op: 'secrets.digest', ns, digest: drawerDigest(ns, chk.device), ts: Date.now() }
-    reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
-  }
-
-  /**
-   * UN APARATO PREGUNTA SI PUEDE ACTUALIZARSE (`op: 'update-ask'`, dueño 2026-10-08).
-   *
-   * Pedir aprobación es un interruptor DE CADA AGENTE, independiente del de la bóveda
-   * (`updateApproval` de `src/settings.js` vale solo para la propia bóveda): el agente solo
-   * manda esto cuando lo tiene encendido. Así que aquí no se consulta ningún ajuste:
-   *
-   *   · alguien aprueba en este perfil → un pedido `kind: 'update'` a nombre del aparato, que
-   *     dura un día; se contesta «pendiente» y el resultado sale cuando alguien decide, por
-   *     donde vino la pregunta. Vencido es no.
-   *   · nadie aprueba → sí, sin preguntar: esperar un sí que nadie puede dar sería no
-   *     actualizarse nunca.
-   *
-   * Lo puede preguntar cualquier miembro del acta: no pide nada que no sea suyo.
-   */
-  const updateAsks = new Map()      // device|product|version → { id, dest } del pedido vivo
-  const updateDecisions = new Map() // device|product|version → { ok: true, exp }: lo ya aprobado
-  const cut = (v, n) => (typeof v === 'string' && v && v.length <= n ? v : null)
-  async function handleUpdateAsk (from, p) {
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'update-ask')
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    if (!record || !(record.members || []).some((m) => m.pub === chk.device)) {
-      audit('rejected', { what: 'update-ask', reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
-    }
-    const product = cut(p.data?.product, 128)
-    const version = cut(p.data?.version, 64)
-    const fromVersion = cut(p.data?.from, 64)
-    if (!product || !version) return reply(from, { type: MSG.ERROR, code: 'bad-request', error: 'update-ask: needs `product` and `version`' })
-    const deviceId = await deviceIdOf(chk.device).catch(() => null)
-    const say = async (dest, extra) => {
-      const body = { op: 'update-ask', product, version, ...extra, ts: Date.now() }
-      reply(dest, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
-    }
-
-    const approvers = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).length
-    if (!approvers) {
-      audit('update-ask', { device: deviceId, product, version, asked: false })
-      log(`[vault] update-ask: ${deviceId || '????-????'} may update ${product} to ${version} on its own (nobody approves in this profile)`)
-      return say(from, { ok: true, asked: false })
-    }
-
-    const key = `${chk.device}|${product}|${version}`
-    const now = Date.now()
-    for (const [k, d] of updateDecisions) if (d.exp <= now) updateDecisions.delete(k)
-    // YA SE DECIDIÓ y quien preguntó no estaba para oírlo: se le dice lo decidido en vez de
-    // volver a timbrar por lo mismo.
-    const decided = updateDecisions.get(key)
-    if (decided) return say(from, { ok: decided.ok, asked: true })
-    // YA HAY UN PEDIDO VIVO por esto mismo (el agente se reinició y vuelve a preguntar): no se
-    // timbra otra vez; la respuesta irá a quien pregunta ahora.
-    const vivo = updateAsks.get(key)
-    if (vivo && waiters.has(vivo.id)) {
-      vivo.dest = from
-      return say(from, { pending: true, id: vivo.id, exp: vivo.exp, asked: true })
-    }
-    const ask = { id: null, exp: null, dest: from }
-    let pend
-    try {
-      pend = await awaitApproval({
-        device: chk.device, ns: 'vault', kind: 'update', what: 'update',
-        ctx: { product, version, from: fromVersion }, ttlMs: UPDATE_TTL_MS,
-        onAnswer: async (ok) => {
-          updateAsks.delete(key)
-          // Solo se recuerda el SÍ. Un no puede ser un vencimiento (nadie lo vio), y
-          // recordarlo dejaría al aparato un día sin poder volver a preguntar.
-          if (ok === true) updateDecisions.set(key, { ok: true, exp: Date.now() + UPDATE_TTL_MS })
-          await say(ask.dest, { ok: ok === true, asked: true, id: ask.id })
-        }
-      })
-    } catch (e) {
-      log(`[vault] update-ask: could not ask for approval: ${e.message}`)
-      return reply(from, { type: MSG.ERROR, code: 'ask-failed', error: 'update-ask: could not ask for approval' })
-    }
-    ask.id = pend.id; ask.exp = pend.exp
-    updateAsks.set(key, ask)
-    return say(from, { pending: true, id: pend.id, exp: pend.exp, asked: true })
-  }
-
-  /**
-   * UN APARATO DICE QUE SE ACTUALIZÓ (`op: 'update-done'`): la bóveda se lo cuenta a quien
-   * aprueba en este perfil, por el mismo camino que su propio «me actualicé». Si el agente
-   * avisa o no lo decide él (su interruptor); aquí solo se reparte.
-   *
-   * Y su hermano `op: 'update-needs-root'`: el aparato vio una versión nueva y no puede
-   * instalarla solo porque necesita permisos de administrador. Mismo reparto, otro `ev`.
-   *
-   * QUIÉN ES lo dice el acta (id y nombre), no lo que el aparato cuente de sí mismo.
-   */
-  async function handleUpdateDone (from, p) {
-    const op = p.data.op
-    const ev = op === 'update-needs-root' ? 'update-needs-root' : 'updated'
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, op)
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    const member = (record?.members || []).find((m) => m.pub === chk.device)
-    if (!member) {
-      audit('rejected', { what: op, reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
-    }
-    const product = cut(p.data?.product, 128)
-    const version = cut(p.data?.version, 64)
-    if (!product || !version) return reply(from, { type: MSG.ERROR, code: 'bad-request', error: `${op}: needs \`product\` and \`version\`` })
-    const deviceId = await deviceIdOf(chk.device).catch(() => null)
-    try {
-      await announceUpdate({ ev, version, from: cut(p.data?.from, 64), product, deviceId, label: member.label || '' })
-    } catch (e) {
-      log(`[vault] ${op}: ${deviceId || '????-????'} reported ${product} ${version}, but the approvers could not be told: ${e.message}`)
-      return reply(from, { type: MSG.ERROR, code: e.code || 'announce-failed', error: `${op}: the approvers could not be told` })
-    }
-    const body = { op, ok: true, product, version, ts: Date.now() }
-    reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
-  }
-
-  const storeNonces = new Map()
-  async function handleVarStore (from, p) {
-    const ns = p.data?.ns
-    const op = p.data?.op
-    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: `${op}: invalid namespace` })
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: secretsScope(ns), ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, op)
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: op, ns, reason: record ? 'cn' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
-    }
-    const deviceId = await deviceIdOf(chk.device).catch(() => null)
-    // FIRMADA COMO TODO LO QUE SIRVE LA BÓVEDA (con la llave de sellado que nombra el acta, y
-    // el acta al lado): `store.recipients` dice PARA QUIÉN se sellan los valores, y si el
-    // proxio pudiera cambiar esa lista por sus llaves, abriría las privadas al pasar.
-    const answer = async (body) => reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
-    try {
-      if (op === 'store.recipients') {
-        return await answer({
-          op: 'store.recipients', ns, ts: Date.now(),
-          recipients: { public: await varsDesk.recipients({ ns, public: true }), private: await varsDesk.recipients({ ns, public: false }) },
-          // Para que quien importa sepa de antemano qué va a pasar con lo que ya existe.
-          approval: hasApprover(record)
-        })
-      }
-      // CAMBIA ESTADO: un solo uso. La frescura (±5 min) no basta — repetir el mismo sobre
-      // dentro de esa ventana volvería a timbrar el teléfono de quien aprueba.
-      const nonce = p.data?.nonce
-      if (typeof nonce !== 'string' || nonce.length < 16) return reply(from, { type: MSG.ERROR, code: 'no-nonce', error: 'store: missing single-use nonce' })
-      const now = Date.now()
-      for (const [n, exp] of storeNonces) if (exp <= now) storeNonces.delete(n)
-      if (storeNonces.has(nonce)) { audit('rejected', { what: 'store', ns, reason: 'replay' }); return reply(from, { type: MSG.ERROR, code: 'replay', error: 'store: nonce already used' }) }
-      storeNonces.set(nonce, now + 10 * 60 * 1000)
-
-      const items = p.data?.items
-      if (!Array.isArray(items) || !items.length) return reply(from, { type: MSG.ERROR, error: 'store: needs `items`, each with its key and its sealed envelope' })
-      const result = await varsDesk.setMany({ ns, items, caller: chk.device, by: deviceId, fromService: true })
-      if (result?.pending) {
-        audit('store.pending', { device: deviceId, ns, id: result.pending, count: items.length })
-        log(`[vault] ${ns}: ${deviceId || '????-????'} wants to store ${items.length} variable(s) — waiting for approval (${result.pending})`)
-      } else {
-        audit('store', { device: deviceId, ns, keys: result?.keys || [] })
-        log(`[vault] ${ns}: ${deviceId || '????-????'} stored ${(result?.keys || []).length} new variable(s)`)
-        await notifyMembers('vars', { by: deviceId, keys: result?.keys || [], ns })
-      }
-      return await answer({ op: 'store.result', ns, ts: Date.now(), keys: result?.keys || [], pending: result?.pending || null })
-    } catch (e) {
-      return reply(from, { type: MSG.ERROR, ...(e.code ? { code: e.code } : {}), error: `${op}: ${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 (p.data?.op === 'store.recipients' || p.data?.op === 'store') return handleVarStore(from, p)
-    if (p.data?.op === 'digest') return handleDigest(from, p)
-    if (p.data?.op === 'update-ask') return handleUpdateAsk(from, p)
-    if (p.data?.op === 'update-done' || p.data?.op === 'update-needs-root') return handleUpdateDone(from, p)
-    if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke', 'block', 'blocked'].includes(p.data?.op)) return handleApproval(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)' })
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: secretsScope(ns), ...(await contextoActa()), revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'secrets')
-    // FRONTERA DEL CN (acta): además del scope del cert, el acta tiene que decir que este
-    // miembro es el servicio `ns`. Así el límite no depende solo de qué cert se emitió: la
-    // llave del proxy no ve nada que no sea del proxy, y está escrito donde se puede comprobar.
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    if (!record || !Acta.memberCanReadSecrets(record, chk.device, ns)) {
-      audit('rejected', { what: 'secrets', ns, reason: record ? 'cn' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
-    }
-    // APROBACIÓN: si este APARATO está marcado (`dotrino-vault approval <ID> on`), liberarle
-    // claves privadas exige el visto bueno de un aparato con `approve` — en CADA petición,
-    // que para un servicio bien hecho es una por arranque: pide al (re)iniciar, se queda las
-    // claves en memoria y no vuelve a pedir. 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`.
-    // SOLO PÚBLICAS: NO SE PIDE APROBACIÓN (dueño, 2026-09-01).
-    //
-    // La aprobación existe para soltar CLAVES PRIVADAS. Una variable pública está guardada
-    // en claro —eso es lo que significa marcarla— y ya la ve cualquiera que administre, así
-    // que hacer sonar el teléfono del dueño para entregarla es molestarlo por nada.
-    //
-    // Lo que NO se relaja: quien pide sigue teniendo que ser un miembro identificado, con su
-    // papel y con el `cn` de este cajón (las dos comprobaciones de arriba). Y el filtro lo
-    // hace la BÓVEDA (`bundleFor({ publicOnly })`), no el que pide: si mandáramos todo y el
-    // cliente eligiera, pedir «solo públicas» sería la manera de saltarse la aprobación.
-    const publicOnly = p.data?.publicOnly === true
-    // Entregar SIN aprobación porque no hay quien apruebe es la regla (ver `needsApproval`),
-    // pero se deja dicho: quien mire el log tiene que poder ver por qué no sonó el teléfono.
-    if (!publicOnly && record && !Acta.memberCan(record, chk.device, 'unattended') &&
-        !record.members?.some((m) => Acta.memberCan(record, m.pub, 'approve'))) {
-      audit('secrets.no-approver', { device: await deviceIdOf(chk.device).catch(() => null), ns })
-      log(`[vault] ${ns}: served ${await deviceIdOf(chk.device).catch(() => '????-????')} without approval — nobody in the record can approve`)
-    }
-    if (!publicOnly && needsApproval(chk.device, record)) {
-      const deviceId = await deviceIdOf(chk.device).catch(() => null)
-      const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
-      // QUÉ COMANDO, DESDE QUÉ CARPETA — medido contra `/proc` si se puede.
-      let ctx = null
-      try { ctx = contextoDelPedido(p.data?.ctx) } catch (e) {
-        audit('rejected', { what: 'secrets', ns, reason: 'ctx-mismatch' })
-        log(`[vault] ${ns}: refused ${deviceId || '????-????'} — ${e.message}`)
-        return reply(from, { type: MSG.ERROR, code: 'ctx-mismatch', error: 'unauthorized: ' + e.message })
-      }
-      // ¿YA DIJISTE QUE SÍ A ESTE COMANDO? Entonces no se vuelve a timbrar: la concesión
-      // dura una hora DESDE EL ÚLTIMO USO, así que un servicio que sigue pidiendo la
-      // mantiene viva. Cambia el comando o la carpeta y esto ya no encaja: otro pedido.
-      const vigente = grants.allows({ ns, device: chk.device, ctx })
-      if (vigente) {
-        try {
-          const res = await resultFor(ns, chk.device, p.data.ek, record, { publicOnly: false })
-          audit('secrets', { device: deviceId, ns, grant: vigente.id })
-          log(`[vault] ${ns}: ${deviceId || '????-????'} served without ringing (approved command, ${vigente.uses} use(s))`)
-          return reply(from, { type: MSG.SECRETS_RESULT, ...res })
-        } catch (e) {
-          return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
-        }
-      }
-      // (Aquí se rechazaba con `no-approver` cuando nadie podía aprobar. Desde 2026-09-24 ese
-      // caso ya no llega: sin aprobadores, `needsApproval` dice que no hace falta aprobación.)
-      // `from` SE GUARDA: la respuesta llega más tarde —cuando alguien apruebe— y tiene que
-      // volver POR DONDE VINO. Si la pregunta entró por el mostrador local, mandarla por el
-      // proxio la deja en el vacío: quien preguntó está escuchando en el socket, no ahí.
-      // Lo cazó el E2E de aprobación, que se quedó esperando cinco minutos.
-      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek, ctx, from })
-      audit('secrets.pending', { device: deviceId, ns, id: pend.id })
-      log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})` +
-        (ctx ? ` — ${commandLine(ctx, 80)}  [${ctx.cwd || '?'}]` : ' — it does not say what it is running'))
-      const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
-      // 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
-    }
-    let res
-    try { res = await resultFor(ns, chk.device, p.data.ek, record, { publicOnly }) } catch (e) {
-      return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
-    }
-    audit('secrets', { device: await deviceIdOf(chk.device), ns, ...(publicOnly ? { publicOnly: true } : {}) })
-    reply(from, { type: MSG.SECRETS_RESULT, ...res })
-  }
-
-  /** El bundle de `ns` para `devicePub`, sellado a su `ek` y firmado por la llave de sellado. */
-  async function resultFor (ns, devicePub, ek, record, { publicOnly = false } = {}) {
-    // 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, { publicOnly })
-    // 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.
-    // 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])), acta: record || null }
-      : { sealed: b, acta: record || null }
-    // LO QUE SE MANDA CON AGUJEROS, SE DICE. La bóveda sabe aquí mismo que este aparato no
-    // tiene envoltura de tal variable —`missingFor` lo contesta—, y hasta hoy se callaba:
-    // contestaba un bundle que el agente no podía abrir y el registro decía «aprobado»,
-    // como si se hubiera servido. Desde fuera parecía que el pedido funcionaba y volvía a
-    // aparecer una y otra vez. Falta la envoltura, y eso solo se arregla ABRIENDO la
-    // bóveda; decirlo aquí es lo que convierte un bucle mudo en algo que se puede arreglar.
-    if (!b.legacy && !publicOnly) {
-      const faltan = [...secrets.missingFor(`ns:${ns}`, devicePub), ...secrets.missingFor(`dev:${devicePub}`, devicePub)]
-      if (faltan.length) {
-        const quien = await deviceIdOf(devicePub).catch(() => '????-????')
-        audit('secrets.no-wrapping', { device: quien, ns, vars: faltan })
-        log(`[vault] ${ns}: ${quien} has no wrapping for ${faltan.join(', ')} — open the vault (dotrino-vault unlock) so it hands it the key`)
-      }
-    }
-    const enc = await seal({ ek, payload })
-    // La huella va con cada entrega: es la referencia con la que el servicio compara después
-    // (`digest`) sin volver a pedir claves.
-    const body = { op: 'secrets.result', ns, enc, digest: drawerDigest(ns, devicePub), ts: Date.now() }
-    // 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
-  }
-
-  /**
-   * PEDIDOS DE APROBACIÓN (aparatos marcados con `approval on`). Entran por `vault.secrets` con
-   * `op: approvals | approve | deny`, firmados por un aparato al que el ACTA le da `approve`
-   * — que, como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`).
-   *
-   * DECIDE EL ACTA, NO EL PAPEL (dueño, 2026-09-26). El papel solo prueba que el aparato es
-   * de esta bóveda y no está revocado; por eso no se le pide `vault:approve`. Pedírselo
-   * contestaba `unauthorized: scope` a un teléfono SIN el permiso, el teléfono lo tomaba por
-   * un papel atrasado, pedía renovarlo, y renovar firma con la maestra: con la bóveda
-   * cerrada le llegaba «vault locked», que no era la causa. Ahora le llega `acta`, que sí lo
-   * es. Y a uno CON el permiso ya no le hace falta renovar para aprobar: funciona con la
-   * bóveda cerrada, como todos los aparatos.
-   */
-  async function handleApproval (from, p) {
-    const op = p.data?.op
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      ...(await contextoActa()), 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: record ? 'acta' : 'sin-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() }
-      reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body) })
-    }
-    // AL PEDIR SU LISTA, EL APROBADOR DICE SI LE LLEGAN LOS AVISOS (`notify`). Va dentro de lo
-    // que ya firma, así que no hay mensaje nuevo ni nada que el proxio pueda inventar.
-    if (op === 'approvals' && typeof p.data?.notify === 'boolean') {
-      try { notifiable.declare(chk.device, p.data.notify) } catch (e) { log(`[vault] could not record whether ${by || '????-????'} can be notified: ${e.message}`) }
-    }
-    // `notices`: lo que no es un pedido y quien aprueba tiene que saber (la bóveda se
-    // actualizó). El timbre de una app nativa llega vacío, así que lo lee de aquí.
-    if (op === 'approvals') return answer({ op: 'approvals', items: await conContextoSellado(approvals.list(), chk.device, record), notices: notices.list() })
-    // LO QUE YA ESTÁ APROBADO SE VE Y SE CORTA DESDE DONDE SE APROBÓ. Una concesión que se
-    // renueva con cada uso puede durar indefinidamente: si no se puede mirar ni quitar desde
-    // el mismo sitio donde se dio, es un permiso invisible, y eso no lo damos por bueno.
-    if (op === 'grants') return answer({ op: 'grants', items: await conContextoSellado(grants.list(), chk.device, record), ttlMs: GRANT_TTL_MS })
-    // LOS BLOQUEADOS SE VEN desde donde se bloquean. Desbloquear no: eso es de la bóveda
-    // (`dotrino-vault unblock <ID>`) o del administrador, que es lo que pidió el dueño.
-    if (op === 'blocked') return answer({ op: 'blocked', items: blocked.list() })
-    if (op === 'grant-revoke') {
-      const gid = typeof p.data?.id === 'string' ? p.data.id : ''
-      const ok = gid ? grants.revoke(gid) : false
-      if (ok) {
-        audit('secrets.grant.revoked', { id: gid, by })
-        log(`[vault] grant ${gid} revoked by ${by} — that command will ring again`)
-      }
-      return answer({ op: 'grant-revoke.result', id: gid, ok })
-    }
-    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' })
-    // UN INCIDENTE no entrega nada: se contesta BLOQUEAR (`block`) o IGNORAR (`deny`).
-    // `approve` no significa nada aquí y se rechaza en voz alta: el pedido vuelve a la mesa
-    // para que lo conteste con la palabra correcta.
-    if (pend.kind === 'incident') {
-      if (op !== 'block' && op !== 'deny') {
-        approvals.request({ ...pend, ttlMs: Math.max(1000, pend.exp - Date.now()) })
-        return reply(from, { type: MSG.ERROR, error: 'approval: an incident is answered with block or deny' })
-      }
-      if (op === 'deny') {
-        audit('incident.ignored', { device: pend.deviceId, kind: pend.ctx?.kind || null, id, by })
-        log(`[vault] incident ${id} about ${pend.deviceId} ignored by ${by}`)
-        return answer({ op: 'deny.result', id, ok: true })
-      }
-      const b = blocked.block({ pub: pend.device, deviceId: pend.deviceId, label: pend.label, by, reason: pend.ctx?.kind || 'incident' })
-      // Lo que ya tenía concedido se corta en el acto: bloquear y dejarle pasar la hora que
-      // le quedaba sería un bloqueo de mentira.
-      const cut = grants.revokeAll({ device: pend.device })
-      audit('blocked', { device: pend.deviceId, kind: pend.ctx?.kind || null, id, by, grants: cut })
-      log(`[vault] BLOCKED ${pend.deviceId}${pend.label ? ` (${pend.label})` : ''} by ${by} after incident ${id} · unblock with: dotrino-vault unblock ${pend.deviceId}`)
-      // Se avisa a todos: los agentes (la terminal) traen la lista con el acta al recibirlo
-      // y le cierran la sesión que tenga abierta. Sin esto el bloqueo esperaba al tic de 5 min.
-      await notifyMembers('blocked', { deviceId: pend.deviceId, by })
-      return answer({ op: 'block.result', id, ok: true, deviceId: pend.deviceId, since: b.since })
-    }
-    if (op === 'block') return reply(from, { type: MSG.ERROR, error: 'approval: only an incident can be blocked' })
-    // PEDIDOS QUE NO ENTREGAN UN CAJÓN (la bóveda de contraseñas, guardar variables). Se
-    // resuelven ANTES de tocar `resultFor`, que asume un cajón y una `ek`: aquí no hay nada
-    // que sellar, solo una promesa esperando un sí o un no.
-    if (waiters.has(id)) {
-      const resolver = waiters.get(id)
-      waiters.delete(id)
-      const ok = op === 'approve'
-      const what = pend.kind === 'write' ? 'vars' : pend.kind === 'update' ? 'update' : 'passwords'
-      audit(ok ? `${what}.approved` : `${what}.denied`, { device: pend.deviceId, ns: pend.ns, id, by })
-      log(`[vault] ${what}: request ${pend.id} of ${pend.deviceId} ${ok ? 'approved' : 'DENIED'} by ${by}`)
-      // Lo aprobado SE HACE AQUÍ (una escritura se aplica ahora), y si falla quien aprobó
-      // tiene que enterarse: decirle «hecho» a algo que no se guardó es el peor resultado.
-      try { await resolver(ok) } catch (e) {
-        log(`[vault] ${what}: ${pend.id} was approved but could not be applied: ${e.message}`)
-        audit(`${what}.apply-failed`, { id, reason: e.message })
-        return reply(from, { type: MSG.ERROR, error: `approval: approved, but it could not be applied: ${e.message}` })
-      }
-      return answer({ op: `${op}.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 {
-        const err = { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }
-        const porLocal = pend.from && canales.get(pend.from)
-        if (porLocal) porLocal(err)
-        else client.sendByPubkey(pend.device, err)
-      } catch (e) { log(`[vault] ${pend.ns}: could not tell ${pend.deviceId} it was denied: ${e.message}`) }
-      return answer({ op: 'deny.result', id, ok: true })
-    }
-    if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
-    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 })
-    }
-    // LA HORA EMPIEZA AQUÍ, y se estira con cada uso: decir que sí a este comando vale para
-    // las siguientes veces que lo pida ESE MISMO comando desde ESA MISMA carpeta. Un pedido
-    // que no dijo qué corría no deja nada anotado, y se dice por qué: si no, el dueño vería
-    // que unos pedidos dejan de timbrar y otros no, sin ninguna explicación a mano.
-    const grant = grants.grant({ ns: pend.ns, device: pend.device, deviceId: pend.deviceId, ctx: pend.ctx, by })
-    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by, ...(grant ? { grant: grant.id } : {}) })
-    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by}`)
-    log(grant
-      ? `[vault] ${pend.ns}: "${commandLine(pend.ctx, 80)}" approved for ${Math.round(GRANT_TTL_MS / 60000)} min from its last use (grant ${grant.id})`
-      : `[vault] ${pend.ns}: no grant — this request did not say what it is running, so the next one will ring again`)
-    // Va por `sendByPubkey`: si el que pedía ya no está conectado, lo recoge al volver.
-    // EL FALLO NO SE TRAGA. Tragarlo era lo peor de este mostrador: la bóveda apuntaba
-    // «aprobado», el que pedía no recibía nada, y no quedaba una sola línea que mirar —
-    // así que el dueño aprobaba una y otra vez creyendo que el teléfono no llegaba.
-    // Por el canal por el que preguntó. Si fue el proxio, `sendByPubkey`: así lo recoge al
-    // volver aunque ahora esté apagado. Si fue el socket local, por el socket.
-    try {
-      const porLocal = pend.from && canales.get(pend.from)
-      if (porLocal) porLocal({ type: MSG.SECRETS_RESULT, ...res })
-      else client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res })
-    } catch (e) { log(`[vault] ${pend.ns}: approved, but the reply did not reach ${pend.deviceId}: ${e.message}`) }
-    return answer({ op: 'approve.result', id, ok: true })
-  }
-
-  /**
-   * EL COMANDO Y EL PATH VIAJAN DENTRO DE UN SOBRE, no en claro.
-   *
-   * La lista de pedidos sale hacia el teléfono por el proxio, que no cifra (CONVENCIONES
-   * §4.1): mandar ahí el `argv` y el `cwd` le enseñaría al que opera el proxio las rutas del
-   * disco del dueño y los argumentos de sus comandos, que es justo lo que este ecosistema
-   * promete que no pasa. Así que el contexto se cifra **para el aparato que está
-   * preguntando** —con la misma cripto de los secretos sellados: una llave de una vez,
-   * envuelta a su `encPub` del acta— y él lo abre con `openSealedValue`, con una privada que
-   * no sale de su dispositivo.
-   *
-   * Un aparato sin `encPub` en el acta no recibe el contexto, y se dice (`ctxSealed: false`)
-   * en vez de mandárselo en claro «para que al menos lo vea»: eso sería cambiar la promesa
-   * por comodidad, y encima sin avisar a nadie.
-   */
-  async function conContextoSellado (items, aprobador, record) {
-    const encPub = (record?.members || []).find((m) => m.pub === aprobador)?.encPub || null
-    const salida = []
-    for (const it of items) {
-      const { ctx, ...resto } = it
-      if (!ctx) { salida.push({ ...resto, ctx: null }); continue }
-      if (!encPub) { salida.push({ ...resto, ctx: null, ctxSealed: false, ctxReason: 'no-enc-key' }); continue }
-      try {
-        const cek = await makeContentKey()
-        const envelope = await encryptWithCek({ cek, gen: 0, plaintext: JSON.stringify(ctx) })
-        const wrap = await wrapForMember({ cek, memberEncPub: encPub })
-        salida.push({ ...resto, ctx: null, ctxSealed: true, ctxWrap: wrap, ctxEnvelope: envelope })
-      } catch (e) {
-        // NO SE TRAGA: sin esto, un fallo al sellar se vería en el teléfono igual que un
-        // pedido que no dice nada, y nadie sabría que hay algo que arreglar.
-        log(`[vault] could not seal the command of ${it.id} for ${aprobador.slice(0, 24)}…: ${e.message}`)
-        salida.push({ ...resto, ctx: null, ctxSealed: false, ctxReason: 'seal-failed' })
-      }
-    }
-    return salida
-  }
-
-  /**
-   * Aviso a los aparatos que aprueban (cola del proxio → timbre nativo si están apagados).
-   *
-   * LA MAESTRA NO FIRMA ESTO, y es el fallo que dejaba el mecanismo entero inservible.
-   * Avisar es SERVIR, y servir es trabajo de la llave de sellado —la maestra solo sella el
-   * acta y reenvuelve los sobres al abrir (CLAUDE.md, «la maestra tiene DOS trabajos»)—.
-   * Con `identity.signData` esto reventaba con «vault locked» en cada pedido, o sea SIEMPRE:
-   * la bóveda vive cerrada, que es justamente para lo que sirve el candado. Y como reventaba
-   * antes de mandar nada, el proxio no tenía a quién encolar y el teléfono NO TIMBRABA
-   * NUNCA. El pedido solo se veía si al dueño se le ocurría abrir la app por su cuenta.
-   *
-   * El aviso no lleva nada que no esté ya en el pedido, y el timbre que sale de aquí sigue
-   * sin contenido: quien lo recibe pregunta por la lista, no la lee del aviso.
-   */
-  async function notifyApprovers (pend, record) {
-    try {
-      // `kind` dice QUÉ se pide (llevarse claves, guardar variables, actualizar…): es lo que la
-      // app necesita para que el aviso diga el porqué sin tener que abrir la lista. Los
-      // detalles (comando, carpeta, nombres) NO van aquí: van sellados en la lista.
-      const body = { ev: 'approval', id: pend.id, ns: pend.ns, kind: pend.kind || 'read', deviceId: pend.deviceId, label: pend.label, exp: pend.exp, ts: Date.now() }
-      const seal = await sealOrFail(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)`)
-      // EL FALLO NO SE TRAGA. Un aviso que no sale es un teléfono que no timbra, y eso
-      // desde fuera se ve igual que «nadie ha aprobado todavía»: se espera para siempre
-      // sin nada que mirar. Es el mismo cuidado que en `notifyMembers`.
-      for (const pub of who) {
-        // A la app que APRUEBA (`vault`): en un teléfono la llave es de todas sus apps, y sin
-        // decirlo el pedido timbraba a messenger (websocket-proxy ≥ 1.4.0).
-        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, seal }, { app: 'vault' }) }
-        catch (e) { log(`[vault] could not ring ${pub.slice(0, 24)}… about ${pend.ns}: ${e.message}`) }
-      }
-      log(`[vault] ${pend.ns}: rang ${who.length} approver(s) for ${pend.id}`)
-    } catch (e) { log('[vault] could not notify approvers:', e.message) }
-  }
-
-  /**
-   * «ME ACTUALICÉ», a todo el que aprueba (dueño, 2026-10-08). Vale con la aprobación
-   * encendida o apagada: lo que se instala solo también se cuenta.
-   *
-   * Lo manda la versión NUEVA ya corriendo —el daemon llama aquí al arrancar, si dejó dicho
-   * que instaló—, que es la prueba de que ocurrió. El aviso queda además en `notices`, de
-   * donde lo lee una app nativa (su timbre llega vacío).
-   *
-   * También reparte el «me actualicé» de un APARATO (`op: 'update-done'`): entonces lleva su
-   * `product`, `deviceId` y `label`.
-   *
-   * Y con `ev: 'update-needs-root'` cuenta lo contrario: hay versión nueva y NO se instaló
-   * sola porque necesita permisos de administrador (dueño, 2026-10-08: «si se requiere root
-   * por algún motivo, simplemente se notifica al aprobador»). Mismo camino, otro `ev`.
-   *
-   * A diferencia de `notifyApprovers`, aquí el fallo SE LANZA: quien llama guarda el
-   * marcador hasta que el aviso salió, y tragarlo sería borrarlo sin haber avisado.
-   * @returns {Promise<{ approvers: number, sent: number, notice: object|null }>}
-   */
-  async function announceUpdate ({ version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null, ev = 'updated' }) {
-    const record = await refreshActa()
-    const who = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).map((m) => m.pub)
-    if (!who.length) return { approvers: 0, sent: 0, notice: null }
-    // `deviceId`/`label`: solo cuando quien se actualizó es un APARATO (`update-done`). El
-    // aviso de la propia bóveda no los lleva.
-    const notice = notices.add(ev, { version, from, product, ...(deviceId ? { deviceId, label: label || '' } : {}) })
-    const { id, ev: _ev, ts, ...rest } = notice
-    const body = { ev, id, ...rest, ts }
-    const seal = await sealOrFail(body)
-    let sent = 0
-    for (const pub of who) {
-      try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, seal }, { app: 'vault' }); sent++ }
-      catch (e) { log(`[vault] could not tell ${pub.slice(0, 24)}… about the update of ${product} to ${version}: ${e.message}`) }
-    }
-    audit(ev === 'updated' ? 'update.announced' : 'update.needs-root', { product, version, from: notice.from, device: deviceId, approvers: who.length, sent })
-    log(`[vault] update: told ${sent} of ${who.length} approver(s) that ${deviceId ? `${deviceId} (${product})` : 'this vault'} ${ev === 'updated' ? 'now runs' : 'needs administrator rights to install'} ${version}`)
-    if (!sent) throw Object.assign(new Error('no approver could be told'), { code: 'announce-failed' })
-    return { approvers: who.length, sent, notice }
-  }
-
-  /**
-   * UN INCIDENTE: un agente de la cuenta dice que OTRO aparato de la cuenta se equivocó de
-   * clave tres veces seguidas (la terminal, `dotrino-terminal lock`). No se decide aquí
-   * nada: se apunta como un pedido más, de tipo `incident`, y se timbra a quien aprueba,
-   * que es quien bloquea o ignora desde el teléfono. Sin nadie que apruebe no hay a quién
-   * preguntar: se anota en la bitácora y se dice, y el agente se queda con su freno local.
-   *
-   * Quien reporta tiene que ser un miembro con `sign` (es lo que lo hace agente), y el
-   * señalado tiene que estar en el acta: un incidente sobre un desconocido no es un incidente.
-   * Y si el señalado ya está bloqueado no se vuelve a timbrar: se contesta que lo está.
-   */
-  async function handleIncident (from, p) {
-    if (!isFresh(p.data)) return staleReply(from)
-    const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
-    if (!chk.ok) return denyChain(from, chk, p, 'incident')
-    const record = await refreshActa()
-    if (!record || !Acta.memberCan(record, chk.device, 'sign')) {
-      audit('rejected', { what: 'incident', reason: record ? 'acta' : 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member cannot report incidents' })
-    }
-    const d = p.data || {}
-    const kind = typeof d.kind === 'string' ? d.kind.slice(0, 32) : ''
-    const about = typeof d.about === 'string' ? d.about : ''
-    const tries = Number.isInteger(d.tries) ? d.tries : null
-    if (d.op !== 'incident' || !kind || !about) return reply(from, { type: MSG.ERROR, error: 'incident: op, kind and about are required' })
-    const target = (record.members || []).find((m) => m.pub === about)
-    if (!target) return reply(from, { type: MSG.ERROR, code: 'unknown-device', error: 'incident: that device is not in the record' })
-    const by = await deviceIdOf(chk.device).catch(() => null)
-    const byLabel = (record.members || []).find((m) => m.pub === chk.device)?.label || ''
-    const deviceId = await deviceIdOf(about).catch(() => null)
-    audit('incident', { device: deviceId, by, kind, tries })
-    if (blocked.has(about)) {
-      log(`[vault] incident (${kind}) about ${deviceId} reported by ${by}: already blocked`)
-      return reply(from, { type: MSG.INCIDENT_RESULT, id: null, approvers: 0, blocked: true })
-    }
-    const approvers = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).length
-    if (!approvers) {
-      log(`[vault] incident (${kind}) about ${deviceId} reported by ${by}: nobody can approve, so nobody is asked (grant it with: dotrino-vault caps <ID> +aprueba)`)
-      return reply(from, { type: MSG.INCIDENT_RESULT, id: null, approvers: 0, blocked: false })
-    }
-    // `ns` es el que reporta: la pantalla dice «X falló la clave de la terminal de Y». El
-    // contexto va sellado al aprobador como el de cualquier pedido.
-    const pend = approvals.request({
-      ns: by || 'incident', kind: 'incident', device: about, deviceId, label: target.label || '', ek: '',
-      ctx: { kind, tries, reporter: by, reporterLabel: byLabel }, from, ttlMs: UPDATE_TTL_MS
-    })
-    log(`[vault] incident (${kind}) about ${deviceId}${target.label ? ` (${target.label})` : ''} reported by ${by}: asking ${approvers} approver(s) (${pend.id})`)
-    await notifyApprovers(pend, record)
-    reply(from, { type: MSG.INCIDENT_RESULT, id: pend.id, approvers, blocked: false })
-  }
-
-  client.on('message', (from, payload) => onMessage(from, payload))
-
-  // EL MOSTRADOR LOCAL, siempre que se pueda. Si no se puede abrir (un sistema sin sockets
-  // de archivo, un directorio de solo lectura) se dice y se sigue: los servicios usan el
-  // proxio como hasta ahora. Lo que NO se hace es callarlo — un atajo que no está y nadie
-  // lo dice es media hora buscando por qué algo va lento.
-  // El socket se nombra por la LLAVE de esta bóveda: una máquina puede tener varias, y un
-  // servicio solo conoce la maestra que lleva pineada. Así los dos lados calculan la misma
-  // ruta sin mirar ningún índice.
-  if (identity.me?.publickey) {
-    abrirMostradorLocal(localSocketPath((await pubkeyId(identity.me.publickey)).slice(0, 16)))
-  }
-
-  async function onMessage (from, payload) {
-    if (!payload || typeof payload !== 'object') return
-    try {
-      if (payload.type === MSG.HELLO) return desk.handleHello(from, payload)
-      if (payload.type === MSG.ENROLL) return await desk.handleEnroll(from, payload)
-      if (payload.type === MSG.ACTA_SEALED) return await desk.handleActaSealed(from, payload)
-      if (payload.type === MSG.SIGN) return await handleSign(from, payload)
-      if (payload.type === MSG.GET) return await handleGet(from, payload)
-      if (payload.type === MSG.STORE) return await handleStore(from, payload)
-      if (payload.type === MSG.CHECK) return await handleCheck(from, payload)
-      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)
-      if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
-      if (payload.type === MSG.INCIDENT) return await handleIncident(from, payload)
-      if (payload.type === MSG.REPLICA_ACK) return await handleReplicaAck(from, payload)
-      if (payload.type === MSG.LOGIN_START) return await handleLoginStart(from, payload)
-      if (payload.type === MSG.LOGIN_FINISH) return await handleLoginFinish(from, payload)
-      if (payload.type === MSG.LOGIN_CLOSE) return await handleLoginClose(from, payload)
-    } catch (e) {
-      reply(from, { type: MSG.ERROR, error: e.message })
-    }
-  }
-
-  /**
-   * EL MOSTRADOR LOCAL: el mismo protocolo, sin salir de la máquina.
-   *
-   * Un servicio en ESTA máquina hablaba con la bóveda dando la vuelta por
-   * `proxy.dotrino.com`: sale a internet, vuelve, y si el proxio tiene un mal momento el
-   * arranque se retrasa cinco segundos por nada. Absurdo cuando los dos procesos comparten
-   * disco (dueño, 2026-09-03: «estando en la misma máquina debería ser inmediato»).
-   *
-   * Es EL MISMO PROTOCOLO y el mismo enrutador: llega `{type, data, signature, cert}` y se
-   * comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket no
-   * autoriza nada** — es la misma puerta por un camino más corto, no una puerta de atrás.
-   * Por eso no hay un solo `if` de «viene de local» en ningún handler, y no debe haberlo.
-   *
-   * Y no es un puerto: es un socket de archivo, en modo 0600 y bajo el directorio del
-   * usuario. No se alcanza desde otra máquina ni desde otro usuario, así que la promesa
-   * del `docker-compose` —«la bóveda no escucha nada»— sigue siendo cierta donde importa.
-   */
-  function abrirMostradorLocal (socketPath) {
-    let n = 0
-    const server = net.createServer((sock) => {
-      const id = 'local:' + (++n)
-      let buf = ''
-      const enviar = (obj) => { try { sock.write(JSON.stringify(obj) + '\n') } catch (_) {} }
-      canales.set(id, enviar)
-      sock.on('data', (chunk) => {
-        buf += chunk
-        // UN TOPE, y por lo mismo que en las respuestas: sin él, quien se conecte puede
-        // hacer crecer este buffer hasta tumbar la bóveda mandando y sin saltos de línea.
-        if (buf.length > MAX_REPLY_BYTES) { buf = ''; enviar({ type: MSG.ERROR, error: 'request too big' }); return }
-        let i
-        while ((i = buf.indexOf('\n')) >= 0) {
-          const linea = buf.slice(0, i); buf = buf.slice(i + 1)
-          if (!linea.trim()) continue
-          let p = null
-          try { p = JSON.parse(linea) } catch (_) { enviar({ type: MSG.ERROR, error: 'malformed request' }); continue }
-          onMessage(id, p).catch((e) => enviar({ type: MSG.ERROR, error: e.message }))
-        }
-      })
-      const cerrar = () => canales.delete(id)
-      sock.on('close', cerrar)
-      sock.on('error', cerrar)
-    })
-    server.on('error', (e) => log('[vault] the local desk could not open (' + e.message + '): services will use the proxy'))
-    // EL DIRECTORIO ES EL CONTROL, no el modo del socket.
-    //
-    // `mkdir` con `mode` NO corrige un directorio que ya existe, y sin `XDG_RUNTIME_DIR`
-    // —un servicio de sistema, un contenedor— esto cae en `/tmp`, donde cualquiera puede
-    // haberlo creado antes con permiso de escritura para todos. Quien sea dueño del
-    // directorio puede borrar el socket y poner el suyo: los servicios de esta máquina
-    // acabarían hablando con él. No leería nada (la respuesta va firmada por una llave que
-    // nombra el acta y el cliente la comprueba), pero los deja sin arrancar.
-    //
-    // Y el `chmod 0600` de abajo llega DESPUÉS de `listen`, así que por sí solo deja una
-    // rendija. Lo que la cierra de verdad es que el directorio sea nuestro y solo nuestro.
-    const dir = socketDir()
-    try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }) } catch (_) {}
-    try {
-      const st = fs.statSync(dir)
-      const ajeno = typeof process.getuid === 'function' && st.uid !== process.getuid()
-      const abierto = (st.mode & 0o077) !== 0
-      if (ajeno || abierto) {
-        return log(`[vault] the local desk stays closed: ${dir} is ${ajeno ? 'owned by another user' : 'writable by others'} ` +
-          '— services on this machine will use the proxy instead')
-      }
-    } catch (e) {
-      return log('[vault] the local desk stays closed: could not check ' + dir + ' (' + e.message + ')')
-    }
-    try { fs.rmSync(socketPath, { force: true }) } catch (_) {}
-    server.listen(socketPath, () => {
-      try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
-      log('[vault] local desk at ' + socketPath + ' (same machine, no round trip)')
-    })
-    server.unref?.()
-    return server
-  }
-
-  /**
-   * 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
-    // ESTE MENSAJE NO LO FIRMA NADIE, y no hace falta: el acta se autentica sola —va sellada
-    // y `canAdopt` comprueba que la selló quien la MÍA reconoce—. Pero eso solo funciona si
-    // hay una mía contra la que comparar: sin acta previa, `canAdopt` acepta cualquiera
-    // («sin-acta-previa»), y este es el único mostrador donde una llega de un desconocido.
-    // Anunciar no es cómo se entra en una cuenta —para eso está el enrolamiento—, así que
-    // sin acta propia no se adopta: se dice y se para.
-    const propia = (await identity.profileActa?.().catch(() => null))?.acta || null
-    if (!propia) return log('[vault] a record was announced but this vault has none of its own to compare it with: ignored')
-    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
-  // la CA. Solo se levanta cuando el acta autoriza a alguien — sin eso no hay a quién
-  // responder, y crear la llave por si acaso sería crear un secreto que nadie pidió.
-  //
-  // Y se levanta EN CUANTO pasa, no en el siguiente arranque: conceder el permiso ya es
-  // un acto explícito del dueño, y pedirle además que reinicie la bóveda es de las cosas
-  // que se olvidan y luego parecen un fallo del gestor.
-  let passwords = null
-  /**
-   * EL SELLADO del gestor: la misma cripto de los sobres del ecosistema
-   * (`@dotrino/identity/content`), atada a la llave de cifrado de esta bóveda.
-   *
-   * Lo arma el PILAR (`identitySealing`), que es la MISMA pieza que usan las otras dos
-   * bóvedas —la de la pestaña y la de dentro de la extensión—. Estaba escrito a mano aquí,
-   * y son las tres puntas del mismo sobre: tres copias son dos que se pueden quedar atrás,
-   * y ese fallo no hace ruido — la petición sale, al otro lado «no es para mí», y desde
-   * fuera se ve como que nadie respondió.
-   *
-   * NO se pone `requireSealed` en el cliente, y no es un olvido: el cliente del vault es
-   * UNO y lo comparte todo, y el protocolo de la CA viaja en claro a propósito (un
-   * enrolamiento es público hasta que hay cert). Lo que corta aquí es `VaultResponder`,
-   * que tira lo que llegue sin la marca `sealed`. Por eso `isSealed` mira la marca del
-   * gestor y no otra.
-   *
-   * Sin esto la bóveda RECIBÍA los sobres y los tiraba —el cliente no tenía con qué
-   * abrirlos— y el aparato se quedaba esperando sin que nada lo dijera.
-   */
-  const passwordSealing = identitySealing(identity)
-  const startPasswordDesk = async () => {
-    if (passwords || !passwordDevices().length) return
-    const { createPasswordDesk } = await import('./passwords.js')
-    client.updateConfig({ sealing: passwordSealing })
-    passwords = createPasswordDesk({
-      client,
-      store: passwordsStore,
-      // LA BÓVEDA NO TIENE LLAVE. Lo que pone aquí es a quién envolverle las que hacen los
-      // aparatos, y la pública de la copia de recuperación —la que abre la frase del perfil
-      // y es la única forma de volver a repartir una entrada si un día no queda ningún
-      // aparato—. Ninguna de las dos abre nada por sí sola.
-      members: (kind) => passwordRecipients(kind),
-      recoveryPub: () => secrets.recoveryPub(),
-      canWrite: (pub) => !!actaCache && !!pub && Acta.memberCan(actaCache, pub, 'passwords'),
-      // UNA sola condición, y es del ACTA: el aparato tiene la capacidad `passwords`.
-      // Quitársela —o quitar el aparato— le corta esto en la siguiente pasada, sin
-      // que haya una segunda lista que acordarse de tocar.
-      isAllowed: (pub) => !!actaCache && Acta.memberCan(actaCache, pub, 'passwords'),
-      encPubOf: (pub) => (actaCache?.members || []).find((m) => m.pub === pub)?.encPub || null,
-      // EN VIVO, no del caché: conceder o quitar `unattended` tiene que surtir efecto en
-      // el acto. Con el caché, la mesa de contraseñas seguía decidiendo con la foto del
-      // último refresco — y en el sentido peligroso: un aparato al que le acabas de quitar
-      // el permiso se seguía sirviendo solo.
-      needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
-      // El teléfono: se apunta el pedido, se le avisa y esta promesa espera su firma.
-      // Es el mismo camino que ya recorren los cajones de secretos.
-      // EL PEDIDO DICE QUÉ SE QUIERE LEER (dueño, 2026-09-30: «es importante que se sepa el
-      // porqué»). Antes salía como `read` sin contexto, y el teléfono enseñaba «pide tus claves
-      // de passwords · no dice qué está ejecutando», que parece un servicio desconocido cuando
-      // es tu extensión pidiendo una contraseña. Ahora es `kind: 'passwords'` con la operación y
-      // los CAMPOS (`password`, `totp`…) — nunca la entrada ni el sitio, que no se ven aquí.
-      // Va sellado al que aprueba, como el comando de un pedido de claves.
-      approve: async ({ pubkey, op, payload }) => {
-        let resolve
-        const espera = new Promise((r) => { resolve = r })
-        const fields = Array.isArray(payload?.keys) ? payload.keys.slice(0, 12).map((k) => String(k).slice(0, 40)) : null
-        await awaitApproval({
-          device: pubkey, ns: 'passwords', kind: 'passwords', what: 'passwords', op,
-          ctx: { op: String(op || '').replace(/^pm2\./, ''), fields }, onAnswer: resolve
-        })
-        return espera
-      },
-      audit,
-      log,
-    }).start()
-    log(`[vault] passwords: serving ${passwordDevices().length} device(s)`)
-  }
-  try {
-    // El acta ANTES de mirarla: es ella la que dice si hay a quién responder, y sin
-    // refrescarla primero el mostrador no se levantaba nunca en un arranque en frío.
-    await refreshActa()
-    const actaSweeper = setInterval(() => {
-      refreshActa().then(startPasswordDesk).catch(() => {})
-    }, 5000)
-    actaSweeper.unref?.()
-    if (passwordDevices().length) await startPasswordDesk()
-    // Ni código de enlace ni pegar nada: un gestor entra como cualquier otro aparato.
-    else log('[vault] passwords: no device may ask yet · pair one with `dotrino-vault pair --scope contrasenas`')
-  } catch (e) {
-    log(`[vault] passwords: could not start (${e.message}); everything else keeps going`)
-  }
-
-  log(`[vault] listo · id ${fp} · ${store.getTree().children.length} nodos`)
-
-  // ----- API local (CLI/UI de control) -----
-  // Emparejar / aprobar / rechazar / revocar viven en el núcleo compartido (`desk`).
-
-  // ----- AVISO DE CAMBIO a los agentes del ns -----
-  //
-  // Guardar un secreto no sirve de nada si quien lo usa no se entera. La bóveda
-  // avisa (sin mandar valores: solo «el ns cambió») y el agente decide — el
-  // estándar es que SALGA y lo levante su supervisor, para leer todo fresco y,
-  // sobre todo, para que el valor viejo deje de existir en su memoria.
-  //
-  // AGRUPADO a propósito: cargar cinco valores seguidos con `secret set` son cinco
-  // escrituras, pero un solo cambio de configuración. Sin esta ventana serían cinco
-  // reinicios en cadena, y el agente se pasaría la carga entera reiniciándose.
-  // La variable de entorno va en inglés (CONVENCIONES §8.1); nadie la tenía puesta.
-  const NOTICE_GROUP_MS = Number(process.env.DOTRINO_VAULT_NOTICE_MS) || 3000
-  const pendingNotices = new Map()   // clave (ns | 'dev:'+pub) → timer
-
-  async function notifyNsChange (ns) {
-    let targets = []
-    try {
-      const { issued } = await identity.listDelegations()
-      const revokedNonces = await revocationSet()
-      const scope = secretsScope(ns)
-      // Los agentes de ESE ns y nadie más: el aviso dice qué namespace cambió, así
-      // que mandárselo a otro sería filtrarle que existe.
-      //
-      // Y UNO POR LLAVE, no uno por delegación: renovar el cert emite una
-      // delegación nueva para la MISMA sub-clave, así que un agente que lleve
-      // tiempo enrolado aparece varias veces y recibiría el aviso repetido.
-      const seen = new Set()
-      targets = (issued || []).filter((x) => {
-        if (!x.sub || revokedNonces.has(x.nonce) || !(x.scope || []).includes(scope)) return false
-        if (seen.has(x.sub)) return false
-        seen.add(x.sub)
-        return true
-      })
-    } catch (e) { return log('[vault] could not list who to notify:', e.message) }
-    if (!targets.length) return
-
-    // FIRMA LA LLAVE DE SELLADO, con el acta al lado (el servicio lo comprueba con
-    // `verifyResponder`). Firmaba la maestra, y con la bóveda cerrada —que es como vive— el
-    // aviso reventaba antes de salir: el servicio no se enteraba de ningún cambio.
-    const body = { op: 'secrets.changed', ns, ts: Date.now() }
-    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
-    const seal = await sealOrFail(body)
-    for (const d of targets) {
-      try { client.sendByPubkey(d.sub, { type: MSG.SECRETS_CHANGED, body, seal, acta }) } catch (_) {}
-    }
-    audit('secrets.changed', { ns, notified: targets.length })
-    log(`[vault] config for "${ns}" changed: notified ${targets.length} agent(s)`)
-  }
-
-  /**
-   * Cambió una variable de UN aparato: el aviso va solo a ese aparato. El mensaje dice
-   * qué NAMESPACE cambió (es lo que el agente sabe leer), así que hace falta su `cn`; un
-   * miembro sin `cn` no es un servicio y no lee variables, de modo que no hay a quién
-   * avisar y no se manda nada.
-   */
-  async function notifyDeviceChange (pub) {
-    let cn = null
-    let record = null
-    try {
-      record = (await identity.profileActa?.().catch(() => null))?.acta
-      cn = (record?.members || []).find((m) => m.pub === pub)?.cn || null
-    } catch (e) { return log('[vault] could not look up who to notify:', e.message) }
-    if (!cn) return
-    const body = { op: 'secrets.changed', ns: cn, ts: Date.now() }
-    const seal = await sealOrFail(body)
-    try { client.sendByPubkey(pub, { type: MSG.SECRETS_CHANGED, body, seal, acta: record }) } catch (_) {}
-    const device = await deviceIdOf(pub).catch(() => null)
-    audit('secrets.changed', { ns: cn, device, notified: 1 })
-    log(`[vault] config for device ${device} ("${cn}") changed: notified it`)
-  }
-
-  /**
-   * Un cambio de configuración, un aviso: escrituras seguidas se agrupan en la misma
-   * ventana. La CLAVE distingue los dos cajones (`<ns>` y `dev:<pub>`) para que tocar
-   * lo de un aparato no cancele el aviso pendiente de todo su namespace.
-   */
-  function scheduleNotice (ns) {
-    schedule(ns, async () => {
-      await notifyNsChange(ns)
-      // Y a los replicadores el sobre nuevo. Sin esto repartirían el valor de ayer: el
-      // aviso de cambio le dice al servicio que se reinicie, y al reiniciar volvería a
-      // pedir — y si la bóveda está apagada, el replicador le daría lo viejo.
-      await pushToReplicas(`secret:${ns}`)
-    })
-  }
-  function scheduleDeviceNotice (pub) { schedule('dev:' + pub, () => notifyDeviceChange(pub)) }
-
-  function schedule (key, fn) {
-    clearTimeout(pendingNotices.get(key))
-    const t = setTimeout(() => {
-      pendingNotices.delete(key)
-      fn().catch((e) => log('[vault] change notice failed:', e.message))
-    }, NOTICE_GROUP_MS)
-    t.unref?.()
-    pendingNotices.set(key, t)
-  }
-
-  // --- CONSOLA REMOTA (docs/consola-remota.md) ---------------------------------
-  // Un dispositivo con cert `vault:admin` puede ADMITIR y EXPULSAR miembros sin venir
-  // al PC. No puede cambiar permisos, traspasar el mando, conceder `admin` ni tocar los
-  // secretos: esas operaciones no existen como mensaje, a propósito. Así un aparato con
-  // `admin` robado hace daño acotado y reversible (se le revoca) en vez de poder dejar
-  // al dueño fuera de su propia cuenta, que no tiene vuelta atrás.
-  /** Últimas entradas de la bitácora (JSONL), de la más reciente hacia atrás. */
-  function readActivity (limit = 100) {
-    try {
-      return fs.readFileSync(activityFile, 'utf8').split('\n').filter(Boolean).slice(-limit)
-        .map((l) => { try { return JSON.parse(l) } catch (_) { return null } }).filter(Boolean).reverse()
-    } catch (_) { return [] }
-  }
-
-  /**
-   * Avisa a TODOS los miembros de que el perfil cambió, firmado por la maestra. Sin
-   * esto, administrar a distancia sería invisible para el resto de los dispositivos —
-   * y esa visibilidad es lo que hace DETECTABLE a un admin comprometido. Va por
-   * `sendByPubkey`, así que al que está apagado le llega cuando encienda (cola 24 h).
-   */
-  async function notifyMembers (ev, info = {}) {
-    try {
-      // SIN FIRMA, y no falta nada: quien lo usa es el ACTA que viaja al lado, que se
-      // autentica sola (otra bóveda la adopta por `canAdopt`; el teléfono solo refresca y
-      // pregunta). Lo firmaba la maestra, que no firma con la bóveda cerrada: el aviso
-      // reventaba antes de salir y el acta nueva no llegaba a nadie.
-      const body = { ev, ...info, ts: Date.now() }
-      // 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()
-      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).
-        // CALLADO (`quiet`): se encola igual, pero no toca el timbre push. Un aviso de que
-        // el perfil cambió puede esperar a que el aparato abra solo; timbrar por él hacía
-        // sonar el teléfono con «alguien pide tus claves» sin ningún pedido detrás.
-        // El timbre es para los pedidos (`notifyApprovers`), que sí esperan una mano.
-        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, acta }, { quiet: true, app: 'vault' }) }
-        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) }
-    // Y a los replicadores, que no quieren un aviso sino el CONTENIDO: sin esto se
-    // quedarían con el acta de ayer y repartiendo sobres de un aparato ya revocado.
-    await pushToReplicas(ev)
-  }
-
-  /**
-   * EL ARRASTRE AL ARRANCAR (`docs/replicas.md` §6). Un replicador dice por dónde va en
-   * cuanto se conecta, y si va por detrás se le empuja.
-   *
-   * Sin esto, la bóveda solo empujaba al cambiar algo: un replicador que se enciende
-   * después se quedaba vacío hasta el siguiente cambio, que puede no llegar en semanas.
-   * Y el empujón de un enrolamiento se manda a un aparato que todavía no está conectado.
-   * Lo destapó el smoke y era un hueco del diseño, no del código.
-   *
-   * El acuse va FIRMADO por el replicador y se comprueba contra el acta: sin eso, cualquiera
-   * podría pedirle a la bóveda que reparta el acta y los sobres mandando un acuse inventado.
-   */
-  async function handleReplicaAck (from, p) {
-    const body = p?.body
-    if (!body || body.op !== 'replica.ack') return
-    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-    if (!record) return
-    // LA LLAVE VA DENTRO DEL MENSAJE FIRMADO, no se saca de `from`: `from` es el
-    // identificador de la conexión en el proxio, no la llave del miembro. Compararlo con
-    // el acta rechazaba a todo el mundo, y en el caso contrario habría sido peor.
-    const quien = body.publickey
-    if (typeof quien !== 'string' || !Acta.memberCan(record, quien, 'replica')) {
-      return log('[vault] a replica ack arrived from someone the record does not allow to serve: ignored')
-    }
-    if (!(await verifyDeviceSig({ publickey: quien, data: body, signature: p.signature }))) {
-      return log('[vault] a replica ack does not check out against its own key: ignored')
-    }
-    if (typeof body.seq === 'number' && body.seq >= record.seq) return
-    log(`[vault] a replica is at #${body.seq} and we are at #${record.seq}: catching it up`)
-    await pushToReplicas('catch-up')
-  }
-
-  /**
-   * EMPUJAR A LOS REPLICADORES lo que tienen que poder repartir: el acta y los sobres.
-   *
-   * Se manda TODO firmado de antes —el acta la selló la maestra, cada sobre lo firmó la
-   * llave de sellado— así que un replicador no puede falsificar nada de lo que le damos.
-   * Y va cerrado a su destinatario, no a él: reparte sobres que no puede abrir. Es lo que
-   * permite ponerlo en una máquina en la que no confías (`docs/replicas.md` §8.bis).
-   *
-   * Se empuja después de cada cambio, y no se espera acuse: si un replicador está apagado
-   * se queda atrás y lo alcanza el siguiente empujón. Un replicador atrasado no es un
-   * peligro —el cliente rechaza un acta con `seq` menor del que ya vio— sino menos
-   * disponibilidad, que es exactamente lo que un replicador arriesga.
-   */
-  async function pushToReplicas (motivo = 'change') {
-    try {
-      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-      if (!record) return
-      const replicas = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'replica'))
-      if (!replicas.length) return
-
-      // UN SOBRE POR (CAJÓN, APARATO), porque `bundleFor` lo talla a quien lo pide: lleva
-      // solo las envolturas de ESE aparato. Mandar uno genérico no serviría de nada.
-      const bundles = {}
-      for (const m of record.members || []) {
-        if (!m.cn) continue
-        try { bundles[`${m.cn} ${m.pub}`] = secrets.bundleFor(m.cn, m.pub) } catch (_) {}
-      }
-      const body = { op: 'replica.push', seq: record.seq, acta: record, bundles, ts: Date.now() }
-      const seal = await signSeal(body)
-      if (!seal) return log('[vault] cannot push to the replicas: the record names no sealing key of ours')
-      let n = 0
-      for (const r of replicas) {
-        try { client.sendByPubkey(r.pub, { type: MSG.REPLICA_PUSH, body, seal }); n++ }
-        catch (e) { log(`[vault] could not push to a replica: ${e.message}`) }
-      }
-      log(`[vault] pushed record #${record.seq} and ${Object.keys(bundles).length} bundle(s) to ${n} replica(s) on ${motivo}`)
-    } catch (e) { log('[vault] could not push to the replicas: ' + e.message) }
-  }
-
-  /**
-   * MOSTRADOR DE VARIABLES para la consola remota (`lib/src/admin.js` enruta; la política
-   * y la cripto viven aquí, que es donde están la clave y el disco).
-   *
-   * Dos reglas, y son toda la frontera:
-   *
-   *   1. **El valor de una PRIVADA no sale de esta máquina.** Ni para un aparato tuyo con
-   *      `admin`. Lo que viaja de una privada es su nombre y que es privada — con eso se
-   *      le puede poner un valor nuevo a ciegas, que es lo que hace falta para rotarla.
-   *   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 ({ caller = null } = {}) {
-      // EL VAULT DECIDE QUÉ ENVÍA PARA LEER (dueño, 2026-09-02: «la consola debe tener todos
-      // los sobres; la diferencia es si el vault se los envía para la lectura o no»).
-      //
-      // Tener la envoltura y recibir el sobre son dos cosas: quien administra tiene la
-      // envoltura de cada PÚBLICA, y por eso aquí se le manda el sobre de esas y solo de
-      // esas. Las privadas de un cajón con dueño no se mandan — y aunque se mandaran no
-      // podría abrirlas, porque su envoltura no existe. Dos cerrojos para lo mismo, a
-      // propósito: que uno falle no basta para leerlas.
-      //
-      // Se sella la lista ENTERA, no solo los valores: el proxy tampoco tiene por qué
-      // aprender cómo se llaman tus variables ni qué servicios corres.
-      return {
-        enc: await identity.sealContent(JSON.stringify({
-          ns: withEnvelopes(listSecrets(), 'ns', caller), dev: withEnvelopes(await listDeviceSecrets(), 'dev', caller),
-          // 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 } })(),
-          // SI ESTÁ CERRADA, Y SI SE PUEDE ABRIR DESDE AQUÍ. La consola no tenía forma de
-          // saberlo: se enteraba solo al chocar con un `vault-locked` intentando algo. Y
-          // `remoteUnlock` distingue las dos razones por las que el formulario no aparece —
-          // «no está cerrada» y «no hay contraseña de admin puesta»— que son cosas
-          // distintas y llevan a acciones distintas.
-          locked: (() => { try { return !!isLocked() } catch (_) { return true } })(),
-          remoteUnlock: (() => { try { return !!hasSecondary() } catch (_) { return false } })()
-        }))
-      }
-    },
-    /**
-     * PARA QUIÉN ENVOLVER. Lo contesta la bóveda porque la lista sale del ACTA
-     * (`recipientsOf`), y tener dos sitios respondiendo a «quién puede abrir este cajón» es
-     * exactamente cómo se acaba dejando fuera a alguien sin que nadie se entere.
-     */
-    async recipients ({ ns, pub, public: isPublic }) {
-      // LA VISIBILIDAD CAMBIA LA LISTA: una pública se envuelve además para quien
-      // administra, así que hay que decirlo al preguntar. Pedirla sin decirlo y luego
-      // guardarla como pública produciría un sobre que la consola no puede abrir — y la
-      // bóveda lo rechazaría, que es lo correcto pero desorienta.
-      return secrets.recipientsFor(ns ? `ns:${ns}` : `dev:${pub}`, { public: !!isPublic })
-    },
-    /**
-     * GUARDAR UNA VARIABLE **SIN VERLA** (dueño, 2026-09-01).
-     *
-     * «La bóveda cerrada no puede ver el valor; debe confiar en la firma del admin y en el
-     * contenido de esos sobres, y es la razón por la que al abrir la bóveda rehace los
-     * sobres: por si alguno tiene alguna incoherencia.»
-     *
-     * Antes esto abría el sobre para sacar el valor en claro y volvía a cerrarlo. Ese
-     * rodeo era el ÚNICO motivo por el que la llave de cifrado del perfil tenía que estar
-     * accesible con la bóveda cerrada — o sea, la razón por la que una copia del disco
-     * abría todo lo dirigido al perfil.
-     *
-     * Ahora llega hecho: el valor cifrado con una CEK nueva y esa CEK envuelta para cada
-     * destinatario. Aquí se comprueba lo que se puede comprobar SIN la llave: que las
-     * envolturas cubren exactamente a quien dice el acta. Lo que no se puede comprobar
-     * —que dentro haya lo que dice— lo corrige el repaso al abrir la bóveda.
-     *
-     * Una PÚBLICA sigue viajando en claro y por el camino de siempre: marcarla pública es
-     * precisamente decir que no hay nada que ocultar.
-     */
-    async set ({ ns, pub, key, sealed, caller = null, public: isPublic, by: who = null }) {
-      const owner = ns ? `ns:${ns}` : `dev:${pub}`
-      if (sealed) {
-        // PÚBLICA Y PRIVADA VAN IGUAL (dueño, 2026-09-02: «la única diferencia es si se
-        // despachan o no, son políticas; dales el mismo tratamiento de seguridad»). La
-        // marca solo decide si se entrega sin aprobación.
-        // Si esto va a pedir aprobación, al aprobarse puede EDITAR; si no, solo añadir.
-        const ask = needsApproval(caller, await refreshActa())
-        const apply = async () => {
-          await checkAuthor(owner, key, sealed, caller, { allowOverwrite: ask })
-          await checkRecipients(owner, sealed.wraps, !!isPublic)
-          await secrets.putSealed(owner, key, sealed, { by: who, public: isPublic })
-          audit('secret.set', { ns: ns || null, key, sealed: true }); scheduleNotice(ns)
-          await settleDebts(owner)
-        }
-        // Comprobado ANTES de dejarlo en espera: un sobre malo falla al guardarlo, no cinco
-        // minutos después en la pantalla de quien aprueba. `apply` lo repite al aprobar.
-        await checkAuthor(owner, key, sealed, caller, { allowOverwrite: ask })
-        await checkRecipients(owner, sealed.wraps, !!isPublic)
-        const pending = await holdWrite({ caller, ns, pub, keys: [key], apply, ask })
-        if (pending) return { ok: true, key, pending }
-        await apply()
-        return { ok: true, key }
-      }
-      // NO HAY OTRO CAMINO (dueño, 2026-09-02: «no dejes caminos viejos ni fallbacks; no hay
-      // que hacer retrocompatibilidad y es una regla del estado actual del proyecto, por eso
-      // quedan luego backdoors»).
-      //
-      // Aquí estaba el `enc`: la consola sellaba el valor AL PERFIL y la bóveda lo ABRÍA
-      // para volver a cerrarlo. Ese descifrado era el único motivo por el que la llave de
-      // cifrado del perfil tenía que estar accesible con la bóveda cerrada — o sea, la
-      // razón por la que una copia del disco abría todo lo dirigido al perfil. Dejarlo
-      // «por si acaso» habría dejado el agujero entero abierto con otro nombre.
-      throw Object.assign(
-        new Error('var.set: the value must come already sealed (`sealed`); the old `enc` path is gone — build it with buildSealedVar()'),
-        { code: 'needs-sealed' })
-    },
-    /**
-     * VARIAS DE UNA VEZ, y por eso existe: cada guardado suelto hace que la bóveda avise
-     * al servicio de que su configuración cambió, y el servicio SALE para releerla entera
-     * (`watchEnv`). Guardadas de una en una, quien administra a distancia reiniciaba el
-     * servicio una vez por variable, y las primeras veces arrancaba con la configuración a
-     * medio poner. Juntas: un guardado, un aviso, un reinicio.
-     *
-     * 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, items, caller = null, by: who = null, fromService = false }) {
-      // CADA VARIABLE VIENE EN SU PROPIO SOBRE, ya hecho. La bóveda no abre ninguno: solo
-      // comprueba quién los firma y a quién envuelven, igual que en `set`. Aquí estaba el
-      // `enc` que las traía todas juntas selladas AL PERFIL, y abrirlo era lo que obligaba
-      // a tener la llave de cifrado accesible con la bóveda cerrada.
-      if (!Array.isArray(items) || !items.length) throw new Error('var.setMany: no variables came')
-      const owner = ns ? `ns:${ns}` : `dev:${pub}`
-      const keys = []
-      // ¿SE PIDE APROBACIÓN? Desde la mesa del admin, lo de siempre (`needsApproval`: quien
-      // tiene `unattended` escribe solo). Desde el propio SERVICIO que guarda en su cajón, la
-      // aprobación es SOLO PARA EDITAR (dueño, 2026-10-12: «la aprobación solamente es para
-      // editar una env; para almacenarla es directo»): una variable nueva no le quita nada a
-      // nadie y se guarda en el acto; reemplazar una que ya existe pide el sí de quien
-      // aprueba, tenga o no `unattended` el servicio (dueño, 2026-09-29: «el unattended
-      // también pediría aprobación»). Una tanda con alguna que ya existe se pide ENTERA: va
-      // todo o nada. Sin nadie que apruebe no se pide —la regla de siempre— y lo que ya
-      // existe falla con `exists`.
-      const record = await refreshActa()
-      const ask = fromService
-        ? hasApprover(record) && items.some((it) => it?.key && secrets.has(owner, it.key))
-        : needsApproval(caller, record)
-      for (const it of items) {
-        if (!it?.key || !it?.sealed) throw new Error('var.setMany: each variable needs its key and its sealed envelope')
-        await checkAuthor(owner, it.key, it.sealed, caller, { allowOverwrite: ask })
-        await checkRecipients(owner, it.sealed.wraps, !!it.public)
-      }
-      // Se comprueban TODAS antes de escribir NINGUNA: media carga aplicada es una
-      // configuración que nadie quiso, y el servicio se reinicia con ella.
-      const apply = async () => {
-        for (const it of items) {
-          await checkAuthor(owner, it.key, it.sealed, caller, { allowOverwrite: ask })
-          await checkRecipients(owner, it.sealed.wraps, !!it.public)
-        }
-        for (const it of items) {
-          await secrets.putSealed(owner, it.key, it.sealed, { by: who, public: !!it.public })
-          keys.push(it.key)
-        }
-        audit('secret.setMany', { ns: ns || null, keys }); scheduleNotice(ns)
-        await settleDebts(owner)
-      }
-      const pending = await holdWrite({ caller, ns, pub, keys: items.map((it) => it.key), apply, ask })
-      if (pending) return { ok: true, keys: [], pending }
-      await apply()
-      return { ok: true, keys }
-    }
-  }
-
-  /**
-   * GUARDAR VARIABLES TAMBIÉN PIDE PERMISO (dueño, 2026-09-23: «si el admin no es
-   * unattended, sí debería pedir permiso para almacenar variables»).
-   *
-   * Es el mismo permiso que ya decide si un aparato se lleva las claves solo: quien tiene
-   * `unattended` escribe sin preguntar; quien no, deja la escritura en espera y el teléfono
-   * decide. Un permiso, una regla, para leer y para escribir.
-   *
-   * No se espera DENTRO de la llamada: la consola corta a los 20 s y aprobar puede tardar
-   * cinco minutos. Se contesta «pendiente» en el acto, el sobre se queda en memoria (va
-   * sellado, la bóveda no lo abre) y se escribe al aprobar. Denegado o vencido, se tira.
-   *
-   * Devuelve el id del pedido si la escritura quedó en espera, o `null` si se puede hacer ya.
-   */
-  async function holdWrite ({ caller, ns, pub, keys, apply, ask }) {
-    if (!(ask ?? needsApproval(caller, await refreshActa()))) return null
-    // Quien llama ya comprobó el sobre; `apply` lo vuelve a comprobar al aprobar, porque el
-    // acta pudo cambiar en medio.
-    const target = ns || await deviceIdOf(pub).catch(() => null) || '?'
-    const pend = await awaitApproval({
-      device: caller, ns: target, kind: 'write', what: 'vars',
-      // LOS NOMBRES van en el contexto, que viaja SELLADO al que aprueba: el proxio no
-      // tiene por qué aprender cómo se llama la configuración de un servicio.
-      ctx: { keys },
-      onAnswer: async (ok) => {
-        if (!ok) return
-        await apply()
-        await notifyMembers('vars', { by: await deviceIdOf(caller).catch(() => null), keys, ns: ns || null })
-      }
-    })
-    return pend.id
-  }
-
-  /**
-   * BLOQUEAR O DESBLOQUEAR A MANO, desde la bóveda (CLI/TUI) o desde la consola de
-   * administración. El camino normal para bloquear es el aprobador (`handleApproval`,
-   * `block`); desbloquear solo pasa por aquí, que es lo que pidió el dueño.
-   */
-  async function setBlocked (pub, on, { by = 'vault' } = {}) {
-    const deviceId = await deviceIdOf(pub).catch(() => null)
-    if (on) {
-      const record = await refreshActa()
-      const label = (record?.members || []).find((m) => m.pub === pub)?.label || ''
-      const b = blocked.block({ pub, deviceId, label, by, reason: 'manual' })
-      grants.revokeAll({ device: pub })
-      audit('blocked', { device: deviceId, by, kind: 'manual' })
-      log(`[vault] BLOCKED ${deviceId} by ${by}`)
-      await notifyMembers('blocked', { deviceId, by })
-      return b
-    }
-    const was = blocked.unblock(pub)
-    if (was) {
-      audit('unblocked', { device: deviceId, by })
-      log(`[vault] unblocked ${deviceId} by ${by}`)
-      await notifyMembers('unblocked', { deviceId, by })
-    }
-    return was
-  }
-
-  const admin = createAdminDesk({
-    desk,
-    deviceIdOf,
-    audit,
-    blocked: { list: () => blocked.list(), set: setBlocked },
-    // Abrir a distancia. Va inyectado porque `admin.js` es puro y esto necesita cripto y
-    // disco; `null` si este perfil no lo soporta, y entonces la operación contesta que no.
-    unlockDesk,
-    // El MISMO candado que frena firmar y editar el perfil: revocar reescribe el acta y
-    // configurar toca los secretos, y ninguna de las dos se hace con la bóveda cerrada.
-    isLocked,
-    notify: notifyMembers,
-    readActivity,
-    vars: varsDesk,
-    // CERT ∩ ACTA, igual que los secretos con su CN. El cert dice qué se emitió; el acta,
-    // qué decidió el dueño AHORA. Sin el segundo, `caps <ID> -administra` no surtía efecto
-    // hasta que el cert caducara: quitarle la administración a un aparato que ya no es de
-    // fiar exigía revocarlo entero. Con el cruce, deja de administrar en el acto.
-    verify: async ({ data, signature, cert }) => {
-      const chk = await verifyChain({
-        data, signature, cert,
-        expectedScope: SCOPE.ADMIN, ...(await contextoActa()), revoked: await revocationSet()
-      })
-      // Quitarse a UNO MISMO desde la consola remota entra por aquí: la segunda petición
-      // que mande el aparato ya llega con el certificado retirado. Que se entere con el
-      // aviso firmado, en vez de con un error suelto que no puede borrar nada.
-      if (!chk.ok) {
-        await notifyIfRevoked(data?.publickey, cert?.nonce || null, cert?.iss || null, chk.reason)
-        return chk
-      }
-      const record = (await identity.profileActa?.().catch(() => null))?.acta
-      if (!record || !Acta.memberCan(record, chk.device, 'admin')) return { ok: false, reason: record ? 'acta' : 'sin-acta' }
-      return chk
-    }
-  })
-
-  /**
-   * RENUNCIA: un miembro se quita capacidades a sí mismo y la bóveda la SELLA en el acta.
-   *
-   * NO se pide certificado, y es a propósito: el registro va firmado por el propio miembro
-   * y solo puede QUITAR, así que honrarlo no puede hacer daño — y exigir un cert válido
-   * dejaría fuera justo el caso que la justifica (un aparato que ya no es de fiar, o cuyo
-   * cert caducó). Sin esto la renuncia se quedaba en el dispositivo: la bóveda seguía
-   * teniendo escrito que podía firmar y le seguía aceptando peticiones.
-   */
-  async function handleRenounce (from, p) {
-    const record = p?.data?.record || p?.record
-    if (!record || typeof record !== 'object') return reply(from, { type: MSG.ERROR, error: 'renounce: record required' })
-    if (!(await Acta.verifyRenounce(record).catch(() => false))) {
-      audit('rejected', { what: 'renounce', reason: 'signature' })
-      return reply(from, { type: MSG.ERROR, error: 'renounce: the signature is not the member own' })
-    }
-    // UNA RENUNCIA QUE NO QUITA NADA NO SE HONRA, y esto es lo que corta el replay barato.
-    //
-    // El registro va firmado y lleva `ts`, pero nadie lo miraba: cualquiera que lo viera
-    // pasar por el proxio podía volver a mandarlo cuando quisiera. Como `absorbRenounce`
-    // SELLA UN ACTA NUEVA cada vez, repetirlo hacía subir el `seq` y empujar a todos los
-    // aparatos sin que hubiera cambiado nada — y dejaba en la bitácora una renuncia con el
-    // nombre del aparato, que es lo peor: la bitácora es la prueba, y ahí decía algo que
-    // ese aparato no hizo.
-    //
-    // Mirando lo que el acta dice HOY, un registro repetido no quita nada y se para aquí.
-    // Lo que esto NO cierra, y queda anotado: si el dueño vuelve a conceder ese permiso, el
-    // mismo registro viejo lo quita otra vez. Cerrarlo del todo pide que el acta recuerde
-    // la fecha de la última renuncia por miembro y rechace las que no sean posteriores.
-    const actual = (await identity.profileActa?.().catch(() => null))?.acta || null
-    if (!actual) {
-      audit('rejected', { what: 'renounce', reason: 'sin-acta' })
-      return reply(from, { type: MSG.ERROR, error: 'renounce: this vault has no record to apply it to' })
-    }
-    const tiene = new Set(Acta.effectiveCaps(actual, record.member) || [])
-    if (!(record.caps || []).some((c) => tiene.has(c))) {
-      audit('rejected', { what: 'renounce', reason: 'nada-que-quitar' })
-      return reply(from, { type: MSG.ERROR, error: 'renounce: that member no longer holds any of those capabilities' })
-    }
-    try {
-      // A LA SUBACTA PRIMERO, y aquí está el arreglo: desde este momento surte efecto,
-      // esté la bóveda abierta o cerrada. Antes se intentaba sellar directamente, sellar es
-      // de la maestra, y con el perfil cerrado la renuncia se perdía con un error — en el
-      // único momento en que de verdad hace falta.
-      const guardada = await subacta.add(record)
-      if (!guardada.ok && guardada.reason === 'no-aceptable') {
-        audit('rejected', { what: 'renounce', reason: 'no-aceptable' })
-        return reply(from, { type: MSG.ERROR, error: 'renounce: the entry is not one this vault accepts' })
-      }
-      const device = await deviceIdOf(record.member).catch(() => null)
-      audit('renounce', { device, caps: record.caps })
-      log(`[vault] ${device} renounced: ${(record.caps || []).join(', ')} — in effect now`)
-
-      // Y SE SELLA SI SE PUEDE. Con la bóveda abierta entra en el acta y lo respeta toda la
-      // cuenta; cerrada se queda pendiente y lo absorbe el `unlock`. Las dos ramas son
-      // correctas, así que el fallo al sellar NO es un error para quien renunció.
-      let seq = null
-      try {
-        const r = await identity.absorbRenounce(record)
-        subacta.clear([record])
-        seq = r?.seq ?? null
-      } catch (e) {
-        log(`[vault] the renounce stays pending until the vault is opened (${e.message})`)
-      }
-      await notifyMembers('renounce', { deviceId: device, caps: record.caps })
-      reply(from, { type: MSG.RENOUNCE_RESULT, ok: true, seq, pending: seq === null })
-    } catch (e) {
-      reply(from, { type: MSG.ERROR, error: 'renounce: ' + e.message })
-    }
-  }
-
-  async function handleAdmin (from, p) {
-    // La frescura se comprueba aquí (es del transporte, igual que en el resto de
-    // handlers); el resto de la regla vive en el módulo puro.
-    if (!isFresh(p.data)) return staleReply(from)
-    const r = await admin.handle(p.data, { signature: p.signature, cert: p.cert })
-    // El `code` viaja aparte del texto: el texto está en inglés y puede cambiar, el código
-    // es lo que empareja quien llama (`vault-locked` ≠ «no autorizado»).
-    // EL FRENO VIAJA CON EL RECHAZO. `tries` y `waitSec` solo los trae abrir a distancia, y
-    // sin ellos el admin reintenta contra una puerta que ya no responde y no sabe por qué —
-    // el mismo silencio que se arregló en el resto del ecosistema.
-    if (!r.ok) {
-      return reply(from, {
-        type: MSG.ERROR,
-        error: r.error,
-        ...(r.code ? { code: r.code } : {}),
-        ...(r.tries != null ? { tries: r.tries } : {}),
-        ...(r.waitSec != null ? { waitSec: r.waitSec } : {})
-      })
-    }
-    reply(from, { type: MSG.ADMIN_RESULT, op: p.data.op, result: r.result })
-  }
-
-  // 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).
-  /**
-   * 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(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,
-  // 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
-    if (!record) return []
-    // LLEVAR EL `cn` NO ES PODER LEER. El acta manda también aquí: un miembro entra en la
-    // lista si además puede leer los secretos de ese cajón (`memberCanReadSecrets`).
-    //
-    // Sin esa segunda mitad, el `cn` era la única puerta y `cn` es un texto libre: la LLAVE
-    // DE COMUNICACIÓN de la bóveda entra en el acta con `cn: 'vault'` y `caps: ['sign']`,
-    // así que un cajón llamado `vault` —nombre perfectamente válido— la contaba entre sus
-    // dueños. No llegaba a recibir sobre (no tiene `encPub`, y `recipientsFor` los filtra),
-    // pero la salvaguarda era un accidente: bastaba que alguien le apuntara una `encPub`
-    // para envolverle la llave a la llave que firma con la bóveda CERRADA. Se comprueba el
-    // permiso, que es lo que de verdad se quería preguntar.
-    return (record.members || []).filter((m) => m.cn === ns && Acta.memberCanReadSecrets(record, m.pub, 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) }
-
-  /**
-   * 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. */
-  /** Sin repetidos por llave: un aparato puede entrar por dos vías (dueño y admin). */
-  const dedup = (miembros) => {
-    const vistos = new Set()
-    return miembros.filter((m) => m && !vistos.has(m.pub) && vistos.add(m.pub))
-  }
-  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, { public: isPublic = false } = {}) {
-    const co = await cosealerMembers()
-    // UNA PÚBLICA SE ENVUELVE TAMBIÉN PARA QUIEN ADMINISTRA (dueño, 2026-09-02: «la consola
-    // debe poder leer todas las variables… debe tener todos los sobres; la diferencia es si
-    // el vault se los envía para la lectura o no» → «cambia la regla y di que se envuelven
-    // las públicas»).
-    //
-    // Puede decidirse variable a variable porque cada escritura estrena su propia CEK: el
-    // llavero guarda una generación por valor, no una por cajón.
-    //
-    // Y la PRIVADA de un cajón con dueño sigue sin envoltura para la consola, que es la
-    // regla de agosto y su motivo no ha cambiado: el token de R2 no tiene por qué poder
-    // abrirse desde un navegador. Lo que cambia es que «pública» ya sí quiere decir algo
-    // para quien administra — puede leerla— además de que se despacha sin aprobación.
-    const admins = isPublic ? await adminDevices() : []
-    // EL PERFIL SE LE ENVUELVE A QUIEN PUEDE HABLAR POR TI (`docs/datos-del-perfil.md`).
-    //
-    // Va explícito y antes que nada porque si no cae en la rama de «cajón sin dueño» y
-    // acabaría envuelto solo para quien ADMINISTRA — que no es lo que se decidió: leer y
-    // escribir tu identidad es `firma`, y no todos los que firman administran. Un teléfono
-    // normal firma y no administra, y tiene que ver tu perfil.
-    if (owner === PROFILE_OWNER) {
-      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
-      const firman = (record?.members || [])
-        .filter((m) => m.encPub && Acta.memberCan(record, m.pub, 'sign'))
-        .map((m) => ({ pub: m.pub, encPub: m.encPub }))
-      return conCoselladores(dedup(firman), co)
-    }
-    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á) entra quien administra
-      // SIEMPRE: si no, no quedaría nadie que pudiera abrirlo sin la frase.
-      const base = owned.length ? [...owned, ...admins] : await adminDevices()
-      return conCoselladores(dedup(base), 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 conCoselladores(dedup([m, ...admins]), co)
-    return conCoselladores(dedup([...(m ? [m] : []), ...await adminDevices()]), co)
-  }
-
-  /**
-   * 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 []
-    // A QUIÉN LE FALTA ALGO LO DICE `recipientsOf`, Y SOLO ÉL — la misma lista con la que
-    // se envuelve al escribir y se rehace el llavero al abrir. Aquí había otra: «un aparato
-    // sin `cn` puede destapar cualquier cajón sin dueño». Para `@me` no es cierto —el
-    // perfil se envuelve a quien puede FIRMAR por ti—, así que un aparato sin `firma` salía
-    // con todos los datos del perfil «sin llave todavía», y abrir la bóveda, que es lo que
-    // el aviso pedía, no podía apagarlo: el llavero ya estaba como decía el acta. Dos
-    // listas para la misma pregunta acaban siempre así.
-    const out = new Map()
-    for (const owner of secrets.owners()) {
-      // Por VISIBILIDAD: a quien administra se le envuelve la pública de un cajón con dueño
-      // y no la privada. La lista de las públicas contiene siempre a la de las privadas.
-      const privados = new Set((await recipientsOf(owner)).map((m) => m.pub))
-      for (const m of await recipientsOf(owner, { public: true })) {
-        if (!m.encPub || m.pub === master) continue
-        const missing = secrets.missingFor(owner, m.pub, { only: (esPublica) => esPublica || privados.has(m.pub) })
-        if (!missing.length) continue
-        const row = out.get(m.pub) || { pub: m.pub, cn: m.cn || null, owners: {} }
-        row.owners[owner] = missing
-        out.set(m.pub, row)
-      }
-    }
-    return [...out.values()]
-  }
-
-  /**
-   * 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}`)
-    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 }>}
-   */
-  /**
-   * PEDIRLE A UN HERMANO QUE ENVUELVA — Y QUE SE LO ENTREGUE A LA BÓVEDA (§8.11).
-   *
-   * Regla del dueño (2026-09-01): «un servicio reparte la llave AL VAULT para que este la
-   * reparta después, pero no se la entrega directo; si lo hace sin pasar por el vault está
-   * mal». Es lo que hace este camino, y conviene verlo en el orden de las líneas:
-   *
-   *   1. la BÓVEDA le pide el sobre al hermano (`sendByPubkey` → `REWRAP`);
-   *   2. el hermano le contesta A ELLA, nunca al recién llegado;
-   *   3. la BÓVEDA lo guarda (`putWrap`) y a partir de ahí lo sirve ella.
-   *
-   * El destinatario no habla con nadie, y la bóveda nunca ve la llave en claro: el sobre
-   * llega ya cerrado a la pública del destinatario. Por eso esto funciona con el perfil
-   * cerrado, que es justo cuando hace falta.
-   */
-  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) {
-      // La llave de sellado firma (el servicio lo comprueba con `verifyResponder`): esto
-      // tiene que funcionar con la bóveda cerrada, y la maestra entonces no firma.
-      const body = { op: 'rewrap', owner, gen: gen.gen, wrap: gen.mine, target: targetPub, acta: record, ts: Date.now() }
-      const seal = await sealOrFail(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, seal }) } 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 }
-  }
-
-  /**
-   * REHACER EL LLAVERO ENTERO. Se llama al ABRIR la bóveda, que es el único momento en que
-   * se puede: envolver exige la llave del cajón, y esa solo se abre con la frase.
-   *
-   * Lo que falle aquí SALE en `failed`, y quien llame tiene que decirlo. Callarlo fue el
-   * fallo: un cajón que no se pudo reenvolver deja a sus aparatos sin poder leer nada, y
-   * desde fuera la bóveda parecía abierta y sana — «desbloqueado» a secas—. Se descubría
-   * días después, por un servicio que pedía sus claves una y otra vez.
-   */
-  /**
-   * QUE LOS SOBRES EXISTAN PARA TODOS, SIEMPRE — TAMBIÉN AL SELLAR EL ACTA.
-   *
-   * Regla del dueño (2026-09-01): «cuando se abre el vault, y siempre, debe asegurarse de
-   * que todos los sobres para todos los dispositivos existan, antes y después de sellar un
-   * acta; es la tarea de la llave maestra, no tiene otra».
-   *
-   * Y es literalmente su otro trabajo: la maestra firma el acta y regenera los sobres. Todo
-   * cambio del acta cambia QUIÉN debe tener envoltura de qué —entra un aparato, se le da
-   * `secrets`, se le quita, aparece un sellador nuevo—, así que sellar sin repasar los
-   * sobres deja el llavero diciendo una cosa y el acta otra. Eso fue justo el agujero: un
-   * servicio en el acta, con su permiso, y sin poder abrir nada.
-   *
-   * Con la bóveda ABIERTA se rehace de verdad. Cerrada no se puede —envolver exige la llave
-   * del cajón— y entonces queda como DEUDA anotada, que es lo que salda el `unlock`. Lo que
-   * no se hace es callarlo.
-   */
-  /**
-   * QUE LOS SOBRES EXISTAN PARA TODOS, CADA VEZ QUE EL ACTA CAMBIA.
-   *
-   * Regla del dueño (2026-09-01): «cuando se abre el vault, y siempre, debe asegurarse de
-   * que todos los sobres para todos los dispositivos existan, antes y después de sellar un
-   * acta; es la tarea de la llave maestra, no tiene otra». Y es literalmente su otro
-   * trabajo: firmar el acta y regenerar los sobres.
-   *
-   * SE REHACE ENTERO, no se salda lo que falta. Saldar añade lo que no está pero no MIRA lo
-   * que sobra: la envoltura de alguien a quien ya se le quitó el permiso se quedaría ahí
-   * para siempre y nadie se enteraría. `resealAll` con `exact` deja cada cajón envuelto para
-   * exactamente quien dice el acta —crea lo que falta y RETIRA lo caduco—, que es la única
-   * forma de poder afirmar que el llavero está al día. No toca la red: es reenvolver con
-   * las públicas del acta, así que esperar aquí no cuelga de ningún aparato apagado.
-   *
-   * NO HAY CAMINO PARA «LA BÓVEDA ESTÁ CERRADA» (dueño, 2026-09-01: «es un absurdo, con
-   * bóveda cerrada no puede cambiar el acta»). Sellar el acta necesita la maestra, y cerrada
-   * la maestra no está en memoria — o sea que si se llegó hasta aquí, estaba abierta. Un
-   * `if` para ese caso no sería prudencia: sería un repliegue que le pone cara de trámite
-   * normal a una contradicción. Si aun así falta la llave, se dice como lo que es.
-   */
-  /**
-   * ¿QUIÉN HIZO ESTE SOBRE? Tiene que decirlo, y tiene que ser un MIEMBRO DEL ACTA.
-   *
-   * Regla del dueño (2026-09-01): «los sobres deben traer información de quién los hizo,
-   * deberían tener la firma para que no se cuelen sobres firmados por cualquiera; solo
-   * puede haber sobres firmados por miembros del acta».
-   *
-   * La petición ya viene firmada y comprobada (`verifyChain` + el acta), así que un extraño
-   * no llega hasta aquí. Esto es otra cosa y hace falta igual: la bóveda guarda unos bytes
-   * que NO PUEDE LEER, y sin esta firma lo único que ataba esos bytes a un autor era el
-   * momento de la llamada. Con ella, el registro guardado se explica solo — se puede
-   * comprobar después, en frío, sin fiarse de ningún log.
-   *
-   * El autor tiene que ser QUIEN LLAMA. Aceptar un sobre firmado por otro sería admitir un
-   * relevo: alguien con `admin` colando un sobre que fabricó un tercero, sin que ninguna de
-   * las dos comprobaciones lo note.
-   */
-  async function checkAuthor (owner, key, sealed, caller, { allowOverwrite = false } = {}) {
-    const a = sealed?.author
-    if (!a || typeof a.pub !== 'string' || typeof a.sig !== 'string' || typeof a.ts !== 'number') {
-      throw new Error('var.set: the envelope must say WHO made it (`author: { pub, sig, ts }`)')
-    }
-    if (caller && a.pub !== caller) {
-      throw new Error('var.set: the envelope was signed by someone other than the caller — a relayed envelope is not accepted')
-    }
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    const m = (record?.members || []).find((x) => x.pub === a.pub)
-    if (!record || !m) {
-      throw new Error('var.set: the envelope is signed by a key the record does not name')
-    }
-    // UN SERVICIO SOLO PARA SU CAJÓN (dueño, 2026-09-01: «un cn no puede poner un sobre
-    // faltante fuera de su cn»). Es la misma regla que ya aplica el reparto delegado
-    // (`handleRewrapOk`), y tiene que valer también aquí: si no, un servicio con `admin`
-    // podría escribir en el cajón de otro. Quien administra sin `cn` sí puede: ese es su
-    // trabajo, y para eso se le concede a mano.
-    const ns = owner.startsWith('ns:') ? owner.slice(3) : null
-    if (m.cn && ns && m.cn !== ns) {
-      throw new Error(`var.set: "${m.cn}" cannot write into "${owner}" — a service only authors envelopes for its own drawer`)
-    }
-    // Y UN SERVICIO NO PISA LO QUE YA HAY (dueño, 2026-09-01: «un cn no puede sobrescribir
-    // un sobre existente; solamente el admin y el vault editan sobres, los otros pueden
-    // crear los que faltan nomás»).
-    //
-    // SALVO QUE ALGUIEN LO APRUEBE (dueño, 2026-09-29: «si requiere aprobación hagamos que
-    // pueda también editar; si no hay approval, solamente agregar — la aprobación nos da el
-    // nivel de seguridad aceptable»). Un sí de quien aprueba es justo la decisión humana que
-    // faltaba para reemplazar; sin él, sigue siendo solo rellenar.
-    //
-    // Es la misma regla que `putWrap` («solo añade, nunca pisa») y por el mismo motivo: un
-    // servicio que pudiera reemplazar un sobre podría dejar sin leer a otro miembro con uno
-    // basura — denegación de servicio disfrazada de escritura. Rellenar lo que falta no
-    // quita nada a nadie; reemplazar sí, y eso es de quien administra.
-    if (m.cn && !allowOverwrite && secrets.has?.(owner, key)) {
-      throw Object.assign(new Error(`var.set: "${m.cn}" cannot overwrite "${key}" — without an approval a service only fills in what is missing; replacing is for who administers`), { code: 'exists' })
-    }
-    const cuerpo = authorBody(owner, key, sealed.e, a.ts)
-    if (!(await verifyDeviceSig({ publickey: a.pub, data: cuerpo, signature: a.sig }))) {
-      throw new Error('var.set: the author signature does not verify over this envelope')
-    }
-  }
-
-  /**
-   * ¿ESTE SOBRE ENVUELVE A QUIEN TOCA? Lo único que se puede comprobar sin la llave.
-   *
-   * No se puede saber si dentro de cada envoltura está la CEK correcta —para eso habría que
-   * abrirla, que es justo lo que ya no se hace—, pero sí QUIÉN puede abrirlas. Y eso ya
-   * ataja lo que importa: que no falte nadie (un servicio que arrancaría sin configuración)
-   * y que no sobre nadie (alguien a quien el acta no nombra leyendo el cajón).
-   *
-   * Lo de dentro lo corrige el repaso al abrir la bóveda, que es para lo que está.
-   */
-  async function checkRecipients (owner, wraps, isPublic = false) {
-    if (!wraps || typeof wraps !== 'object') throw new Error('var.set: the envelope carries no wraps')
-    const { recoveryPub, members } = await secrets.recipientsFor(owner, { public: isPublic })
-    if (!recoveryPub) throw new Error('var.set: this vault has no recovery key yet')
-    const deben = new Set(members.map((m) => m.pub))
-    const traidos = new Set(Object.keys(wraps).filter((k) => k !== RECOVERY_WRAP))
-    const faltan = [...deben].filter((p) => !traidos.has(p))
-    const sobran = [...traidos].filter((p) => !deben.has(p))
-    if (faltan.length) {
-      throw new Error(`var.set: the envelope leaves ${faltan.length} member(s) of "${owner}" out — they could not read it (ask the vault for the recipients with \`var.recipients\`)`)
-    }
-    if (sobran.length) {
-      throw new Error(`var.set: the envelope wraps for ${sobran.length} key(s) the record does not name for "${owner}"`)
-    }
-  }
-
-  async function refreshWraps (motivo) {
-    // HAY CANDADO SOLO SI HAY LAS DOS COSAS: contraseña Y alguien que sepa abrirla.
-    //
-    // `startVault` sin gestor de perfiles trae `hasPassword = () => true` y `openKey =
-    // null`, que leído a la letra dice «tiene contraseña pero no hay con qué abrirla» — el
-    // estado imposible. Mirando solo `hasPassword` se daba por cerrada una bóveda que abre
-    // con la llave de la máquina, y el repaso del llavero se saltaba ENTERO: el servicio se
-    // quedaba sin su envoltura y contestábamos un paquete que no podía abrir. Es el mismo
-    // fallo que se está arreglando, colado por la puerta de al lado.
-    const conCandado = typeof openKey === 'function' && (() => { try { return !!hasPassword() } catch (_) { return true } })()
-    const k = conCandado ? openKey() : null
-    if (conCandado && !k) {
-      log(`[vault] ${motivo}: the record changed but the profile key is not here — the record cannot be sealed while locked, so this should not happen; the keyring was NOT rebuilt`)
-      return null
-    }
-    const r = await resealAll(k).catch((e) => { log(`[vault] ${motivo}: could not rebuild the keyring: ${e.message}`); return null })
-    if (r?.wrapped) log(`[vault] ${motivo}: keyring rebuilt (${r.wrapped} wrap(s) in ${r.drawers} drawer(s))`)
-    // LOS SOBRES CADUCOS SE DICEN. Son envolturas de quien ya no debería poder abrir ese
-    // cajón: retirarlas en silencio esconde que alguien las tuvo de más.
-    if (r?.dropped) log(`[vault] ${motivo}: ${r.dropped} stale wrap(s) dropped (they belonged to members the record no longer names)`)
-    if (r?.failed?.length) log(`[vault] ${motivo}: ${r.failed.length} drawer(s) could NOT be resealed: ${r.failed.map((f) => f.owner).join(', ')}`)
-    return r
-  }
-
-  /**
-   * MIGRACIÓN, CON FECHA: la copia de recuperación pudo quedar sellada con la llave de la
-   * MÁQUINA aunque el perfil tenga contraseña.
-   *
-   * Pasa por un camino perfectamente normal: escribir una variable NO pide la frase (§8.1),
-   * así que si el cajón se estrenó con el perfil cerrado, `ensureRecovery` la selló con lo
-   * único que había — la llave de la máquina. A partir de ahí, abrir el perfil y reenvolver
-   * pasa la llave de la CONTRASEÑA, que no abre ese sobre: «wrong password», el llavero no
-   * se rehace, y los servicios se quedan sin poder leer sus cajones para siempre. Es
-   * exactamente lo que le pasó a un perfil real el 2026-09-01.
-   *
-   * Aquí se abre con la de la máquina y se vuelve a cerrar con la de la contraseña, que es
-   * el `rekey` que aquel `password-set` no llegó a hacer. NO es un repliegue: no decide un
-   * permiso, no deja pasar a nadie, y **se acaba** — al primer desbloqueo el sobre queda
-   * bajo la frase y esta rama no vuelve a entrar. Y va en el sentido estricto: el material
-   * de la llave de máquina vive en este mismo disco, así que pasar a la contraseña PROTEGE
-   * más de lo que había, no menos.
-   *
-   * Se puede quitar cuando no queden perfiles de antes de 0.81.0 (2027-03-01).
-   */
-  const MIGRACION_RECUPERACION_HASTA = Date.parse('2027-03-01T00:00:00Z')
-  async function migrarRecuperacionALaFrase (adminKey) {
-    if (!adminKey || Date.now() > MIGRACION_RECUPERACION_HASTA) return false
-    try {
-      // Si la frase ya la abre, no hay nada que migrar.
-      await secrets.recoveryOpensWith(adminKey)
-      return false
-    } catch (_) {}
-    try {
-      // LA LLAVE DE LA MÁQUINA, EXPLÍCITA. `null` NO vale aquí: `defaultKey()` mira primero
-      // `openKey()`, y con el perfil ABIERTO eso es la llave de la contraseña — o sea que
-      // pasar `null` probaba la misma llave dos veces y la migración no migraba nada. Lo
-      // dijo el propio diagnóstico: «no abre ni con la contraseña ni con la de la máquina»,
-      // cuando la de la máquina no se había llegado a probar.
-      const maquina = new Uint8Array(kekFor(dir))
-      await secrets.recoveryOpensWith(maquina)                // si esta tampoco, no hay migración que hacer
-      const r = await secrets.rekeyRecovery(maquina, adminKey)
-      if (!r?.rekeyed) return false
-      log('[vault] the recovery copy was sealed with this machine\'s key: re-sealed under the profile password')
-      audit('secret.recovery-rekeyed', {})
-      return true
-    } catch (e) {
-      log(`[vault] the recovery copy does not open with the password nor with this machine's key (${e.message}): the drawers cannot be re-wrapped`)
-      return false
-    }
-  }
-
-  /**
-   * LAS CONTRASEÑAS, AL FORMATO SELLADO (§2.7) Y CON SUS ENVOLTURAS AL DÍA (§2.5).
-   *
-   * Las dos cosas se hacen aquí, al ABRIR el perfil, porque las dos necesitan lo mismo: la
-   * frase. Convertir hay que hacerlo una vez; repasar las envolturas, cada vez que cambie
-   * quién puede leer — y este es el único momento en que hay con qué.
-   *
-   * La bóveda ve los valores SOLO mientras convierte, que es cuando tiene que reescribirlos.
-   * Después no puede: lo último que hace la conversión es borrar la llave vieja.
-   */
-  async function sealPasswords (adminKey = null) {
-    if (!passwords) return null
-    const recipients = {
-      recoveryPub: secrets.recoveryPub(),
-      main: passwordRecipients('main'),
-      passkeys: passwordRecipients('passkeys')
-    }
-    if (!recipients.recoveryPub) {
-      log('[vault] passwords: no recovery key yet — nothing can be sealed until there is one')
-      return null
-    }
-    const out = {}
-    try {
-      const { convertPasswords } = await import('./passwords.js')
-      const r = await convertPasswords({
-        store: passwordsStore,
-        sealed: passwords.sealed,
-        cek: await llaveViejaDeContrasenas(),
-        recipients,
-        // LA MAESTRA FIRMA LO QUE ESCRIBE, como cualquier aparato que guarda una entrada.
-        // Firmar no es leer: lo que se le envuelve a esta bóveda sigue siendo nada.
-        author: { publickey: master, sign: (body) => identity.signData(body) },
-        dropOldKey: soltarLlaveVieja,
-        log
-      })
-      out.converted = r?.entries || 0
-      if (r?.already) out.converted = 0
-    } catch (e) {
-      log(`[vault] passwords: could not convert to the sealed format (${e.message})`)
-      out.convertError = e.message
-    }
-    try {
-      const r = await passwords.sealed.rewrapAll({
-        openRecovery: (wrap) => secrets.openRecoveryWrap(wrap, adminKey)
-      })
-      out.wrapped = r.wrapped
-      out.dropped = r.dropped
-      if (r.wrapped || r.dropped) {
-        log(`[vault] passwords: keyring rebuilt (${r.wrapped} wrap(s), ${r.dropped} stale one(s) dropped)`)
-      }
-      if (r.failed?.length) log(`[vault] passwords: ${r.failed.length} generation(s) could NOT be rewrapped`)
-    } catch (e) {
-      log(`[vault] passwords: could not rebuild the keyring (${e.message})`)
-      out.rewrapError = e.message
-    }
-    return out
-  }
-
-  async function resealAll (adminKey = null) {
-    // ANTES de reenvolver nada: si la copia de recuperación se quedó bajo la llave de la
-    // máquina, se pasa a la frase. Sin esto, todo lo de abajo falla con «wrong password».
-    if (adminKey) await migrarRecuperacionALaFrase(adminKey)
-    // Y LA LLAVE DE RECUPERACIÓN EXISTE. Nacía al escribir el primer secreto, así que una
-    // bóveda recién creada no tenía a quién envolver — y como crearla necesita la maestra,
-    // cerrada ya no había manera. El síntoma: escribir el perfil con la bóveda cerrada
-    // fallaba con «the vault did not say who to seal the profile for», en un perfil nuevo
-    // y solo en el primero. Abrir la bóveda es el momento de saldarlo, y es idempotente.
-    // …salvo en un almacén v3, que no tiene ese concepto: ahí lo que toca es `migrate`, y
-    // escribir o leer un sobre ya se rechaza diciéndolo. Crearla antes de migrar sería
-    // dejar una llave suelta en un formato que va a reescribirse entero.
-    if (!secrets.isLegacy()) await secrets.ensureRecovery(adminKey)
-    const out = { drawers: 0, wrapped: 0, sealed: 0, dropped: 0, sinLlave: [], failed: [] }
-    for (const owner of secrets.owners?.() || []) {
-      const before = new Set(secrets.recipientsIn(owner))
-      // POR VISIBILIDAD, no una lista fija: una pública lleva además la envoltura de quien
-      // administra. Con una sola lista se le daría también la de una privada con dueño, que
-      // es justo lo que no puede pasar.
-      const members = (esPublica) => recipientsOf(owner, { public: esPublica })
-      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.sealed += r?.sealed || 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})`)
-        out.failed.push({ owner, error: e.message })
-      }
-    }
-    if (out.dropped || out.sealed) audit('secret.reseal', { drawers: out.drawers, dropped: out.dropped, sealed: out.sealed })
-    if (out.failed.length) audit('secret.reseal-failed', { drawers: out.failed.map((f) => f.owner) })
-    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 = (esPublica) => recipientsOf(owner, { public: esPublica })
-      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) {
-    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
-    // QUIÉN RECIBE ENVOLTURA LO DICE `recipientsOf`, Y SOLO ÉL.
-    //
-    // Antes cada llamador traía su propia lista (`nsMembers`, o el miembro suelto), y todas
-    // se dejaban fuera a los SELLADORES — que `recipientsOf` sí incluye. Resultado: escribir
-    // una variable envolvía para el servicio y dejaba al sellador con la generación vieja
-    // (dueño, 2026-09-01: «al envolver hay que envolver siempre para todos los selladores,
-    // para que siempre tengan la info fresca»). Dos listas para la misma pregunta acaban
-    // siempre así: una se actualiza y la otra no.
-    try { return await spreadKey(owner, (esPublica) => recipientsOf(owner, { public: esPublica }), 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 }
-
-  /**
-   * RENOMBRAR una variable. Para el servicio que la lee es un cambio de configuración como
-   * cualquier otro —la de antes desaparece y aparece otra—, así que se avisa igual: si no,
-   * seguiría arrancando con el nombre viejo hasta el siguiente reinicio.
-   */
-  async function renameSecret (ns, from, to) {
-    const r = await secrets.rename(`ns:${ns}`, from, to)
-    if (r?.renamed) { audit('secret.rename', { ns, from, to }); scheduleNotice(ns) }
-    return r
-  }
-  async function renameDeviceSecret (pub, from, to) {
-    const r = await secrets.rename(`dev:${pub}`, from, to)
-    if (r?.renamed) {
-      audit('secret.rename', { device: await deviceIdOf(pub).catch(() => null), from, to, scope: 'device' })
-      scheduleDeviceNotice(pub)
-    }
-    return r
-  }
-
-  /**
-   * CARGAR CONFIGURACIÓN ES UNA TRANSACCIÓN: muchas variables, UN aviso.
-   *
-   * De una en una, cada `set` es un cambio de configuración para la bóveda, y el agente
-   * obedece el primero —sale, lo levanta el supervisor, lee lo que hubiera en ese
-   * instante— mientras el dueño sigue tecleando. El resultado es un servicio corriendo
-   * con media configuración, y encima con el arranque a medio hacer. La ventana de
-   * agrupado (`NOTICE_GROUP_MS`) tapa el caso de un script, no el de una persona
-   * escribiendo con quince segundos entre variable y variable.
-   *
-   * Así que la carga en grupo llega hasta aquí entera: se valida TODO primero, se
-   * escribe en un solo guardado y sale UN aviso al final. Las visibilidades no entran:
-   * no cambian lo que el servicio lee y por eso nunca avisaron.
-   *
-   * @param {string} ns
-   * @param {Array<{op:'set'|'rm', key:string, value?:string, public?:boolean}>} items
-   * @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).
-   */
-  async function applySecrets (ns, items, { by = null } = {}) {
-    const list = assertItems(items)
-    const changed = []
-    await secrets.batch(async () => {
-      for (const it of list) {
-        if (it.op === 'rm') {
-          if (await secrets.delete(ns, it.key)) { audit('secret.rm', { ns, key: it.key }); changed.push(it.key) }
-        } else {
-          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) {
-      await settleDebts(`ns:${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, { by = null } = {}) {
-    const list = assertItems(items)
-    const m = await requireService(pub)
-    const changed = []
-    await secrets.batch(async () => {
-      for (const it of list) {
-        if (it.op === 'rm') {
-          if (await secrets.deleteDevice(pub, it.key)) changed.push(it.key)
-        } else {
-          await secrets.setDevice(pub, it.key, it.value, it.public, { by })
-          changed.push(it.key)
-        }
-      }
-    })
-    if (changed.length) {
-      await settleDebts(`dev:${pub}`)
-      const device = await deviceIdOf(pub).catch(() => null)
-      for (const it of list) {
-        if (!changed.includes(it.key)) continue
-        audit(it.op === 'rm' ? 'secret.rm' : 'secret.set', { device, ns: m?.cn || null, key: it.key, scope: 'device' })
-      }
-      scheduleDeviceNotice(pub)
-    }
-    return changed
-  }
-
-  /**
-   * Todo o nada: si una variable del grupo no vale, no se escribe NINGUNA. Media
-   * configuración cargada es peor que ninguna — el servicio arranca con ella.
-   */
-  function assertItems (items) {
-    if (!Array.isArray(items) || !items.length) throw new Error('batch: no items')
-    for (const it of items) {
-      if (!it || (it.op !== 'set' && it.op !== 'rm')) throw new Error('batch: each item must be a set or an rm')
-      if (it.op === 'rm') { if (!it.key) throw new Error('batch: rm needs a key') } else assertVar(it.key, it.value)
-    }
-    return items
-  }
-  /**
-   * Los nombres, y el VALOR de las públicas. Pública quiere decir «este valor puede salir
-   * de esta máquina»: taparlo justo aquí —en la máquina donde vive, delante de su dueño—
-   * era lo único que la marca no significaba. La consola remota ya las enseña.
-   */
-  /**
-   * LE PONE A CADA PÚBLICA SU SOBRE Y LA ENVOLTURA DE QUIEN PREGUNTA, para que pueda leerla.
-   *
-   * Solo a las públicas: es la política de despacho, y es lo único que cambia entre una y
-   * otra. A una privada no se le manda nada — y aunque se le mandara, quien administra no
-   * tiene su envoltura en un cajón con dueño, así que no la abriría igual.
-   *
-   * Si falta la envoltura de quien pregunta (todavía no se le ha hecho, o el cajón se
-   * escribió antes de que entrara) se manda la variable SIN sobre: se ve que existe y que es
-   * pública, y no se puede leer. Eso es cierto y se arregla abriendo la bóveda; inventarse
-   * un valor o esconder la fila sería peor.
-   */
-  const withEnvelopes = (entries, kind, caller) => {
-    if (!caller) return entries
-    const attach = (owner, k) => {
-      if (!k.public) return k
-      const e = secrets.entryOf?.(owner, k.key)
-      const wrap = e?.gen != null ? secrets.wrapOf?.(owner, e.gen, caller) : null
-      return e?.e && wrap ? { ...k, e: e.e, wrap } : k
-    }
-    if (kind === 'ns') {
-      const out = {}
-      for (const [ns, keys] of Object.entries(entries)) out[ns] = keys.map((k) => attach(`ns:${ns}`, k))
-      return out
-    }
-    return entries.map((row) => ({ ...row, keys: row.keys.map((k) => attach(`dev:${row.pub}`, k)) }))
-  }
-
-  function listSecrets () {
-    // YA NO SE ENSEÑA EL VALOR DE UNA PÚBLICA (dueño, 2026-09-02). Desde que todas van en
-    // sobre, «pública» dejó de significar «en claro»: dice a quién se le despacha sin
-    // aprobación, nada más. Para ver un valor hay que poder abrirlo, igual que cualquiera —
-    // y en un cajón con dueño, quien administra deliberadamente no puede.
-    return secrets.list()
-  }
-  /** Cambiar SOLO quién puede ver el valor (no toca el valor ni avisa: el servicio lee lo mismo). */
-  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)
-  }
-
-  /**
-   * CAMBIA LOS PERMISOS DE UNO O VARIOS APARATOS EN UNA SOLA ACTA. `changes`: `[{ pub, caps }]`,
-   * cada `caps` la lista COMPLETA de ese aparato.
-   */
-  async function setCapsMany (changes) {
-    if (!Array.isArray(changes) || !changes.length) throw Object.assign(new Error('no changes to save'), { code: 'NO_CHANGES' })
-    if (typeof identity.setCapsMany !== 'function') {
-      throw Object.assign(new Error('this build\'s @dotrino/identity cannot change several devices at once (needs setCapsMany)'), { code: 'caps-many-unavailable' })
-    }
-    const r = await identity.setCapsMany(changes)
-    // ¿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 members = (await identity.profileMembers()).members
-      for (const { pub, caps } of changes) {
-        const quedaron = new Set(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 */ }
-    const devices = await Promise.all(changes.map(async ({ pub, caps }) => ({ deviceId: await deviceIdOf(pub).catch(() => null), caps })))
-    for (const d of devices) audit('caps', { device: d.deviceId, caps: d.caps })
-    // El acta acaba de cambiar QUIÉN debe tener envoltura de qué: se repasa antes de
-    // avisar, para que el aviso salga con el llavero ya al día.
-    await refreshWraps('caps')
-    // UN aviso: un aparato solo (la forma de siempre) o la lista, si fueron varios.
-    await notifyMembers('caps', devices.length === 1 ? devices[0] : { devices })
-    return r
-  }
-
-  /** 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
-    if (!record) return null
-    return (record.members || []).find((m) => m.pub === pub) || null
-  }
-
-  /**
-   * Variables de UN aparato. Se exige que sea un SERVICIO del acta (miembro con `cn`) porque
-   * es el único que las lee: guardárselas a un teléfono sería configuración muerta, escrita
-   * donde nadie la va a buscar el día que no funcione. Si la bóveda es anterior al acta no
-   * hay contra qué comprobarlo y se acepta.
-   */
-  async function requireService (pub) {
-    const m = await memberOf(pub)
-    if (!m) {
-      const record = (await identity.profileActa?.().catch(() => null))?.acta
-      if (record) throw new Error('device: it is not a member of this profile')
-      return null
-    }
-    if (!m.cn) throw new Error('device: it is not a service (only services read variables); pair it with `pair --service <ns>`')
-    return m
-  }
-
-  async function setDeviceSecret (pub, key, value, isPublic, { by = null } = {}) {
-    const m = await requireService(pub)
-    await secrets.setDevice(pub, key, value, isPublic, { by })
-    await settleDebts(`dev:${pub}`)
-    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 = 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)
-    }
-    return ok
-  }
-
-  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
-  }
-
-  /**
-   * Las variables por aparato —nombres, y el valor de las PÚBLICAS, igual que `listSecrets`—
-   * con quién es cada aparato pegado: una llave suelta no se puede administrar. `orphan`
-   * marca las que quedaron de una llave que ya no está en el acta.
-   */
-  async function listDeviceSecrets () {
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    const members = record?.members || []
-    const out = []
-    for (const [pub, keys] of Object.entries(secrets.listDevices())) {
-      const m = members.find((x) => x.pub === pub) || null
-      out.push({
-        pub,
-        id: m?.id || await deviceIdOf(pub).catch(() => null),
-        label: m?.label || '',
-        cn: m?.cn || null,
-        // Sin valores: desde 2026-09-02 una pública también va en sobre (ver `listSecrets`).
-        keys,
-        orphan: !!members.length && !m
-      })
-    }
-    return out
-  }
-
-  return {
-    identity, client, store, threads, secrets, master, fingerprint: fp, dir,
-    // Alcanzable ≠ corriendo: si el proxio rechazó el `identify` esta bóveda está viva y
-    // nadie puede hablarle. Lo mira `status` (ver `manager.js`, `summary`).
-    isIdentified,
-    // Se expone para poder PROBAR que una respuesta que no cabe no mata la conexión: es el
-    // único punto por el que sale todo, y el fallo que cierra vive justo ahí.
-    reply,
-    /**
-     * SOLTAR LA MAESTRA. Cerrar el perfil tiene que sacarla de la memoria, no solo dejar de
-     * cargarla en el siguiente arranque: si no, el candado seguiría siendo una bandera al
-     * lado de una llave descifrada, que es exactamente lo que se quitó de en medio.
-     *
-     * Se recarga el par: sin la llave del perfil el pilar lo deja SIN privada, así que a
-     * partir de aquí firmar se niega con `vault-locked`. Servir sigue igual — eso lo hace la
-     * llave de comunicación, que no depende de la contraseña.
-     */
-    async dropMasterKey () {
-      const r = await identity.reloadMasterKey?.()
-      return { locked: r?.locked !== false }
-    },
-    /** Al abrir: recuperar la maestra y, si venía en claro de antes, dejarla sellada. */
-    async takeMasterKey () {
-      const r = await identity.reloadMasterKey?.()
-      if (r?.locked === false) { try { await identity.sealMasterKey?.() } catch (_) {} }
-      // ABRIR ES EL ÚNICO MOMENTO en que un perfil con contraseña está abierto, así que es
-      // aquí donde puede estrenar su llave de comunicación (ver `ensureCommKeyInActa`).
-      // Si falla, no se arrastra: abrir el perfil no puede depender de esto.
-      //
-      // Y SE VUELVE A IDENTIFICAR EN EL ACTO: `identify` solo corre al conectar y al cambiar
-      // el token, así que estrenar la llave no servía de nada hasta el siguiente arranque —
-      // la bóveda seguía muda en el proxio con su llave ya admitida en el acta. Al dueño le
-      // pasó el 2026-09-05: hizo lo que el log pedía y la consola siguió sin contestar.
-      if (r?.locked === false) {
-        try { if (await ensureCommKeyInActa()) await reidentificar?.() } catch (_) {}
-      }
-      // Y ABSORBER LO PENDIENTE. La subacta ya lo estaba honrando con el perfil cerrado —de
-      // eso vive—, pero mientras siga ahí solo lo sabe esta máquina: al sellarlo, entra en
-      // el acta y lo respeta toda la cuenta. Si falla no se arrastra: abrir el perfil no
-      // puede depender de esto, y lo pendiente sigue surtiendo efecto igual.
-      if (r?.locked === false) { try { await absorberSubacta('unlock') } catch (_) {} }
-      // Y LOS APARATOS MUERTOS FUERA DEL ACTA, en una sola (dueño, 2026-09-22). Es el mismo
-      // momento: la maestra está en memoria y cambiar el acta es uno de sus dos trabajos.
-      // Si falla no se arrastra —abrir no depende de esto—, pero se dice.
-      if (r?.locked === false) {
-        try {
-          const antes = await refreshActa()
-          const aprobaban = (antes?.members || []).filter((m) => Acta.memberCan(antes, m.pub, 'approve')).map((m) => m.pub)
-          const { removed = [], seq } = await identity.pruneExpiredDevices?.() || {}
-          for (const d of removed) {
-            const id = await deviceIdOf(d.pub).catch(() => null)
-            audit('pruned', { device: id, label: d.label || '', reason: 'expired', seq })
-            log(`[vault] unlock: removed ${id || '????-????'} ${d.label ? `(${d.label}) ` : ''}from the record: its certificate expired and cannot be renewed · record #${seq}`)
-          }
-          // ¿SE LLEVÓ AL ÚLTIMO QUE APROBABA? Entonces se dice ALTO. Quitarlo es correcto —con
-          // el papel muerto no podía firmar ninguna aprobación, estuviera o no en el acta—,
-          // pero desde ese momento todo pedido de un aparato sin `unattended` se rechaza, y
-          // el 2026-09-22 eso pasó en silencio: el teléfono se fue y nadie lo supo en dos días.
-          const despues = await refreshActa()
-          const quedan = (despues?.members || []).filter((m) => Acta.memberCan(despues, m.pub, 'approve')).map((m) => m.pub)
-          const idosPub = lastApproverGone(aprobaban, quedan, removed.map((d) => d.pub))
-          const idos = removed.filter((d) => idosPub.includes(d.pub))
-          if (idos.length) {
-            const quienes = (await Promise.all(idos.map(async (d) => `${await deviceIdOf(d.pub).catch(() => '????-????')}${d.label ? ` (${d.label})` : ''}`))).join(', ')
-            audit('no-approver', { removed: idos.length, seq })
-            log(`[vault] WARNING: nobody in the record can approve any more — ${quienes} was the last. From now on every device gets its keys WITHOUT approval, until you enrol one and grant it \`dotrino-vault caps <ID> +aprueba\``)
-          }
-        } catch (e) { log(`[vault] unlock: could not remove expired devices: ${e.message}`) }
-      }
-      // Y DESPUÉS, LOS SOBRES A LA LLAVE VIGENTE: la poda de arriba pudo rotarla.
-      if (r?.locked === false) {
-        try { await resealStaleThreads('unlock') } catch (e) { log(`[vault] unlock: could not reseal old envelopes: ${e.message}`) }
-      }
-      return { locked: r?.locked !== false }
-    },
-    // Forzar un empujón: lo usa `replica push` de la CLI y el smoke, para no depender
-    // de que justo acabe de cambiar algo.
-    pushToReplicas,
-    startPairing: desk.startPairing,
-    stopPairing: desk.stopPairing,
-    listPending: desk.listPending,
-    // ¿Pide permiso este aparato para recibir claves privadas? Lo dice el ACTA
-    // (`unattended`), no una lista de esta máquina — por eso ya no hay `setApproval` ni
-    // `supervised`: se concede y se quita como cualquier otro permiso, con `caps`.
-    needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
-    /**
-     * QUIÉN PUEDE APROBAR EN ESTA CUENTA. Lo usa la actualización (§15): la bóveda pide
-     * permiso al teléfono **solo si hay a quién pedírselo**; si no hay ningún aparato con
-     * `aprueba`, se actualiza sola.
-     *
-     * Es la regla del dueño (2026-09-20) y evita la trampa evidente: una bóveda sin
-     * aprobadores que se quedaría sin poder actualizarse nunca, esperando un sí que nadie
-     * puede dar. Mismo sitio del que ya sale el «rang N approver(s)» de los secretos.
-     */
-    /**
-     * PEDIR PERMISO PARA ACTUALIZARSE a `version` (la instala el daemon si se aprueba). Es
-     * un pedido como los demás —sale en Pedidos del teléfono, `kind: 'update'`—, pero dura
-     * un día (`UPDATE_TTL_MS`): no hay nadie esperando delante de una terminal.
-     * @returns {{ answer: Promise<boolean>, withdraw: () => void }} `answer`: sí o no (vencido
-     *   o retirado es no). `withdraw` quita el pedido si sigue vivo.
-     */
-    askUpdateApproval: ({ version }) => {
-      const yo = identity.me?.publickey || null
-      let pendId = null
-      let withdrawn = false
-      let settle
-      const answer = new Promise((resolve) => { settle = resolve })
-      // RETIRAR: otro perfil ya contestó por la máquina, o ya no hace falta. El pedido sale
-      // de la lista de quien aprueba en vez de quedarse un día pidiendo algo ya decidido.
-      const retirar = () => {
-        if (!pendId || !waiters.delete(pendId)) return
-        const pend = approvals.take(pendId)
-        audit('update.withdrawn', { device: pend?.deviceId || null, ns: 'vault', id: pendId })
-        log(`[vault] update: request ${pendId} withdrawn`)
-        settle(false)
-      }
-      awaitApproval({
-        device: yo, ns: 'vault', kind: 'update', what: 'update',
-        ctx: { product: '@dotrino/vaultd', version, from: VERSION }, ttlMs: UPDATE_TTL_MS, onAnswer: settle
-      }).then((pend) => { pendId = pend.id; if (withdrawn) retirar() })
-        .catch((e) => { log(`[vault] update: could not ask for approval: ${e.message}`); settle(false) })
-      return { answer, withdraw: () => { withdrawn = true; retirar() } }
-    },
-    announceUpdate,
-    approvers: async () => {
-      const record = await refreshActa()
-      if (!record) return []
-      return (record.members || [])
-        .filter((m) => Acta.memberCan(record, m.pub, 'approve'))
-        // `notifiedAt`: cuándo dijo por última vez que le llegan los avisos (null = no lo ha
-        // dicho, o caducó). No decide si se pide: se enseña junto al pedido sin respuesta.
-        .map((m) => ({ id: m.id, label: m.label || '', pub: m.pub, notifiedAt: notifiable.since(m.pub) }))
-    },
-    // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
-    // llave. Lo que no puede es listarla un aparato.
-    passwordDevices,
-    passwordsVault: () => passwords?.vault || null,
-    // --- ENTRAR CON USUARIO Y CONTRASEÑA -------------------------------------------------
-    //
-    // El alta va en DOS pasos porque la contraseña no pasa por aquí: quien crea el aparato
-    // (la CLI, en esta máquina) hace su mitad de OPAQUE, genera las llaves del aparato y las
-    // cierra con la llave que sale de la contraseña. La bóveda solo guarda lo que no puede
-    // abrir, sella el acta y firma el certificado — y eso último sí pide el perfil abierto.
-    listLogins: () => logins.list(),
-    loginRegisterBegin: ({ user, request, replace = false }) => logins.registerBegin({ user, request, replace }),
-    // El alta es la MISMA pieza que usa la bóveda-pestaña (`registerLogin`): aquí solo se
-    // añade lo que es del binario — la bitácora y el aviso a los demás aparatos.
-    loginRegisterFinish: async (opts) => {
-      const r = await registerLogin({ ...opts, identity, logins })
-      if (r.replaced) { audit('login.passwd', { user: r.user }); return r }
-      audit('login.create', { user: r.user, device: r.deviceId, caps: r.caps })
-      await notifyMembers('enrolled', { deviceId: r.deviceId, by: 'login' })
-      return r
-    },
-    // ENTRAR DESDE ESTA MISMA MÁQUINA. Es el mismo intercambio que hace un navegador por el
-    // proxio, y pasa por el mismo freno: lo usa `logins passwd`, que necesita abrir el
-    // paquete de llaves con la contraseña vieja antes de volver a cerrarlo con la nueva.
-    loginBegin: ({ user, request }) => logins.loginBegin({ user, request }),
-    loginEnd: ({ lid, finalization, label }) => logins.loginEnd({ lid, finalization, label }),
-    closeLogin: ({ user, sid }) => {
-      const r = logins.closeSession({ user, sid })
-      if (r.ok) audit('login.close', { user, sid: String(sid).slice(0, 8), by: 'console' })
-      return r
-    },
-    clearLoginBlock: ({ user }) => logins.clearBlock({ user }),
-    removeLogin: async ({ user }) => {
-      const found = logins.list().find((x) => x.user === user)
-      if (!found) return { ok: false }
-      logins.remove({ user })
-      audit('login.remove', { user, device: found.deviceId })
-      // Quitarlo de aquí no lo saca del acta: lo suyo es revocar el aparato, y eso ya existe.
-      return { ok: true, pub: found.pub, deviceId: found.deviceId }
-    },
-    listApprovals: () => approvals.list(),
-    // El perfil desde el cajón `@me` (lo que empujan los aparatos): ver `profileView`.
-    profileView: () => secrets.profileView(),
-    // LAS CONCESIONES VIVAS, para verlas y para cortarlas. Se enseñan en la máquina del
-    // dueño (TUI/CLI), donde el contexto ya es suyo y no hay nada que sellar.
-    listGrants: () => grants.list(),
-    revokeGrant: (id) => grants.revoke(id),
-    revokeGrants: (filtro) => grants.revokeAll(filtro || {}),
-    // 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, 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) {
-        // POR `recipientsOf`, NO por `nsMembers`. Quien debe tener envoltura de un cajón lo
-        // dice UN sitio, y ahí dentro están también los SELLADORES (dueño, 2026-09-01: «al
-        // envolver hay que envolver siempre para todos los selladores, para que siempre
-        // tengan la info fresca»). Repartiendo solo a los del ns, un cajón tocado por esta
-        // puerta dejaba a los selladores con la envoltura vieja.
-        await spreadKey(`ns:${m.cn}`, (esPublica) => recipientsOf(`ns:${m.cn}`, { public: esPublica }), 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`)
-        })
-      }
-      // Y el llavero ENTERO: el recién llegado también es destinatario de su propio cajón,
-      // y si entra con `sella` lo es de TODOS. Repartir solo el suyo dejaba el resto atrás.
-      await refreshWraps('enrolled')
-      await notifyMembers('enrolled', { deviceId: r?.deviceId || null, by: 'pc' })
-      return r
-    },
-    rejectDevice: (deviceId) => desk.reject(deviceId),
-    // 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, renameSecret, renameDeviceSecret, 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,
-    /** Convierte las contraseñas al formato sellado y repasa sus envolturas (§2.5, §2.7). */
-    sealPasswords,
-    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.
-    /**
-     * Los miembros del acta, y QUÉ CORRE CADA UNO (CONVENCIONES §14). La versión no está en
-     * el acta —el acta dice quién puede qué, no qué build es— así que se le pega aquí, que
-     * es por donde salen `members` y la consola. El dueño lo pidió en los dos sitios.
-     *
-     * `running: null` es «todavía no ha hablado desde que arrancamos», que no es lo mismo
-     * que «no declara»: lo segundo trae un dictamen con `code: 'undeclared'`.
-     */
-    profileMembers: async () => {
-      const r = await identity.profileMembers()
-      return {
-        ...r,
-        vault: MI_VERSION,
-        // Y LO QUE RENUNCIÓ Y NO SE HA SELLADO. Ya surte efecto —de eso vive la subacta—
-        // pero si no se ve, el dueño mira la lista, lee los permisos del acta y cree que
-        // ese aparato los tiene. Un freno que no se explica es otro silencio.
-        members: (r?.members || []).map((m) => ({
-          ...m,
-          running: versionDe(m.pub),
-          // Dónde corre: lo último que dijo firmado y, si nunca habló, lo del acta.
-          machine: machines.of(m.pub) || m.machine || null,
-          // Cuándo dijo que le llegan los avisos (null = no lo ha dicho, o caducó). Solo
-          // tiene sentido en quien aprueba, y es un dato para enseñar: no decide nada.
-          notifiedAt: notifiable.since(m.pub),
-          renounced: subacta.forMember(m.pub).flatMap((e) => e.caps || [])
-        }))
-      }
-    },
-    // 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,
-    // LOS BLOQUEADOS, y quitarlos de la lista (`dotrino-vault block|unblock <ID>`).
-    listBlocked: () => blocked.list(),
-    setBlocked,
-    /**
-     * QUIÉN tiene envoltura de la generación vigente de un cajón (llaves de firma, más
-     * `#recovery`). Es diagnóstico: saber a cuántos se les envolvió no ayuda a abrir nada,
-     * y en cambio es lo único que contesta de verdad a «¿quién puede leer esto?».
-     *
-     * Se expone porque hacía falta para COMPROBARLO en una prueba en vez de argumentarlo:
-     * la condición del dueño para acotar los sobres por cajón y permisos —en vez de
-     * envolver para todos— fue estar seguro de que no falta ninguno.
-     */
-    secretRecipients: (owner) => secrets.recipientsIn(owner),
-    // ¿Es ESTA bóveda la que sella el acta? Lo usa el freno de borrado (D12).
-    isMaster: () => identity.isMaster(),
-    setCaps: async (pub, caps) => setCapsMany([{ pub, caps }]),
-    // VARIOS APARATOS EN UNA SOLA ACTA (dueño, 2026-09-26): el borrador de la TUI se sella
-    // de golpe, con UN repaso del llavero y UN aviso, en vez de uno por aparato.
-    setCapsMany,
-    // Renombrar un dispositivo: es un nombre para el humano (no toca permisos ni llaves),
-    // pero pasa por el acta y se avisa, para que el cambio no sea invisible en el resto.
-    setLabel: async (pub, label) => {
-      const r = await identity.setLabel(pub, label)
-      const device = await deviceIdOf(pub).catch(() => null)
-      audit('label', { device, label: r?.label ?? label })
-      await notifyMembers('label', { deviceId: device, label: r?.label ?? label })
-      return r
-    },
-    // QUITAR EL DISPOSITIVO. Se identifica por su llave (`sub`), no por un `nonce`: un
-    // aparato puede tener varios certificados y retirar uno no lo echaba de la bóveda.
-    // Se sigue aceptando `{ nonce }` para no romper una consola vieja en vuelo.
-    //
-    // Al salir alguien el acta cambia igual que al entrar, así que el llavero se repasa
-    // también aquí: lo que sobra se quita (`resealAll` lo hace) y el que se queda sigue
-    // completo. Un llavero que solo se repasa al añadir acumula envolturas de quien ya no
-    // está, que es lo contrario de lo que se quiso al expulsarlo.
-    revokeDevice: async (target) => {
-      const sub = typeof target === 'object' && target ? target.sub : null
-      if (!sub) {
-        const nonce = typeof target === 'string' ? target : target?.nonce
-        const r = await desk.revoke(nonce)
-        await notifyMembers('revoked', { certNonce: nonce, by: 'pc' })
-        return r
-      }
-      const r = await desk.revokeDevice(sub)
-      audit('revoke-device', { device: await deviceIdOf(sub).catch(() => null), certs: r?.nonces?.length ?? null })
-      await refreshWraps('revoked')
-      // Quitar un aparato rota la llave de la cuenta: lo guardado pasa a la nueva.
-      try { await resealStaleThreads('revoke') } catch (e) { log(`[vault] revoke: could not reseal old envelopes: ${e.message}`) }
-      await notifyMembers('revoked', { deviceId: await deviceIdOf(sub).catch(() => null), by: 'pc' })
-      return r
-    },
-    close () {
-      clearInterval(approvalsSweeper)
-      for (const t of pendingNotices.values()) clearTimeout(t)
-      pendingNotices.clear()
-      try { client.close() } catch (_) {} identity.destroy()
-    }
-  }
+export async function startVault ({ dir = dataDir(), ...opts } = {}) {
+  return startVaultCore({ ...opts, platform: nodePlatform(dir) })
 }
+
+export default { startVault }