@dotrino/vaultd 0.49.1 → 0.52.0

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}`,
@@ -230,7 +232,7 @@ const es = {
   pairAccount: (name, min) => `Cuenta que se comparte: ${name}  ·  válido ~${min} min`,
   pairScan: 'Escanéalo, o abre esta dirección en el dispositivo:',
   pairUrl: 'URL: ',
-  pairPaste: 'O pega este código en vault.dotrino.com/dispositivos:',
+  pairPaste: 'O pega este código en vault.dotrino.com/vault:',
   pairWarning: '⚠ Este código deja LEER tus datos y FIRMAR con tu identidad. No lo compartas.',
   pairConnected: (id) => `⧗ Se conectó: ${id} — pulsa A y escribe el código que muestra.`,
   pairWaiting: 'Esperando a que el dispositivo se conecte…',
@@ -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}`,
@@ -515,7 +519,7 @@ const en = {
   pairAccount: (name, min) => `Account being shared: ${name}  ·  valid ~${min} min`,
   pairScan: 'Scan it, or open this address on the device:',
   pairUrl: 'URL: ',
-  pairPaste: 'Or paste this code into vault.dotrino.com/dispositivos:',
+  pairPaste: 'Or paste this code into vault.dotrino.com/vault:',
   pairWarning: '⚠ This code lets someone READ your data and SIGN as you. Do not share it.',
   pairConnected: (id) => `⧗ Connected: ${id} — press A and type the code it shows.`,
   pairWaiting: 'Waiting for the device to connect…',

package/src/vault.js

@@ -23,7 +23,6 @@ import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar } from './secretsStore.js'
 import { createApprovals } from './approvals.js'
-import { parsePublicKey, sshSignature } from './sshKeys.js'
 import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { seal } from '../lib/src/sealed.js'
@@ -31,6 +30,13 @@ import { dataDir, ensureDir } from './paths.js'
 import { atRestFor, machineKey, migrateFile } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
 
