@dotrino/vaultd 0.126.0 → 0.128.0

package/lib/src/admin.js

@@ -284,6 +284,12 @@ export function createAdminDesk ({
             by
           })
           const keys = result?.keys || []
+          // EN ESPERA DE APROBACIÓN: todavía no cambió nada, así que no hay de qué avisar. El
+          // aviso sale cuando se aprueba y se escribe de verdad.
+          if (result?.pending) {
+            audit('admin.var.pending', { by, ns: toScope ? data.ns : null, id: result.pending, count: data.items.length })
+            return { ok: true, result }
+          }
           audit('admin.var.set', { by, ns: toScope ? data.ns : null, device: toDevice ? await deviceIdOf(data.pub).catch(() => null) : null, keys })
           await notify('vars', { by, keys, ns: toScope ? data.ns : null })
           return { ok: true, result: result || { ok: true } }
@@ -308,6 +314,10 @@ export function createAdminDesk ({
           caller: chk.device,
           by
         })
+        if (result?.pending) {
+          audit('admin.var.pending', { by, ns: toScope ? data.ns : null, id: result.pending, count: 1 })
+          return { ok: true, result }
+        }
         audit('admin.var.set', { by, ns: toScope ? data.ns : null, device: toDevice ? await deviceIdOf(data.pub).catch(() => null) : null, key: data.key })
         // Cambiar la configuración de un servicio a distancia no puede ser invisible: es
         // la contrapartida de delegar (F3 de docs/consola-remota.md).

package/lib/src/service.js

@@ -313,7 +313,7 @@ export async function sayHello (client, qr) {
   const hello = await new Promise((resolve, reject) => {
     const off = client.on('message', (_f, p) => {
       if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
-      else if (p?.type === MSG.ERROR) { finish(); reject(new Error(p.error)) }
+      else if (p?.type === MSG.ERROR) { finish(); reject(vaultError(p)) }
     })
     const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
     const finish = () => { off(); clearTimeout(t) }
@@ -387,7 +387,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
         if (p.type === MSG.ENROLL_CHALLENGE) {
           const show = onCode || (({ deviceId, code }) => console.log(`[vault] device ${deviceId} · approve it on the vault:  dotrino-vault approve ${code}`))
           show({ deviceId, code })
-        } else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) } else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
+        } else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) } else if (p.type === MSG.ERROR) { cleanup(); reject(vaultError(p)) }
       })
       const t = setTimeout(() => { cleanup(); reject(new Error('timeout waiting for approval on the vault')) }, approveTimeoutMs)
       const cleanup = () => { off(); clearTimeout(t) }
@@ -507,7 +507,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
     const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
     const res = await pending
-    if (res.type === MSG.ERROR) throw new Error(res.error)
+    if (res.type === MSG.ERROR) throw vaultError(res)
     return { encPub, created, ok: true }
   } finally { client.close() }
 }
@@ -656,7 +656,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       try { res = await pending; break } catch (e) { ultimo = e }
     }
     if (!res) throw ultimo || new Error('nobody answered: neither the vault nor any replica')
-    if (res.type === MSG.ERROR) throw new Error(res.error)
+    if (res.type === MSG.ERROR) throw vaultError(res)
 
     // CAJÓN CON APROBACIÓN: la bóveda contesta «pendiente» (firmado) y la respuesta de
     // verdad llega cuando el aparato que aprueba firme — por esta misma conexión, que
@@ -668,7 +668,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
       res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
         .catch((e) => { throw new Error(/timeout/.test(e.message) ? 'approval: nobody approved the request in time' : e.message) })
-      if (res.type === MSG.ERROR) throw new Error(res.error)
+      if (res.type === MSG.ERROR) throw vaultError(res)
     }
 
     // AUTENTICIDAD: la firma NO es de la maestra. El acta dice qué llave vale para esto
