@dotrino/vaultd 0.51.0 → 0.52.0

package/lib/src/enroll.js

@@ -52,7 +52,7 @@ export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
 /** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
-const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin' }
+const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin', 'vault:passwords': 'passwords' }
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 

package/lib/src/protocol.js

@@ -98,7 +98,11 @@ export const SCOPE = Object.freeze({
   // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
   // de master y sigue siendo local. No se empareja — se concede desde el PC.
   ADMIN: 'vault:admin',
-  APPROVE: 'vault:approve' // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  APPROVE: 'vault:approve', // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
+  // El gestor de contraseñas: pedir credenciales de la bóveda, de a una y por dominio.
+  // Nunca lista la bóveda entera. Este SÍ se empareja (`pair --scope contrasenas`): es
+  // lo primero que hace la extensión, y no tendría sentido obligar a un segundo paso.
+  PASSWORDS: 'vault:passwords'
 })
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.51.0",
+  "version": "0.52.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": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.60.3",
+    "@dotrino/identity": "^0.61.0",
     "@dotrino/passmanager": "^0.1.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -195,16 +195,19 @@ async function cmdPair (args = []) {
   if (scIdx >= 0) {
     const raw = args[scIdx + 1]
     if (!raw || raw.startsWith('-')) { console.error('uso: dotrino-vault pair --scope sign,read,store,secrets:<ns>'); process.exit(2) }
-    const ALIAS = { firma: 'sign', lee: 'read', guarda: 'store' }
+    const ALIAS = { firma: 'sign', lee: 'read', guarda: 'store', contrasenas: 'passwords', 'contraseñas': 'passwords' }
     scope = []
     for (const tok of raw.split(',').map((t) => t.trim()).filter(Boolean)) {
       const t = ALIAS[tok] || tok
       if (t === 'admin' || t === 'administra') { console.error('`admin` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +administra'); process.exit(2) }
       if (t === 'approve' || t === 'aprueba') { console.error('`approve` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +aprueba'); process.exit(2) }
       if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
+      // El gestor de contraseñas SÍ se empareja con su permiso puesto: es lo único que
+      // va a hacer ese aparato, y pedirlo en dos pasos era el paso que nadie daba.
+      if (t === 'passwords') { scope.push('vault:passwords'); continue }
       const m = /^secrets:([a-z0-9-]{1,32})$/.exec(t)
       if (m) { scope.push('vault:secrets:' + m[1]); continue }
-      console.error('permiso desconocido: %s  (sign | read | store | secrets:<ns>)', tok); process.exit(2)
+      console.error('permiso desconocido: %s  (sign | read | store | contrasenas | secrets:<ns>)', tok); process.exit(2)
     }
     if (service) scope.push('vault:secrets:' + service)
     scope = [...new Set(scope)]
@@ -404,7 +407,7 @@ async function cmdMembers () {
     // se mira quién es quién — y en la lista de variables ya seria tarde.
     if (m.cn && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
   }
-  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +permiso')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +permiso')
   console.log('  «Permiso»: ese aparato solo recibe claves privadas cuando lo apruebas desde un aparato con «aprueba» (en cada arranque).')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
   console.log('  No deja cambiar permisos ni traspasar el mando: eso solo se hace en esta máquina.')
@@ -463,42 +466,20 @@ async function cmdApproval (args = []) {
     : `Listo: ${m.id} vuelve a recibir sus claves sin aprobación.`)
 }
 
-/**
- * `dotrino-vault passwords <ID> on|off` — deja (o no) que ese aparato pida contraseñas
- * de tu bóveda.
- *
- * Es una lista de ESTA bóveda, no del acta, por lo mismo que `approval`: es ella la que
- * entrega. El acta manda igual — si revocas el aparato allí, deja de pedir aunque siga
- * en esta lista. Y si además le pones `approval on`, cada arranque suyo te pedirá el
- * visto bueno en el teléfono.
- */
-async function cmdPasswords (args = []) {
-  const [id, val] = args
-  if (!id || !['on', 'off'].includes(val)) {
-    console.error('uso: dotrino-vault passwords <ID> on|off')
-    process.exit(1)
-  }
-  const m = await findMember(id)
-  writeReq('secret-request.json', { op: 'passwords', pub: m.pub, id: m.id, label: m.label || '', on: val === 'on' })
-  sendSignal(requireDaemon().pid, 'SIGUSR2')
-  if (val === 'on') {
-    console.log(`Listo: ${m.id} puede pedir contraseñas de tu bóveda (de una en una; nunca la lista entera).`)
-    console.log('Reinicia el vault: al arrancar imprime el código de enlace que se pega en la extensión.')
-  } else {
-    console.log(`Listo: ${m.id} deja de poder pedir contraseñas.`)
-  }
-}
-
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
   const [id, ...changes] = args
   if (!id || !changes.length) {
-    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+permiso|-permiso')
+    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+permiso|-permiso')
     process.exit(2)
   }
   const CAP_BY_WORD = {
     firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
-    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve'
+    // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
+    // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
+    contrasenas: 'passwords', 'contraseñas': 'passwords',
+    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve',
+    passwords: 'passwords'
   }
   const s = requireDaemon()
   const m = await findMember(id)