+/**
+ * Tope de una respuesta de la bóveda por el transporte. El proxio (`PROXY_MAX_FRAME_BYTES`)
+ * corta el frame a 1 MB, y el sobre del proxio (destinatarios, tipos) va por encima de esto:
+ * se deja margen en vez de apurar el límite.
+ */
+const MAX_REPLY_BYTES = 768 * 1024
+
 /**
  * Abre UN perfil del vault (una maestra, un dir, una conexión al proxy). El
  * daemon multi-perfil (`manager.js`) levanta uno de estos por perfil.
@@ -72,7 +78,88 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const store = openStore(dir)
   const threads = openThreadStore(dir)
   const approvals = createApprovals()
-  const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit(g.kind === 'ssh' ? 'ssh.expired' : 'secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId }) }, 30 * 1000); approvalsSweeper.unref?.()
+
+  /**
+   * Pedidos de aprobación que NO son de un cajón de secretos: quien espera es una
+   * promesa dentro del vault (la bóveda de contraseñas), no un aparato aguardando un
+   * sobre sellado. `id` del pedido → `resolve(boolean)`.
+   *
+   * Aparte a propósito: `approvals` es un módulo puro y no tiene por qué saber que hay
+   * dos clases de espera.
+   */
+  const waiters = new Map()
+  // APARATOS QUE PIDEN APROBACIÓN: una lista de llaves en `approval.json` (cifrado en reposo
+  // como todo el dir). Es decisión de esta bóveda, no del acta: es ella la que entrega.
+  const approvalFile = path.join(dir, 'approval.json')
+  const approvalAtRest = atRestFor(dir)
+  const readSupervised = () => { try { const d = JSON.parse(approvalAtRest.decrypt(fs.readFileSync(approvalFile, 'utf8'))); return Array.isArray(d?.members) ? d.members : [] } catch (_) { return [] } }
+  const needsApproval = (pub) => readSupervised().includes(pub)
+  async function setApproval (pub, on) {
+    const cur = new Set(readSupervised())
+    if (on) cur.add(pub); else cur.delete(pub)
+    fs.writeFileSync(approvalFile, approvalAtRest.encrypt(JSON.stringify({ v: 1, members: [...cur] })), { mode: 0o600 })
+    audit('approval', { device: await deviceIdOf(pub).catch(() => null), on: !!on })
+    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 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 = () => {
+    try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
+  }
+  const writePasswordsFile = (d) => {
+    fs.writeFileSync(passwordsFile, passwordsAtRest.encrypt(JSON.stringify(d)), { mode: 0o600 })
+  }
+
+  /** El almacén que espera `@dotrino/passmanager`. Todo en un archivo, cifrado en reposo. */
+  const passwordsStore = {
+    async get (k) { return readPasswordsFile()?.data?.[k] },
+    async set (k, v) {
+      const d = readPasswordsFile() || { v: 1, data: {} }
+      d.data = { ...(d.data || {}), [k]: v }
+      writePasswordsFile(d)
+    },
+  }
+
+  /** 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é.
+   *
+   * `isAllowed`/`encPubOf` del responder son SÍNCRONOS (se llaman por cada mensaje que
+   * entra, y leer el acta ahí sería un await por mensaje), así que se refresca aparte.
+   * Se relee cada pocos segundos: revocar un aparato tarda eso en cortarle el acceso,
+   * no un reinicio.
+   */
+  let actaCache = null
+  const refreshActa = async () => {
+    try { actaCache = (await identity.profileActa?.().catch(() => null))?.acta || null } catch (_) {}
+    return actaCache
+  }
+
+  /**
+   * La llave de la bóveda de contraseñas. Nace con el primer uso y vive cifrada en
+   * reposo, como la identidad: aquí no hace falta envolverla a cada aparato porque
+   * ningún aparato abre la bóveda — piden de a una y el vault responde.
+   */
+  async function passwordsKey () {
+    const d = readPasswordsFile()
+    if (d?.cek) {
+      const raw = Uint8Array.from(Buffer.from(d.cek, 'base64'))
+      return crypto.subtle.importKey('raw', raw, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt'])
+    }
+    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') })
+    return key
+  }
+
+  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(),
     // A QUIÉN se le envuelve la llave de cada cajón: los servicios de ese namespace (o el
@@ -405,7 +492,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const devices = await Promise.all(issued.map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
     })))
-    reply(from, { type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain })
+    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain }))
+  }
+
+  /**
+   * NADA DE FRAMES QUE NO CABEN. El proxio corta a 1 MB y cierra la conexión con un 1009:
+   * la respuesta no llega, la bóveda reconecta y no queda ni una línea de log de su lado.
+   * Así estuvo muda tres días para todo el ecosistema (2026-08-24) mientras el bot social
+   * repetía «no tienes ningún node de contenido enrolado».
+   *
+   * La cadena de actas es lo único que puede crecer sin techo aquí —cada acta es un
+   * snapshot completo de los miembros—, así que se recorta por el FINAL: el tramo que sale
+   * sigue siendo contiguo desde el `seq` del que pregunta, que es lo que necesita para
+   * encadenar, y en la siguiente pregunta seguirá desde donde llegó.
+   */
+  function fitChain (msg) {
+    const size = (m) => JSON.stringify(m).length
+    if (size(msg) <= MAX_REPLY_BYTES) return msg
+    const full = msg.chain?.length || 0
+    while (msg.chain?.length && size(msg) > MAX_REPLY_BYTES) msg.chain = msg.chain.slice(0, -1)
+    if (!msg.chain?.length) msg.chain = null
+    const left = msg.chain?.length || 0
+    log(`[vault] record chain trimmed to fit the transport: ${left}/${full} link(s), ${size(msg)} bytes`)
+    if (size(msg) > MAX_REPLY_BYTES) log(`[vault] ⚠ the reply STILL does not fit (${size(msg)} bytes): the proxy will drop it`)
+    return msg
   }
 
   // RENOVACIÓN automática: un dispositivo con cert VIGENTE y no revocado pide un