@@ -1244,9 +1244,23 @@ function fingerprintOf (secrets) {
  */
 const FINAL_CODES = new Set([
   'no-wrapping',   // falta la envoltura, y solo la fabrica el dueño abriendo la bóveda
-  'plaintext-var'  // el valor está en claro en la bóveda: hay que volver a escribirlo
+  'plaintext-var', // el valor está en claro en la bóveda: hay que volver a escribirlo
+  // NADIE EN EL ACTA PUEDE APROBAR: reintentar no lo arregla, y callarlo es lo peor. Pasó el
+  // 2026-09-24: la limpieza de aparatos muertos se llevó al único teléfono con `aprueba`, y
+  // `dotrino-env` se quedó reintentando cada minuto sin decir nada mientras la bóveda
+  // contestaba exactamente qué había que hacer.
+  'no-approver'
 ])
 
+/**
+ * Un `vault.error` como Error CON SU `code`. Antes se construía con el texto a secas, y el
+ * código que la bóveda manda para distinguir los casos se perdía justo aquí — así que
+ * `isFinal` no podía reconocer ninguno por `code` y todo se reintentaba.
+ */
+function vaultError (p) {
+  return Object.assign(new Error(p?.error || 'vault error'), { code: p?.code || null })
+}
+
 export function isFinal (e) {
   if (FINAL_CODES.has(e?.code)) return true
   return /not enrolled|invalid ns|unauthorized: (revoked|expired|scope|cn|untrusted-issuer|cert-device-mismatch|denied)/.test(e?.message || '')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.126.0",
+  "version": "0.128.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -25,7 +25,7 @@
     "@dotrino/identity": "0.101.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
-    "@dotrino/proxy-client": "0.23.1",
+    "@dotrino/proxy-client": "0.24.0",
     "@dotrino/roadmap": "0.3.7",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.1.1",

package/src/approvals.js

@@ -73,7 +73,9 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
    * de un sobre (`handleApproval`). Si mañana aparece otro sitio que publique esta lista,
    * esto es lo que hay que recordar.
    */
-  const publicOf = (p) => ({ id: p.id, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ctx: p.ctx || null })
+  // `kind` dice QUÉ se pide: `read` (llevarse las claves, lo de siempre) o `write` (guardar
+  // variables). La pantalla del teléfono no puede decir «pide tus claves» a una escritura.
+  const publicOf = (p) => ({ id: p.id, ns: p.ns, kind: p.kind, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ctx: p.ctx || null })
 
   return {
     /** Apunta un pedido. Uno por cajón y aparato: pedir otra vez reemplaza al anterior. */
@@ -82,12 +84,15 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
      * apruebe— y tiene que volver por el mismo sitio: desde que la bóveda atiende también
      * por un socket local, mandarla siempre por el proxio la dejaba en el vacío.
      */
-    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null, ttlMs = null }) {
-      for (const [id, p] of pending) if (p.ns === ns && p.device === device) pending.delete(id)
+    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null, ttlMs = null, kind = 'read' }) {
+      // Pedir las claves otra vez reemplaza al pedido anterior: es la misma pregunta. Una
+      // ESCRITURA no: cada una lleva su propio valor, y reemplazarla tiraría la anterior
+      // sin que nadie dijera que no.
+      if (kind !== 'write') for (const [id, p] of pending) if (p.kind !== 'write' && p.ns === ns && p.device === device) pending.delete(id)
       const ts = now()
       // `ttlMs` lo pone quien pide: una actualización aguanta un día y un comando cinco
       // minutos, y la mesa no tiene por qué saber cuál es cuál (ver `PENDING_TTL_MS`).
-      const p = { id: rnd(), ns, device, deviceId, label, ek, ctx, ts, exp: ts + (ttlMs || pendingTtlMs), from }
+      const p = { id: rnd(), ns, kind, device, deviceId, label, ek, ctx, ts, exp: ts + (ttlMs || pendingTtlMs), from }
       pending.set(p.id, p)
       return publicOf(p)
     },
@@ -180,4 +185,20 @@ export function createGrants ({ now = Date.now, ttlMs = GRANT_TTL_MS } = {}) {
   return api
 }
 
-export default { createApprovals, createGrants, PENDING_TTL_MS, UPDATE_TTL_MS, GRANT_TTL_MS }
+/**
+ * ¿SE LLEVÓ UNA LIMPIEZA AL ÚLTIMO QUE APROBABA? Devuelve los aprobadores que se fueron si
+ * antes había alguno y ahora no queda ninguno; si no, una lista vacía.
+ *
+ * Una cuenta SIN aprobadores puede ser legítima (todo desatendido, se actualiza sola), así
+ * que el aviso no es «no hay aprobadores»: es «LOS HABÍA y acabas de perder el último».
+ *
+ * @param {string[]} before  llaves con `approve` antes
+ * @param {string[]} after   llaves con `approve` después
+ * @param {string[]} removed llaves que salieron del acta
+ */
+export function lastApproverGone (before, after, removed) {
+  if (!before.length || after.length) return []
+  return removed.filter((pub) => before.includes(pub))
+}
+
+export default { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, UPDATE_TTL_MS, GRANT_TTL_MS }

