@dotrino/vaultd 0.51.0 → 0.53.0

package/README.md

@@ -456,18 +456,25 @@ y así un reinicio del PC nunca deja tus apps muertas esperando a que alguien te
 ```sh
 dotrino-vault profile password     # pone o cambia la contraseña (te la pregunta)
 dotrino-vault profile password rm  # la quita
-dotrino-vault unlock               # abre la bóveda en esta consola
-dotrino-vault lock                 # vuelve a cerrarla
+dotrino-vault unlock               # abre la bóveda en esta consola (5 min sin usarse y se cierra sola)
+dotrino-vault lock                 # vuelve a cerrarla ya
 ```
 
 Lo único que se sigue viendo con el candado puesto es que **existe** y que está cerrada
 (`status`, `profile ls`): si no, no habría forma de saber qué abrir.
 
-El perfil se vuelve a bloquear al reiniciar el servicio. La contraseña **no se
-guarda**: solo un verificador con sal (PBKDF2), igual que el candado del navegador.
-Tiene un mínimo de 4 caracteres y, tras 5 intentos fallidos, cada intento nuevo
-espera cada vez más (hasta 5 minutos); la cuenta de fallos se guarda, así que
-reiniciar no la borra.
+**Se vuelve a cerrar solo a los 5 minutos sin usarse**, además de al reiniciar el
+servicio o con `dotrino-vault lock`. El plazo se cuenta desde la última cosa que hiciste
+en la consola, no desde que la abriste: mientras trabajas no te echa, y en cuanto te
+levantas de la silla se cierra. Lo que piden tus aparatos por el proxy **no** cuenta como
+uso —el candado no es suyo—, así que siguen funcionando igual mientras la consola se
+cierra. La TUI, además, **olvida la contraseña** en ese momento: si no, la reabriría sola
+a la siguiente tecla.
+
+La contraseña **no se guarda**: solo un verificador con sal (scrypt), igual que el
+candado del navegador. Tiene un mínimo de 12 caracteres —varias palabras al azar— y,
+tras 5 intentos fallidos, cada intento nuevo espera cada vez más (hasta 5 minutos); la
+cuenta de fallos se guarda, así que reiniciar no la borra.
 
 Con el perfil bloqueado, la CLI **no** te pide la contraseña sobre la marcha: cualquier
 comando que mire o toque esa bóveda falla con «perfil bloqueado» y hay que correr

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.53.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)
@@ -1160,8 +1141,13 @@ function askText (prompt) {
 
 async function cmdUnlock () {
   const pwd = await askPassword('Contraseña del perfil: ')
-  reportProfiles(await profileRequest('unlock', { password: pwd }))
-  console.log('Ya puedes editar el perfil. Se vuelve a bloquear al reiniciar el servicio (o con: dotrino-vault lock).')
+  // El daemon devuelve cuánto aguanta abierto: se dice AQUÍ, al abrirlo, que es cuando
+  // sirve de algo. Encontrárselo cerrado sin haberlo leído nunca parece una avería.
+  const out = await profileRequest('unlock', { password: pwd })
+  reportProfiles(out)
+  const min = Math.max(1, Math.round((out?.autoLockMs || 5 * 60 * 1000) / 60000))
+  console.log(`Ya puedes editar el perfil. Se vuelve a bloquear solo tras ${min} min sin usarse` +
+    ' (o al reiniciar el servicio, o con: dotrino-vault lock).')
 }
 
 async function cmdLock () {
@@ -1191,7 +1177,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 +1192,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 +1216,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
@@ -1254,7 +1236,8 @@ dispositivos siguen firmando y leyendo aunque esté bloqueado):
   profile password [set]            pone o cambia la contraseña
   profile password rm               la quita
   unlock                            desbloquea para poder editar
-  lock                              vuelve a bloquear (también al reiniciar el servicio)
+  lock                              vuelve a bloquear (también solo, a los 5 min sin
+                                    usarse, y al reiniciar el servicio)
 
 Arrancar y parar, según dónde corra:
   Linux (servicio)  systemctl --user {start,stop,restart} dotrino-vault
@@ -1284,7 +1267,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

@@ -74,6 +74,9 @@ export async function runDaemon () {
     writeJson(stateFile, {
       v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
       proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
+      // Cuánto aguanta abierto el candado sin usarse. Va en la foto para que la consola
+      // pueda DECIRLO en vez de llevar su propio número (que se desincronizaría).
+      autoLockMs: mgr.profiles.autoLockMs,
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -105,7 +108,14 @@ export async function runDaemon () {
   const resolveTarget = (req) => {
     try {
       const id = req?.profile ? mgr.resolve(req.profile) : mgr.currentId()
-      return { id, vault: mgr.get(id), locked: mgr.profiles.isLocked(id) }
+      const locked = mgr.profiles.isLocked(id)
+      // ESTO CUENTA COMO USO: el candado se cierra solo a los 5 min de no usarse
+      // (`profiles.js`), y quien lo usa es esta consola. Va aquí y no en cada `case`
+      // porque toda petición de la CLI/TUI pasa por este punto, y así ninguna se olvida.
+      // Lo que un aparato pida por el proxy NO pasa por aquí, que es justo lo que se
+      // quiere: el candado no es suyo y no debe alargarlo.
+      if (!locked) mgr.profiles.touch(id)
+      return { id, vault: mgr.get(id), locked }
     } catch (e) { console.error('[vault] invalid profile in the request:', e.message); return null }
   }
   /** La bóveda destino, o `null` si el perfil está bloqueado (la petición no se atiende). */
@@ -247,8 +257,24 @@ export async function runDaemon () {
     if (r?.rekeyed) console.log('[vault] secrets master re-sealed (%d drawer(s))', r.drawers)
   }
 
+  /**
+   * BORRA la llave derivada en cuanto se usó. Es lo único de la contraseña que se puede
+   * borrar de verdad: un `string` de JS no se puede pisar (lo copia y lo mueve el motor
+   * hasta que pase el recolector), pero un `Uint8Array` sí, y es el que lleva el material
+   * con el que se abre la copia maestra. Vale lo que vale — no hace milagros con un
+   * volcado de memoria tomado en el instante justo —, pero acorta la ventana de horas a
+   * milisegundos, que es la diferencia entre «estaba ahí» y «estuvo».
+   */
+  const wipe = (k) => { try { if (k instanceof Uint8Array) k.fill(0) } catch (_) {} }
+
   async function handleProfileRequest (req) {
-    const ref = () => mgr.resolve(req.profile || mgr.currentId())
+    // Resolver el destino de una orden de perfil CUENTA COMO USO: estira el plazo del
+    // bloqueo automático igual que cualquier otra cosa que se haga desde la consola.
+    const ref = () => {
+      const id = mgr.resolve(req.profile || mgr.currentId())
+      mgr.profiles.touch(id)
+      return id
+    }
     switch (req.op) {
       case 'list': return {} // el volcado de perfiles ya se hace abajo
       // `id`: quien la crea necesita saber CUÁL quedó, no adivinar por nombre (dos
@@ -266,8 +292,9 @@ export async function runDaemon () {
         const id = ref()
         await mgr.profiles.unlock(id, req.password)
         let note = ''
+        let ak = null
         try {
-          const ak = await mgr.profiles.adminKey(id, req.password)
+          ak = await mgr.profiles.adminKey(id, req.password)
           // REHACER el llavero, no solo saldar: con la frase delante se puede dejar cada
           // cajón envuelto para exactamente quien dice el acta — creando lo que falta,
           // reemplazando lo que alguien metiera mal y quitando lo que sobre.
@@ -277,7 +304,8 @@ export async function runDaemon () {
           if (r?.dropped) note = ` · llavero al día (${r.dropped} envoltura(s) de más retirada(s))`
           else if (r?.wrapped) note = ' · llavero al día'
         } catch (e) { console.error('[vault] could not rebuild the keyring on unlock:', e.message) }
-        return { done: 'perfil desbloqueado' + note }
+        finally { wipe(ak) }
+        return { done: 'perfil desbloqueado' + note, autoLockMs: mgr.profiles.autoLockMs }
       }
       case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
       // PONER contraseña: los secretos pasan de abrirse con la llave de la máquina a
@@ -291,7 +319,7 @@ export async function runDaemon () {
         const vieja = tenia ? await mgr.profiles.adminKey(id, req.current) : null
         await mgr.profiles.setPassword(id, req.password)
         const nueva = await mgr.profiles.adminKey(id, req.password)
-        await rekey(id, vieja, nueva)
+        try { await rekey(id, vieja, nueva) } finally { wipe(vieja); wipe(nueva) }
         return { done: 'contraseña guardada' }
       }
       // QUITARLA: al revés. Se abre la copia maestra con la frase y se vuelve a cerrar
@@ -301,7 +329,7 @@ export async function runDaemon () {
         const id = ref()
         if (!req.password) throw new Error('removing the password needs the current one: the secrets must be re-sealed before it goes')
         const vieja = await mgr.profiles.adminKey(id, req.password)
-        await rekey(id, vieja, null)
+        try { await rekey(id, vieja, null) } finally { wipe(vieja) }
         mgr.profiles.removePassword(id)
         return { done: 'contraseña quitada · los secretos ahora se abren con la llave de esta máquina' }
       }
@@ -373,6 +401,7 @@ export async function runDaemon () {
       if (sec?.op) {
         rm(secretReqFile) // puede llevar la contraseña: fuera del disco cuanto antes
         lastSecretError = null
+        let ak // fuera del try para poder BORRARLA pase lo que pase (ver `wipe`)
         try {
           const vault = targetOf(sec)
           // Carga en GRUPO (`secret set ns K=v K2=v2`, `secret import`): todas las
@@ -384,7 +413,7 @@ export async function runDaemon () {
           // convertir el archivo, rotar re-cifrando—: escribir no (§8.1). Sin ella se cae
           // a la llave de la máquina, que es la protección de antes de esto (y el vault lo
           // avisa al arrancar).
-          const ak = sec.password ? await mgr.profiles.adminKey(sec.profile ? mgr.resolve(sec.profile) : mgr.currentId(), sec.password) : undefined
+          ak = sec.password ? await mgr.profiles.adminKey(sec.profile ? mgr.resolve(sec.profile) : mgr.currentId(), sec.password) : undefined
           if (sec.op === 'migrate') {
             // Sin lista a mano: la pone el vault, y es la MISMA que usa cualquier
             // escritura (servicios del cajón + aparatos que administran). Con una lista
@@ -405,11 +434,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) }
@@ -445,7 +469,7 @@ export async function runDaemon () {
             code: e.code || (/wrong password/i.test(e.message) ? 'WRONG_PASSWORD' : 'SECRET_FAILED')
           }
           console.error('[vault] secret failed:', e.message)
-        }
+        } finally { wipe(ak) }
       }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)

package/src/manager.js

@@ -35,14 +35,20 @@ export function assertCanRemove ({ isMaster, memberCount, name = '' }) {
   throw e
 }
 
-export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge } = {}) {
+export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, autoLockMs } = {}) {
   ensureDir(root)
   // El keypair de transporte del proxy-client es del PROCESO, no de la identidad:
   // se instala apuntando a la RAÍZ (no al dir de un perfil) para que los perfiles
   // no se peleen por el archivo ni se lo lleven al borrarse.
   installNodeGlobals(root)
 
-  const profiles = openProfiles(root)
+  const profiles = openProfiles(root, {
+    ...(autoLockMs === undefined ? {} : { autoLockMs }),
+    // Que se cierre solo tiene que VERSE: si no, quien vuelve y encuentra la consola
+    // pidiendo la contraseña otra vez cree que algo se rompió.
+    onAutoLock: (id) => log('[vault] profile %s locked itself after %d min idle (the console; devices keep working)',
+      id, Math.round(profiles.autoLockMs / 60000))
+  })
   const migrated = profiles.migrate()
   if (migrated?.migrated) log('[vault] identidad mono-perfil migrada al perfil %s', migrated.id)
 

package/src/profiles.js

@@ -52,6 +52,25 @@ const PWD_MIN = 12
  */
 const TRIES_FORGET_MS = 15 * 60 * 1000
 
+/**
+ * BLOQUEO AUTOMÁTICO. Cuánto aguanta abierto el candado sin que nadie lo use.
+ *
+ * Abrir la bóveda dejaba la consola abierta hasta que alguien la cerraba a mano o
+ * reiniciaba el servicio — y el servicio de un PC de escritorio no se reinicia en semanas.
+ * O sea que teclear la contraseña una vez un lunes dejaba la máquina administrable para
+ * quien pasara por delante el jueves. Un candado que solo se cierra reiniciando no es un
+ * candado.
+ *
+ * El plazo se cuenta desde el ÚLTIMO USO (`touch`), no desde que se abrió: quien está
+ * trabajando no se queda fuera a media faena, y quien se levanta de la silla lo encuentra
+ * cerrado. Y vence solo, sin temporizador: se mira la hora al preguntar (`isOpen`), así
+ * que no hay nada que limpiar ni un `setTimeout` que mantenga vivo al proceso.
+ *
+ * Como todo el candado, esto es de la CONSOLA: al vencer, los aparatos ya emparejados
+ * siguen firmando, leyendo y guardando. Lo que se cierra es administrar y mirar.
+ */
+const AUTO_LOCK_MS = 5 * 60 * 1000
+
 /**
  * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
  *
@@ -91,7 +110,13 @@ async function derivePwd (password, saltB64, iter) {
 const newId = () => 'p' + crypto.randomUUID().slice(0, 8)
 const cleanName = (name) => String(name || '').slice(0, MAX_NAME)
 
-export function openProfiles (root = dataDir()) {
+/**
+ * @param {string} root  dir de datos
+ * @param {{ autoLockMs?: number, onAutoLock?: (id: string) => void }} [opts]
+ *   `autoLockMs`: 0 desactiva el bloqueo automático (las pruebas lo acortan).
+ *   `onAutoLock`: se avisa cuando un perfil se cierra solo, para poder decirlo en el log.
+ */
+export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onAutoLock = null } = {}) {
   const file = path.join(root, REGISTRY)
   // CIFRADO EN REPOSO, como todo lo demás. Era el único archivo del vault sin códec, y
   // lleva dentro el verificador del candado. No protege de quien tenga el disco entero
@@ -107,8 +132,24 @@ export function openProfiles (root = dataDir()) {
   const save = () => writeJson(file, data, atRest)
 
   // Perfiles DESBLOQUEADOS en esta ejecución del daemon (en memoria: un reinicio
-  // vuelve a bloquear, igual que cerrar la pestaña en el navegador).
-  const unlocked = new Set()
+  // vuelve a bloquear, igual que cerrar la pestaña en el navegador), cada uno con la
+  // hora a la que se cierra solo si nadie lo usa (ver AUTO_LOCK_MS).
+  const unlocked = new Map() // id -> vence (ms epoch)
+
+  /** ¿Sigue abierto? Vence al MIRARLO, así que no hace falta ningún temporizador. */
+  const isOpen = (id) => {
+    const until = unlocked.get(id)
+    if (until == null) return false
+    if (autoLockMs > 0 && Date.now() >= until) {
+      unlocked.delete(id)
+      // El aviso va después de borrarlo: quien lo escuche verá el perfil ya cerrado.
+      try { onAutoLock?.(id) } catch (_) {}
+      return false
+    }
+    return true
+  }
+  /** Abre (o estira) el plazo. Todo lo que abre el candado pasa por aquí. */
+  const open = (id) => { unlocked.set(id, Date.now() + (autoLockMs > 0 ? autoLockMs : Number.MAX_SAFE_INTEGER)) }
 
   const find = (id) => data.profiles.find((p) => p.id === id) || null
   const dirOf = (id) => path.join(root, 'p', id)
@@ -118,7 +159,10 @@ export function openProfiles (root = dataDir()) {
     name: p.name || '',
     createdAt: p.createdAt || null,
     protected: !!p.pwd,
-    locked: !!p.pwd && !unlocked.has(p.id),
+    locked: !!p.pwd && !isOpen(p.id),
+    // Hasta cuándo sigue abierto si nadie lo toca. Es DATO: la consola lo enseña para
+    // que el cierre no llegue por sorpresa.
+    ...(p.pwd && isOpen(p.id) && autoLockMs > 0 ? { until: unlocked.get(p.id) } : {}),
     current: p.id === data.current,
     // Nació para adoptar la cuenta de un aparato (camino A) y todavía no lo ha hecho.
     ...(p.adopt ? { adopt: true } : {})
@@ -231,7 +275,20 @@ export function openProfiles (root = dataDir()) {
     // ----- candado -----
 
     isProtected: (id) => !!find(id)?.pwd,
-    isLocked: (id) => { const p = find(id); return !!p?.pwd && !unlocked.has(id) },
+    isLocked: (id) => { const p = find(id); return !!p?.pwd && !isOpen(id) },
+    /** Cuánto dura abierto el candado sin usarse (ms). 0 = no se cierra solo. */
+    get autoLockMs () { return autoLockMs },
+    /**
+     * «Se acaba de usar»: estira el plazo del bloqueo automático. Lo llama la consola
+     * al atender CADA petición suya, y solo eso cuenta como uso: que un aparato pida su
+     * configuración no abre nada ni alarga nada, porque el candado no es suyo.
+     * Devuelve si el perfil estaba abierto (a uno cerrado no hay nada que estirarle).
+     */
+    touch (id) {
+      if (!isOpen(id)) return false
+      open(id)
+      return true
+    },
     assertUnlocked (id) {
       if (api.isLocked(id)) throw new Error('profile locked: unlock it with your password (dotrino-vault unlock)')
     },
@@ -258,7 +315,7 @@ export function openProfiles (root = dataDir()) {
 
     async unlock (id, password) {
       const p = assertExists(id)
-      if (!p.pwd) { unlocked.add(id); return { ok: true, locked: false } }
+      if (!p.pwd) { open(id); return { ok: true, locked: false } }
       // Freno de fuerza bruta (una contraseña corta se adivina probando): tras 5
       // fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro.
       // Los fallos VIEJOS se olvidan (ver TRIES_FORGET_MS): si desde el último ha pasado
@@ -296,7 +353,7 @@ export function openProfiles (root = dataDir()) {
       }
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return { ok: true, locked: false }
     },
 
@@ -314,7 +371,7 @@ export function openProfiles (root = dataDir()) {
       p.pwd = { v: 2, salt, verifier: deriveScryptPwd(password, salt) }
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return entry(p)
     },
 
@@ -324,7 +381,7 @@ export function openProfiles (root = dataDir()) {
       delete p.pwd
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return entry(p)
     }
   }

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)
@@ -492,6 +492,72 @@ async function guard (term, st, msg, fn) {
  */
 const activeLocked = (st) => { const p = activeProfile(st); return !!(p?.protected && p.locked) }
 
+/** Los minutos que el daemon aguanta abierto (viene en `state.json`; 5 por defecto). */
+const autoLockMin = (st) => Math.max(1, Math.round((st.state?.autoLockMs || 5 * 60 * 1000) / 60000))
+
+/**
+ * ¿Alguna de las bóvedas que abrió ESTA sesión se cerró sola?
+ *
+ * El plazo lo lleva el daemon (`profiles.js`), no la TUI: aquí solo se MIRA su foto
+ * (`state.json`, que se reescribe cada dos segundos). Así hay un único reloj y no dos
+ * que se desincronizan — y lo que decida el daemon es lo que manda, porque es quien
+ * atiende.
+ */
+const autoLockedIds = (st) => (st.state?.profiles || [])
+  .filter((p) => p.protected && p.locked && (st.sessionPwd?.has(p.id) || st.unlockedHere?.has(p.id)))
+  .map((p) => p.id)
+
+/**
+ * Cuándo hay que despertar para enterarse. Sin esto la TUI se queda dormida en
+ * `readKey()` hasta la siguiente tecla y seguiría enseñando los aparatos y los nombres
+ * de las variables de una bóveda que el daemon ya cerró. Se suman ~2 s porque la foto
+ * se reescribe cada dos: despertar en el instante justo leería la anterior.
+ */
+function autoLockWakeIn (st, now = Date.now()) {
+  let at = 0
+  for (const p of st.state?.profiles || []) {
+    if (!p.until || !(st.sessionPwd?.has(p.id) || st.unlockedHere?.has(p.id))) continue
+    at = at ? Math.min(at, p.until) : p.until
+  }
+  if (!at) return 0
+  const left = at - now + 2200
+  // El plazo ya pasó y la foto sigue diciendo que está abierta: el daemon no la está
+  // reescribiendo (caído o colgado). Se insiste un rato y luego se deja de despertar, o
+  // la TUI se quedaría dando vueltas contra una foto que no va a cambiar.
+  if (left <= 0) return now - at > 15000 ? 0 : 1000
+  return Math.max(250, left)
+}
+
+/**
+ * BLOQUEO AUTOMÁTICO. Se cerró sola: se OLVIDA su contraseña y se sale de lo que se
+ * estaba mirando (dentro se ven los aparatos, las variables y tus datos, que es justo
+ * lo que el candado tapa).
+ *
+ * Olvidarla es la mitad que importa: sin esto la TUI la seguiría teniendo y la
+ * reabriría sola en cuanto alguien pulsara Enter (ver `reunlockSilently`), así que el
+ * candado del daemon no habría cerrado nada.
+ */
+async function forgetAutoLocked (term, st, api = vc) {
+  const ids = autoLockedIds(st)
+  if (!ids.length) return false
+  for (const id of ids) { st.sessionPwd?.delete(id); st.unlockedHere?.delete(id) }
+  const cur = (st.state?.profiles || []).find((p) => p.current)
+  if (ids.includes(cur?.id) && st.screen !== 'profiles') {
+    // Un modal abierto (una pregunta a medias) también se cierra: quien lo dejó abierto
+    // ya no está delante.
+    st.input = null
+    st.confirm = null
+    st.screen = 'profiles'
+  }
+  // Suelta lo cargado y repinta la lista con el candado ya echado (`refreshAll` no pide
+  // el contenido de una bóveda cerrada).
+  await refreshAll(term, st, api)
+  // El aviso va DESPUÉS del refresco: si no, un tropiezo al refrescar lo pisaría con su
+  // error rojo y el candado se cerraría en silencio.
+  flash(st, L(st).autoLocked(autoLockMin(st)), 'warn')
+  return true
+}
+
 // `api` es `vaultControl` — se recibe para poder probar ESTA función (la que se rompió)
 // sin un daemon detrás, que es donde vive la regla de qué se pide y en qué orden.
 async function refreshAll (term, st, api = vc) {
@@ -1608,14 +1674,23 @@ export async function runTui () {
     while (running) {
       st.state = vc.readState()
       st.daemonUp = vc.daemonAlive()
+      // ¿Se cerró sola mientras nadie miraba? Olvida su contraseña y sal de su contenido.
+      await forgetAutoLocked(term, st)
       // caducar el flash a los ~4 s
       if (st.flash && Date.now() - st.flash.at > 4000) st.flash = null
       render(term, st)
 
-      const tick = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      const base = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      // Despertar a tiempo del bloqueo automático, además del sondeo de la pantalla.
+      const wake = autoLockWakeIn(st)
+      const tick = base && wake ? Math.min(base, wake) : (base || wake)
       const key = await term.readKey(tick)
 
       if (key.name === 'resize') continue
+      // Un despertar del bloqueo automático no es una tecla: ya se atendió arriba, y las
+      // pantallas que NO esperan `tick` (todas menos aparatos y emparejamiento) no tienen
+      // por qué verlo.
+      if (key.name === 'tick' && st.screen !== 'pairing' && st.screen !== 'devices') continue
       // input/confirm se AWAITan: serializa las ops contra el daemon (ver onInputKey).
       // Ctrl-C dentro de un modal lo CANCELA (no sale); fuera de un modal, sale.
       if (st.input) { await onInputKey(st, key); continue }
@@ -1664,4 +1739,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, activeLocked, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }
+export const __test = { render, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }

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}`,
@@ -124,6 +126,7 @@ const es = {
   vaultUnlocked: 'Bóveda desbloqueada',
   lockingVault: 'Bloqueando…',
   vaultLocked: 'Bóveda bloqueada',
+  autoLocked: (min) => `Se bloqueó sola tras ${min} min sin usarse · la contraseña se olvidó`,
 
   // dispositivos
   pendingDevice: (id) => ` ⧗ PENDIENTE: ${id}`,
@@ -341,13 +344,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}`,
@@ -418,6 +423,7 @@ const en = {
   vaultUnlocked: 'Vault unlocked',
   lockingVault: 'Locking…',
   vaultLocked: 'Vault locked',
+  autoLocked: (min) => `Locked itself after ${min} min idle · the password was forgotten`,
 
   pendingDevice: (id) => ` ⧗ PENDING: ${id}`,
   pendingHint: '  — press A to approve, X to reject',

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