@@ -489,8 +599,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // da acceso a nada por sí solo. Quien firma esta petición ya tiene la llave de firma
     // del servicio y su cert, o sea que ya lee ese namespace. No hay escalada.
     if (p.data?.op === 'enckey') return handleEncKey(from, p)
-    if (['approvals', 'approve', 'deny', 'ssh.keys', 'ssh.key.add', 'ssh.key.rm'].includes(p.data?.op)) return handleApproval(from, p)
-    if (p.data?.op === 'ssh.sign' || p.data?.op === 'ssh.keys.public') return handleSshRemote(from, p)
+    if (['approvals', 'approve', 'deny'].includes(p.data?.op)) return handleApproval(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
     if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: missing ek (requester ephemeral key)' })
@@ -507,10 +616,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'secrets', ns, reason: 'cn' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
-    // APROBACIÓN POR USO: si el cajón la exige y este aparato no tiene la ventana abierta,
-    // el pedido se apunta, se avisa a quien aprueba y se contesta «pendiente». La respuesta
-    // de verdad sale cuando el teléfono firme (`handleApproval`), sellada a la misma `ek`.
-    if (secrets.policyOf(ns).approval && !approvals.has(ns, chk.device)) {
+    // APROBACIÓN: si este APARATO está marcado (`dotrino-vault approval <ID> on`), liberarle
+    // claves privadas exige el visto bueno de un aparato con `approve` — en CADA petición,
+    // que para un servicio bien hecho es una por arranque: pide al (re)iniciar, se queda las
+    // claves en memoria y no vuelve a pedir. El pedido se apunta, se avisa a quien aprueba y se
+    // contesta «pendiente»; la respuesta de verdad sale cuando el teléfono firme
+    // (`handleApproval`), sellada a la misma `ek`.
+    if (needsApproval(chk.device)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
       const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
@@ -551,68 +663,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return { body, signature }
   }
 
-  // ---------- LLAVES SSH DEL TELÉFONO (`sshKeys.js`) ----------
-  // Aquí solo viven las PÚBLICAS: la privada está en el aparato que aprueba. `ssh` en este
-  // PC habla con el agente del daemon (`sshAgent.js`), y cada firma es un pedido más.
-  const sshKeysFile = path.join(dir, 'ssh-keys.json')
-  const atRest = atRestFor(dir)
-  const readSshKeys = () => { const d = readJsonAt(sshKeysFile); return Array.isArray(d?.keys) ? d.keys : [] }
-  function readJsonAt (file) { try { return JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8'))) } catch (_) { return null } }
-  const writeSshKeys = (keys) => fs.writeFileSync(sshKeysFile, atRest.encrypt(JSON.stringify({ v: 1, keys })), { mode: 0o600 })
-  const sshKeys = () => readSshKeys().map((k) => ({ id: k.id, type: k.type, blob: k.blob, comment: k.comment, deviceId: k.deviceId, addedAt: k.addedAt }))
-
   /**
-   * FIRMAR UN RETO SSH: lo pide el agente local (el `ssh` del usuario) y lo resuelve el
-   * teléfono. No hay ventana: cada conexión es un «sí» — para no repetirlo veinte veces
-   * está `ControlMaster` en el `ssh_config`, que reusa la conexión 15 min.
-   */
-  function requestSshSign ({ keyId, data, askedBy = null, onPending = null }) {
-    const key = readSshKeys().find((k) => k.id === keyId)
-    if (!key) return Promise.reject(new Error('ssh: unknown key'))
-    return new Promise((resolve, reject) => {
-      const pend = approvals.request({
-        kind: 'ssh', ns: 'ssh', deviceId: askedBy || (fp.slice(0, 4).toUpperCase() + '-' + fp.slice(4, 8).toUpperCase()), label: 'ssh',
-        ssh: { key: key.id, comment: key.comment, data: Buffer.from(data).toString('base64') },
-        resolve, reject
-      })
-      try { onPending?.(pend) } catch (_) {}
-      audit('ssh.pending', { key: key.id, id: pend.id, device: askedBy || null })
-      log(`[vault] ssh: ${key.comment || key.id} is waiting for the phone to sign (${pend.id})`)
-      identity.profileActa?.().catch(() => null).then((r) => notifyApprovers(pend, r?.acta))
-    })
-  }
-
-  /**
-   * AGENTE SSH DELGADO en otra máquina (`dotrino-env ssh-agent`): un aparato con `vault:sign`
-   * pide que un reto se firme con una llave del teléfono. No hay nada que proteger en el
-   * que pide: solo convierte el reto en un pedido; quien firma es el teléfono.
-   */
-  async function handleSshRemote (from, p) {
-    const chk = await verifyChain({
-      data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: SCOPE.SIGN, trustedIssuer: master, revoked: await revocationSet()
-    })
-    if (!chk.ok) return denyChain(from, chk, p, 'ssh')
-    const answer = async (body) => {
-      body = { ...body, ts: Date.now() }
-      const { signature } = await identity.signData(body)
-      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
-    }
-    if (p.data.op === 'ssh.keys.public') return answer({ op: 'ssh.keys.public', items: sshKeys().map((k) => ({ id: k.id, blob: k.blob, comment: k.comment })) })
-    const key = readSshKeys().find((k) => k.id === p.data.key)
-    if (!key || typeof p.data.data !== 'string') return reply(from, { type: MSG.ERROR, error: 'ssh: unknown key' })
-    const asker = await deviceIdOf(chk.device).catch(() => null)
-    let pendId = null
-    const done = requestSshSign({ keyId: key.id, data: Buffer.from(p.data.data, 'base64'), askedBy: asker, onPending: (pend) => { pendId = pend.id } })
-    await answer({ op: 'ssh.pending', id: pendId, exp: Date.now() + 5 * 60 * 1000 })
-    try {
-      const sig = await done
-      await answer({ op: 'ssh.sign.result', sig: Buffer.from(sig).toString('base64') })
-    } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
-  }
-
-  /**
-   * PEDIDOS DE APROBACIÓN (cajones con `approval`). Entran por `vault.secrets` con
+   * PEDIDOS DE APROBACIÓN (aparatos marcados con `approval on`). Entran por `vault.secrets` con
    * `op: approvals | approve | deny`, firmados por un aparato con `vault:approve` — que,
    * como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`). El acta tiene
    * que decirlo también, para que quitar el permiso surta efecto en el acto.
@@ -636,44 +688,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       reply(from, { type: MSG.SECRETS_RESULT, body, signature })
     }
     if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
-    if (op === 'ssh.keys') return answer({ op: 'ssh.keys', items: sshKeys() })
-    if (op === 'ssh.key.add') {
-      let k
-      try { k = parsePublicKey(p.data?.pub) } catch (e) { return reply(from, { type: MSG.ERROR, error: e.message }) }
-      const keys = readSshKeys().filter((x) => x.id !== k.id)
-      keys.push({ ...k, deviceId: by, addedAt: Date.now() })
-      writeSshKeys(keys)
-      audit('ssh.key.add', { key: k.id, by })
-      log(`[vault] ssh: key ${k.id} (${k.comment || 'no comment'}) registered by ${by}`)
-      return answer({ op: 'ssh.key.add', id: k.id, ok: true })
-    }
-    if (op === 'ssh.key.rm') {
-      const keys = readSshKeys(); const n = keys.length
-      writeSshKeys(keys.filter((x) => x.id !== p.data?.id))
-      if (keys.length !== n) audit('ssh.key.rm', { key: p.data?.id, by })
-      return answer({ op: 'ssh.key.rm', ok: true })
-    }
     const id = typeof p.data?.id === 'string' ? p.data.id : ''
     const pend = approvals.take(id)
     if (!pend) return reply(from, { type: MSG.ERROR, error: 'approval: unknown or expired request' })
-    if (pend.kind === 'ssh') {
-      if (op === 'deny') {
-        audit('ssh.denied', { key: pend.ssh.key, id, by })
-        try { pend.reject?.(new Error('ssh: denied from ' + by)) } catch (_) {}
-        return answer({ op: 'deny.result', id, ok: true })
-      }
-      if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
-      const key = readSshKeys().find((k) => k.id === pend.ssh.key)
-      let blob
-      try { blob = sshSignature({ jwk: key.jwk, data: Buffer.from(pend.ssh.data, 'base64'), rawSig: p.data?.sig }) } catch (e) {
-        try { pend.reject?.(e) } catch (_) {}
-        audit('rejected', { what: 'ssh.sign', reason: e.message })
-        return reply(from, { type: MSG.ERROR, error: e.message })
-      }
-      audit('ssh.signed', { key: key.id, id, by })
-      log(`[vault] ssh: ${key.comment || key.id} signed by ${by}`)
-      try { pend.resolve?.(blob) } catch (_) {}
-      return answer({ op: 'approve.result', id, ok: true })
+    // 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.
+    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)
+      return answer({ op: `${op}.result`, id, ok: true })
     }
     if (op === 'deny') {
       audit('secrets.denied', { device: pend.deviceId, ns: pend.ns, id, by })
@@ -682,16 +710,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return answer({ op: 'deny.result', id, ok: true })
     }
     if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
-    const exp = approvals.grant(pend.ns, pend.device)
     let res
     try { res = await resultFor(pend.ns, pend.device, pend.ek, record) } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'approval: could not seal the reply: ' + e.message })
     }
-    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by, until: exp })
-    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by} (window until ${new Date(exp).toISOString()})`)
+    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by })
+    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by}`)
     // Va por `sendByPubkey`: si el que pedía ya no está conectado, lo recoge al volver.
     try { client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res }) } catch (_) {}
-    return answer({ op: 'approve.result', id, ok: true, exp })
+    return answer({ op: 'approve.result', id, ok: true })
   }
 
   /** Aviso a los aparatos que aprueban (cola del proxio → push nativo si están apagados). */
@@ -726,6 +753,101 @@ 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 cuando el acta autoriza a alguien — sin eso no hay a quién
+  // responder, y crear la llave por si acaso sería crear un secreto que nadie pidió.
+  //
+  // Y se levanta EN CUANTO pasa, no en el siguiente arranque: conceder el permiso ya es
+  // un acto explícito del dueño, y pedirle además que reinicie la bóveda es de las cosas
+  // que se olvidan y luego parecen un fallo del gestor.
+  let passwords = null
+  /**
+   * EL SELLADO del gestor: la misma cripto de los sobres del ecosistema
+   * (`@dotrino/identity/content`), atada a la llave de cifrado de esta bóveda.
+   *
+   * 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)
+  }
+
   log(`[vault] listo · id ${fp} · ${store.getTree().children.length} nodos`)
 
   // ----- API local (CLI/UI de control) -----
@@ -1618,12 +1740,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
     // Cajones con aprobación por uso (`approvals.js`).
-    secretPolicy: (ns) => secrets.policyOf(ns),
-    setSecretPolicy: async (ns, patch) => { const r = secrets.setPolicy(ns, patch); audit('secret.policy', { ns, ...r }); return r },
-    secretPolicies: () => secrets.policies(),
+    // Aparatos que piden aprobación al recibir claves (`approvals.js`).
+    needsApproval,
+    setApproval,
+    supervised: () => readSupervised(),
+    // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
+    // llave. Lo que no puede es listarla un aparato.
+    passwordDevices,
+    passwordsVault: () => passwords?.vault || null,
     listApprovals: () => approvals.list(),
-    sshKeys,
-    requestSshSign,
     // Aprobar desde el PC avisa igual que aprobar a distancia: el resto de tus
     // dispositivos se entera de que entró alguien, venga de donde venga.
     approveDevice: async (code, adminKey) => {