package/src/vault.js

@@ -37,7 +37,7 @@ import { loadManifest, brokenOf } from '@dotrino/roadmap'
 // 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, PENDING_TTL_MS, GRANT_TTL_MS } from './approvals.js'
+import { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_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'
@@ -155,6 +155,31 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     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 }) {
+    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 })
+    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)
+      }
+    }, PENDING_TTL_MS)
+    t.unref?.()
+    await notifyApprovers(pend, record)
+    return pend
+  }
+
   /**
    * QUÉ COMANDO ESTÁ PIDIENDO LAS CLAVES, Y DESDE QUÉ CARPETA — medido, no creído.
    *
@@ -1595,16 +1620,23 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     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' })
-    // PEDIDOS QUE NO SON DE UN CAJÓN (hoy: la bóveda de contraseñas). Se resuelve 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.
+    // 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'
-      audit(ok ? 'passwords.approved' : 'passwords.denied', { device: pend.deviceId, id, by })
-      log(`[vault] passwords: request of ${pend.deviceId} ${ok ? 'approved' : 'DENIED'} by ${by}`)
-      resolver(ok)
+      const what = pend.kind === 'write' ? 'vars' : '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') {
@@ -1917,24 +1949,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // 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.
       approve: async ({ pubkey, op }) => {
-        const deviceId = await deviceIdOf(pubkey).catch(() => null)
-        const label = (actaCache?.members || []).find((m) => m.pub === pubkey)?.label || ''
-        const pend = approvals.request({ ns: 'passwords', device: pubkey, deviceId, label, ek: '' })
-        audit('passwords.pending', { device: deviceId, id: pend.id, op })
-        log(`[vault] passwords: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
-        const espera = new Promise((resolve) => {
-          waiters.set(pend.id, resolve)
-          // Si nadie contesta, vence solo: la promesa no se queda colgada para siempre
-          // y el aparato recibe un no en vez de esperar sin fin.
-          const t = setTimeout(() => {
-            if (waiters.delete(pend.id)) {
-              audit('passwords.expired', { device: deviceId, id: pend.id })
-              resolve(false)
-            }
-          }, PENDING_TTL_MS)
-          t.unref?.()
-        })
-        await notifyApprovers(pend, actaCache)
+        let resolve
+        const espera = new Promise((r) => { resolve = r })
+        await awaitApproval({ device: pubkey, ns: 'passwords', kind: 'read', what: 'passwords', op, onAnswer: resolve })
         return espera
       },
       audit,
@@ -2111,7 +2128,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // El fallo NO se traga. Que un aviso no salga es exactamente lo que deja a dos
         // bóvedas con actas distintas sin que nadie se entere, y encontrarlo sin una línea
         // de log cuesta días (la última vez, tres).
-        try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature, acta }) }
+        // 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, signature, acta }, { quiet: true }) }
         catch (e) { log(`[vault] could not notify ${pub.slice(0, 24)}… of "${ev}": ${e.message}`) }
       }
       for (const m of miembros) avisar(m.pub)
@@ -2300,11 +2321,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         // 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.
+        const apply = async () => {
+          await checkAuthor(owner, key, sealed, caller)
+          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)
         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)
+        const pending = await holdWrite({ caller, ns, pub, keys: [key], apply })
+        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
@@ -2345,16 +2375,58 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       }
       // Se comprueban TODAS antes de escribir NINGUNA: media carga aplicada es una
       // configuración que nadie quiso, y el servicio se reinicia con ella.
-      for (const it of items) {
-        await secrets.putSealed(owner, it.key, it.sealed, { by: who, public: !!it.public })
-        keys.push(it.key)
+      const apply = async () => {
+        for (const it of items) {
+          await checkAuthor(owner, it.key, it.sealed, caller)
+          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)
       }
-      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 })
+      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 }) {
+    if (!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
+  }
+
   const admin = createAdminDesk({
     desk,
     deviceIdOf,
@@ -3545,12 +3617,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // 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. Requests from devices without \`unattended\` will be refused until you enrol a device and grant it \`dotrino-vault caps <ID> +aprueba\``)
+          }
         } catch (e) { log(`[vault] unlock: could not remove expired devices: ${e.message}`) }
       }
       return { locked: r?.locked !== false }