@@ -1191,7 +1172,7 @@ function help () {
                       (sin la bandera entra a la cuenta activa, o a la de --profile)
   pair --service <ns> empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
   pair --approval       el aparato que entre pedirá tu aprobación (teléfono) al recibir claves
-  pair --scope <lista>  los PERMISOS del cert: sign,read,store,secrets:<ns> (sin esto: sign,read,store;
+  pair --scope <lista>  los PERMISOS del cert: sign,read,store,contrasenas,secrets:<ns> (sin esto: sign,read,store;
                       se combina con --service: --service eco --scope sign = bot que firma y lee su cajón)
   secret set <ns> <CLAVE> <valor>   variable del scope <ns>: la comparten TODOS los
                                     aparatos del perfil que sirven ese namespace
@@ -1206,10 +1187,6 @@ function help () {
   secret device set <ID> CLAVE=valor …
   secret device import <ID> [archivo.env]
   secret device rm <ID> <CLAVE>     borra una variable de ese aparato
-  passwords <ID> on|off             deja que ese aparato pida CONTRASEÑAS de tu bóveda
-                                    (de una en una; nunca la lista entera). Con
-                                    approval on además te pedirá el visto bueno en el
-                                    teléfono. Reinicia el vault tras el primer on
   secret list                       lista los dos cajones: el valor de las públicas,
                                     tapadas las privadas
   secret show [device] <ns|ID> <CLAVE>
@@ -1234,7 +1211,7 @@ function help () {
   me                  tu perfil (nombre, foto, datos) tal como lo tiene la bóveda
   members             el acta del perfil: quién es tuyo y qué puede hacer
   label <ID> <nombre> renombra un dispositivo (el nombre con el que lo reconoces)
-  caps <ID> ±permiso  cambia permisos (+firma -guarda +administra …)
+  caps <ID> ±permiso  cambia permisos (+firma -guarda +administra +contrasenas …)
   revoke <ID|nonce>   quita un dispositivo (con el ID, todos sus certificados)
   activity [n]        bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
   logs                últimos logs del servicio
@@ -1284,7 +1261,6 @@ export async function runCtl (argv) {
     case 'revoke': return cmdRevoke(rest[0])
     case 'secret': return cmdSecret(rest)
     case 'approval': return cmdApproval(rest)
-    case 'passwords': return cmdPasswords(rest)
     case 'activity': return cmdActivity(Number(rest[0]) || 30)
     case 'logs': return cmdLogs()
     case 'version':

package/src/daemon.js

@@ -405,11 +405,6 @@ export async function runDaemon () {
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
           } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
-          else if (sec.op === 'passwords') {
-            const r = await vault.setPasswordDevice(sec.pub, { label: sec.label, on: !!sec.on })
-            console.log('[vault] passwords: device %s %s', sec.id || '?', sec.on ? 'ALLOWED' : 'removed')
-            if (sec.on) console.log('[vault] restart the vault so it starts answering password requests')
-          }
           else if (sec.op === 'approval') { const r = await vault.setApproval(sec.pub, !!sec.approval); console.log('[vault] device %s: approval %s', sec.id || '?', r.approval ? 'REQUIRED on every key request' : 'off') }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }

package/src/tui/app.js

@@ -318,7 +318,7 @@ function pairModeRows (st, t) {
  * una marca de si los tiene. El de administrar va aparte y avisado: es el único que deja
  * a ese aparato meter y sacar dispositivos sin venir aquí.
  */
-const CAPS_ORDER = ['sign', 'store', 'read', 'admin']
+const CAPS_ORDER = ['sign', 'store', 'read', 'admin', 'passwords']
 
 function capsRows (st, t) {
   const i = L(st)

package/src/tui/i18n.js

@@ -45,13 +45,15 @@ const es = {
     sign: 'Firmar como tú',
     store: 'Guardar tus datos',
     read: 'Leer tus datos',
-    admin: 'Administrar el perfil'
+    admin: 'Administrar el perfil',
+    passwords: 'Pedir tus contraseñas'
   },
   capHint: {
     sign: 'usar tu identidad en las apps del ecosistema',
     store: 'escribir en tu bóveda (perfil, contenido, datos sensibles)',
     read: 'ver lo que guardaste',
-    admin: 'conectar y quitar dispositivos desde ese aparato, sin venir aquí'
+    admin: 'conectar y quitar dispositivos desde ese aparato, sin venir aquí',
+    passwords: 'el gestor: pedir una credencial por sitio, nunca la lista entera'
   },
   confirmAdmin: (id) => `¿Dejar que ${id} conecte y quite dispositivos sin venir aquí?`,
   capGiven: (n) => `Concedido: ${n}`,
@@ -341,13 +343,15 @@ const en = {
     sign: 'Sign as you',
     store: 'Save your data',
     read: 'Read your data',
-    admin: 'Manage the profile'
+    admin: 'Manage the profile',
+    passwords: 'Ask for your passwords'
   },
   capHint: {
     sign: 'use your identity across the ecosystem apps',
     store: 'write to your vault (profile, content, sensitive data)',
     read: 'see what you saved',
-    admin: 'connect and remove devices from that device, without coming here'
+    admin: 'connect and remove devices from that device, without coming here',
+    passwords: 'the manager: ask for one credential per site, never the whole list'
   },
   confirmAdmin: (id) => `Let ${id} connect and remove devices without coming here?`,
   capGiven: (n) => `Granted: ${n}`,

package/src/vault.js

@@ -102,9 +102,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return { approval: !!on }
   }
   // 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 es una LISTA DE ESTA BÓVEDA, no del
-  // acta — por lo mismo que `approval.json`: es ella la que entrega. El acta sigue
-  // mandando en que el aparato exista y no esté revocado, y eso se comprueba aparte.
+  // 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)
   const readPasswordsFile = () => {
@@ -118,13 +119,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const passwordsStore = {
     async get (k) { return readPasswordsFile()?.data?.[k] },
     async set (k, v) {
-      const d = readPasswordsFile() || { v: 1, data: {}, devices: [] }
+      const d = readPasswordsFile() || { v: 1, data: {} }
       d.data = { ...(d.data || {}), [k]: v }
       writePasswordsFile(d)
     },
   }
 
-  const passwordDevices = () => readPasswordsFile()?.devices || []
+  /** 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'))
 
   /**
    * El acta vigente, en caché.
@@ -153,20 +155,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
     const key = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
     const raw = new Uint8Array(await crypto.subtle.exportKey('raw', key))
-    writePasswordsFile({ ...(d || { v: 1, data: {} }), cek: Buffer.from(raw).toString('base64'), devices: d?.devices || [] })
+    writePasswordsFile({ ...(d || { v: 1, data: {} }), cek: Buffer.from(raw).toString('base64') })
     return key
   }
 
-  /** Autorizar/retirar un aparato para pedir contraseñas (`dotrino-vault passwords`). */
-  async function setPasswordDevice (pub, { label = '', on = true } = {}) {
-    const d = readPasswordsFile() || { v: 1, data: {}, devices: [] }
-    const resto = (d.devices || []).filter((x) => x.pubkey !== pub)
-    if (on) resto.push({ pubkey: pub, label: String(label || '').slice(0, 60), ts: Date.now() })
-    writePasswordsFile({ ...d, devices: resto })
-    audit('passwords.device', { device: await deviceIdOf(pub).catch(() => null), on: !!on })
-    return { ok: true }
-  }
-
   const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit('secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId }) }, 30 * 1000); approvalsSweeper.unref?.()
   const secrets = openSecretsStore(dir, {
     sealer: makeSealer(),
@@ -764,69 +756,94 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // ----- 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 si hay algún aparato autorizado — sin eso no hay a quién
+  // 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
-  try {
-    if (passwordDevices().length) {
-      const { createPasswordDesk } = await import('./passwords.js')
-      await refreshActa()
-      const actaSweeper = setInterval(refreshActa, 5000)
-      actaSweeper.unref?.()
-      passwords = createPasswordDesk({
-        client,
-        store: passwordsStore,
-        cek: await passwordsKey(),
-        // DOS condiciones, y hacen falta las dos: que esta bóveda lo haya autorizado
-        // (su lista) y que el ACTA siga reconociéndolo. Revocar un aparato en el acta
-        // le corta esto también, sin tener que acordarse de dos sitios.
-        isAllowed: (pub) => {
-          if (!passwordDevices().some((d) => d.pubkey === pub)) return false
-          return (actaCache?.members || []).some((m) => m.pub === pub)
-        },
-        encPubOf: (pub) => (actaCache?.members || []).find((m) => m.pub === pub)?.encPub || null,
-        needsApproval: (pub) => needsApproval(pub),
-        // 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)
-          return espera
-        },
-        audit,
-        log,
-      }).start()
-      log('[vault] passwords: atendiendo peticiones de %d aparato(s)', passwordDevices().length)
-      // El código que se pega en la extensión o en la consola web. Lleva las DOS
-      // públicas: por la de firma enruta el proxio, a la de cifrado se le sella el
-      // contenido. Es público: no hay nada aquí que no pueda verse.
-      try {
-        const codigo = Buffer.from(JSON.stringify({
-          v: 1,
-          sign: await client.getPublicKey(),
-          enc: await identity.getEncryptionPubkey(),
-        })).toString('base64url')
-        log('[vault] passwords: enlaza un aparato con este código:\n%s', codigo)
-      } catch (e) {
-        log('[vault] passwords: no se pudo componer el código de enlace: %s', e.message)
+  /**
+   * 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.
+   *
+   * Va aquí y no en el cliente del transporte porque el cliente del vault es UNO y lo
+   * comparte todo: el protocolo de la CA viaja en claro a propósito (un enrolamiento es
+   * público hasta que hay cert). Lo que se sella es lo del gestor, y por eso `isSealed`
+   * mira su marca 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 = {
+    async seal (msg, peerEncPub) {
+      if (!peerEncPub) throw Object.assign(new Error('no encryption key'), { code: 'unsealed' })
+      return {
+        app: 'passmanager',
+        // Destinatarios como OBJETOS y no como llaves sueltas: `encrypt` expande cada
+        // uno a todos los aparatos de esa persona, y una cadena a secas se le cae por
+        // el `continue` sin envolver nada — el sobre salía vacío y sin error.
+        sealed: await identity.encrypt([{ encryptionPubkey: peerEncPub }], JSON.stringify(msg)),
+        from: await identity.getEncryptionPubkey()
       }
-    }
+    },
+    // `decrypt` devuelve `{ plaintext }`, no la cadena.
+    async open (env) { return JSON.parse((await identity.decrypt(env.from, null, env.sealed)).plaintext) },
+    isSealed: (m) => !!m && m.app === 'passmanager' && !!m.sealed
+  }
+  const startPasswordDesk = async () => {
+    if (passwords || !passwordDevices().length) return
+    const { createPasswordDesk } = await import('./passwords.js')
+    client.updateConfig({ sealing: passwordSealing })
+    passwords = createPasswordDesk({
+      client,
+      store: passwordsStore,
+      cek: await passwordsKey(),
+      // 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,
+      needsApproval: (pub) => needsApproval(pub),
+      // 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)
+        return espera
+      },
+      audit,
+      log,
+    }).start()
+    log('[vault] passwords: serving %d device(s)', passwordDevices().length)
+  }
+  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: no se pudo levantar (%s); el resto sigue igual', e.message)
   }
@@ -1730,7 +1747,6 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // 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,
-    setPasswordDevice,
     passwordsVault: () => passwords?.vault || null,
     listApprovals: () => approvals.list(),
     // Aprobar desde el PC avisa igual que aprobar a distancia: el resto de tus