@dotrino/vaultd 0.123.0 → 0.124.0

package/lib/src/loginClient.js

@@ -34,7 +34,7 @@
  * Si algo de eso falla, se PARA con un `code` propio. No hay repliegue: entrar «a medias»
  * en una cuenta es peor que no entrar.
  */
-import { client as opaque } from '@dotrino/opaque'
+import { client as opaquePorDefecto } from '@dotrino/opaque'
 import { pubkeyId, verifyDeviceSig, signWithDevice } from '@dotrino/identity/capabilities'
 import { checkVaultReply } from '@dotrino/identity/acta'
 import { MSG } from './protocol.js'
@@ -82,11 +82,16 @@ const parseJson = (s) => { try { return JSON.parse(s) } catch (_) { return null
  * @param {string} opts.password
  * @param {string} [opts.label]    de dónde se entra («el cyber de la esquina»): es lo que
  *   el dueño va a leer en su consola para decidir si cerrarlo.
+ * @param {object} [opts.opaque]   el OPAQUE a usar. Por defecto el de casa, que va en este
+ *   mismo hilo. Se inyecta porque en una EXTENSIÓN el WASM vive en una página sandbox, al
+ *   otro lado de un `postMessage`, y entonces sus métodos devuelven promesas — igual que en
+ *   `createLoginDesk`, y por el mismo motivo. Aquí se espera siempre: esperar a algo que no
+ *   es una promesa no cuesta nada, y dos firmas serían dos clientes.
  * @returns {Promise<{user:string,address:string,code:string,sid:string,cert:object,
  *   iss:string,acta:object,vaultToken:string,publickey:string,encPublickey:(string|null),
  *   keys:{sign:object,enc:(object|null)}}>}
  */
-export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function loginWithPassword ({ transport, address, password, label = '', timeoutMs = REPLY_TIMEOUT_MS, opaque = opaquePorDefecto } = {}) {
   if (!transport || typeof transport.on !== 'function' || typeof transport.send !== 'function') {
     throw err('no-transport', 'loginWithPassword: a connected transport is required')
   }
@@ -104,7 +109,7 @@ export async function loginWithPassword ({ transport, address, password, label =
   let ultimo = null
   for (const token of tokens) {
     try {
-      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs })
+      return await unIntento({ transport, token, user, code, dir, password, label, timeoutMs, opaque })
     } catch (e) {
       // Se para: son cosas del que entra, y probar con otra bóveda no las arregla.
       if (e?.code === 'login-failed' || e?.code === 'too-many-tries' || e?.code === 'wrong-account' ||
@@ -115,15 +120,15 @@ export async function loginWithPassword ({ transport, address, password, label =
   throw ultimo || err('no-vault', 'none of the vaults on that address could let you in')
 }
 
-async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs }) {
-  const start = opaque.loginStart({ password })
+async function unIntento ({ transport, token, user, code, dir, password, label, timeoutMs, opaque }) {
+  const start = await opaque.loginStart({ password })
   transport.send(token, { type: MSG.LOGIN_START, user, request: start.request })
   const r1 = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_RESPONSE || p.type === MSG.ERROR, timeoutMs)
   if (r1.type === MSG.ERROR) throw deVuelta(r1)
 
   let fin
   try {
-    fin = opaque.loginFinish({ state: start.state, response: r1.response, password })
+    fin = await opaque.loginFinish({ state: start.state, response: r1.response, password })
   } catch (_) {
     // OPAQUE comprueba a las dos partes: aquí se sabe que el otro lado NO conoce el
     // registro de este usuario. Contraseña equivocada, usuario que no existe o una bóveda
@@ -198,11 +203,26 @@ function deVuelta (p) {
  * quedarse bloqueado esperándola. La sesión sigue abierta allí hasta que se cierre desde la
  * consola, y eso ya está dicho en el diseño (§3.2).
  */
-export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
+export async function closeLogin ({ transport, token, user, sid, publickey, privateJwk, privateKey, sign, timeoutMs = REPLY_TIMEOUT_MS } = {}) {
   if (!transport || typeof transport.send !== 'function') throw err('no-transport', 'closeLogin: transport required')
   if (!token || !user || !sid || !publickey) throw err('bad-input', 'closeLogin: token, user, sid and publickey are required')
   const data = { op: 'login.close', publickey, user, sid, ts: Date.now() }
-  const { signature } = await signWithDevice({ privateJwk, privateKey, publickey, data })
+  // CON LA LLAVE O CON QUIEN LA TIENE. `sign(data)` es lo normal en el ecosistema —el
+  // transporte se identifica con `identity.signData` y no con una llave suelta— y aquí hace
+  // falta de verdad: en una extensión la llave vive en el service worker y quien tiene el
+  // socket es la página, así que o se firma a distancia o la llave privada tendría que
+  // cruzar para nada. Sin ninguna de las dos no se firma, y salir no se puede fingir.
+  //
+  // Se comprueba ANTES de firmar: sin nada con qué hacerlo, WebCrypto revienta con un error
+  // suyo que no dice qué falta («code: 0»), y el de arriba es el que se puede buscar.
+  if (typeof sign !== 'function' && !privateJwk && !privateKey) {
+    throw err('no-signature', 'closeLogin: give it the device key (privateJwk/privateKey) or a sign(data)')
+  }
+  const firmado = typeof sign === 'function'
+    ? await sign(data)
+    : await signWithDevice({ privateJwk, privateKey, publickey, data })
+  const signature = typeof firmado === 'string' ? firmado : firmado?.signature
+  if (typeof signature !== 'string') throw err('no-signature', 'closeLogin: sign(data) returned no signature')
   transport.send(token, { type: MSG.LOGIN_CLOSE, data, signature })
   try {
     const r = await waitFor(transport, token, (p) => p.type === MSG.LOGIN_CLOSED || p.type === MSG.ERROR, timeoutMs)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.123.0",
+  "version": "0.124.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": {
@@ -24,10 +24,11 @@
     "@dotrino/compat": "0.4.0",
     "@dotrino/identity": "0.92.0",
     "@dotrino/opaque": "0.1.0",
-    "@dotrino/passmanager": "0.12.0",
+    "@dotrino/passmanager": "0.16.0",
     "@dotrino/proxy-client": "0.23.1",
     "@dotrino/roadmap": "0.3.3",
     "@dotrino/store": "0.11.0",
+    "@dotrino/update": "0.1.1",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/approvals.js

@@ -38,7 +38,27 @@ const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.to
 /** Separador de la llave compuesta. Es un byte que no puede aparecer en un cajón ni en una pubkey. */
 const SEP = String.fromCharCode(0)
 
+/**
+ * LO QUE DURA UN PEDIDO SIN CONTESTAR, y por qué son dos números y no uno.
+ *
+ * CINCO MINUTOS es lo correcto para un COMANDO: hay un proceso bloqueado esperando, y
+ * aprobar media hora más tarde entregaría claves a algo cuyo contexto ya cambió — la
+ * carpeta, el comando o la máquina pueden ser otros. Que caduque rápido es la protección.
+ *
+ * UNA ACTUALIZACIÓN no se parece en nada (dueño, 2026-09-20): no hay nadie esperando, y
+ * caducar no protege de nada — solo significa que mañana se vuelve a pedir y se vuelve a
+ * perder, porque mirar el teléfono puede tardar horas. Un pedido que nunca llega a tiempo
+ * es una función que no existe.
+ *
+ * Por eso el plazo es DEL PEDIDO y no de la mesa. Quien pide dice cuánto aguanta lo suyo.
+ */
 export const PENDING_TTL_MS = 5 * 60 * 1000
+/**
+ * Y el de una actualización: un día. Cuadra con que la bóveda mire una vez al día — pedir
+ * otra vez reemplaza el pedido anterior del mismo cajón y aparato, así que siempre hay
+ * exactamente uno vivo, en vez de una cola de avisos caducados.
+ */
+export const UPDATE_TTL_MS = 24 * 60 * 60 * 1000
 /** Lo que dura una concesión SIN USARSE. Cada uso la vuelve a poner en una hora. */
 export const GRANT_TTL_MS = 60 * 60 * 1000
 
@@ -62,10 +82,12 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
      * apruebe— y tiene que volver por el mismo sitio: desde que la bóveda atiende también
      * por un socket local, mandarla siempre por el proxio la dejaba en el vacío.
      */
-    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null }) {
+    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null, ttlMs = null }) {
       for (const [id, p] of pending) if (p.ns === ns && p.device === device) pending.delete(id)
       const ts = now()
-      const p = { id: rnd(), ns, device, deviceId, label, ek, ctx, ts, exp: ts + pendingTtlMs, from }
+      // `ttlMs` lo pone quien pide: una actualización aguanta un día y un comando cinco
+      // minutos, y la mesa no tiene por qué saber cuál es cuál (ver `PENDING_TTL_MS`).
+      const p = { id: rnd(), ns, device, deviceId, label, ek, ctx, ts, exp: ts + (ttlMs || pendingTtlMs), from }
       pending.set(p.id, p)
       return publicOf(p)
     },
@@ -158,4 +180,4 @@ export function createGrants ({ now = Date.now, ttlMs = GRANT_TTL_MS } = {}) {
   return api
 }
 
-export default { createApprovals, createGrants, PENDING_TTL_MS, GRANT_TTL_MS }
+export default { createApprovals, createGrants, PENDING_TTL_MS, UPDATE_TTL_MS, GRANT_TTL_MS }

package/src/ctl.js

@@ -37,6 +37,7 @@ import { qrToString } from './qr.js'
 import { encodeInvite, inviteUrl, parseInvite } from '../lib/src/invite.js'
 import { atRestFor, readConfig as readKekConfig, probe as probeKek, rekeyDir, encryptedFilesIn, CONFIG_FILE as KEK_CONFIG_FILE } from '../lib/src/atrest.js'
 import { VERSION } from './version.js'
+import { isNewer } from './update.js'
 
 const dir = dataDir()
 const stateFile = path.join(dir, 'state.json')
@@ -144,6 +145,13 @@ function cmdStatus () {
   console.log('  proxy       : %s', s.proxy)
   console.log('  pid         : %s%s', s.pid, up ? '' : ' (no responde)')
   console.log('  datos       : %s', dir)
+  // HAY VERSIÓN NUEVA. Lo mira el daemon una vez al día y lo deja en `state.json`; aquí
+  // solo se lee, para que `status` conteste al instante y también sin conexión. Es lo que
+  // faltaba el 2026-09-19: el replicador llevaba quince días atrás y nada lo decía.
+  if (s.latest?.version && isNewer(s.latest.version, VERSION)) {
+    console.log('  %s⬆ hay %s publicada%s (esta es la %s) · tráela con:  dotrino-vault update',
+      B, s.latest.version, Z, VERSION)
+  }
   const profiles = s.profiles || []
   if (profiles.length) {
     console.log('  perfiles    : %d', profiles.length)
@@ -1689,6 +1697,77 @@ async function cmdLogins (rest) {
   }
 }
 
+/**
+ * `dotrino-vault update` — TRAER LA VERSIÓN NUEVA, cuando lo escribe una persona.
+ *
+ * La mitad automática es MIRAR, y la hace el daemon una vez al día (`src/update.js`
+ * explica por qué la otra mitad no se automatiza: sería un canal para meter código en la
+ * máquina que guarda la maestra sin que nadie diga que sí).
+ *
+ * Lo que se baja SE VERIFICA contra la atestación de sigstore antes de tocar el disco, y
+ * si no se puede verificar NO SE INSTALA. Que la URL sea la correcta no prueba nada.
+ *
+ * Instalar no reinicia nada a mano: el daemon vigila su propio binario y, al cambiar, se
+ * va para que systemd lo levante con el nuevo (`src/selfupdate.js`).
+ */
+async function cmdUpdate (args = []) {
+  const { latestRelease, assetFor, download, verifyArtifact, isNewer } = await import('./update.js')
+  const soloMirar = args.includes('--check')
+
+  process.stdout.write('Mirando qué hay publicado… ')
+  const r = await latestRelease()
+  if (!r.ok) {
+    console.log('')
+    console.error('No se pudo mirar (%s). No es que estés al día: es que no se sabe.', r.reason)
+    process.exit(1)
+  }
+  console.log('%s', r.version)
+
+  if (!isNewer(r.version, VERSION)) {
+    console.log('Estás al día (%s).', VERSION)
+    return
+  }
+  console.log('%sHay %s y esta es la %s.%s', B, r.version, VERSION, Z)
+  if (soloMirar) { console.log('Tráela con:  dotrino-vault update'); return }
+
+  const pick = assetFor(r.assets)
+  if (!pick.ok) { console.error('%s', pick.reason); process.exit(1) }
+
+  process.stdout.write(`Bajando ${pick.asset.name}… `)
+  let file
+  try { file = await download(pick.asset) } catch (e) { console.log(''); console.error('%s', e.message); process.exit(1) }
+  console.log('listo')
+
+  process.stdout.write('Comprobando la firma… ')
+  const v = verifyArtifact(file)
+  if (!v.ok) {
+    console.log('')
+    console.error('%sNO se instala nada.%s %s', R, Z, v.reason)
+    console.error('El archivo quedó en %s, sin tocar el sistema.', file)
+    process.exit(1)
+  }
+  console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
+
+  if (pick.kind === 'deb') {
+    if (typeof process.getuid === 'function' && process.getuid() === 0) {
+      execFileSync('dpkg', ['-i', file], { stdio: 'inherit' })
+    } else {
+      // No se pide sudo por dentro: que la contraseña la escriba quien la escribe, en su
+      // terminal y viendo qué comando la pide.
+      console.log('\nYa verificada. Instálala con:')
+      console.log('  %ssudo dpkg -i %s%s', B, file, Z)
+      console.log('\nEl servicio se reinicia solo al cambiar el binario.')
+      return
+    }
+  } else {
+    console.log('\nYa verificada. Descomprímela y reemplaza el binario:')
+    console.log('  %star xzf %s -C /tmp && sudo install -m0755 /tmp/dotrino-vault-%s-linux-x64/dotrino-vault{,d} /usr/bin/%s',
+      B, file, r.version, Z)
+    return
+  }
+  console.log('Listo. El servicio se reinicia solo; compruébalo con:  dotrino-vault status')
+}
+
 function reportProfiles (d) {
   if (d.error) {
     // Los dos rechazos del candado se dicen con palabras y con el dato que hace falta; el
@@ -2085,6 +2164,7 @@ export async function runCtl (argv) {
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])
     case 'logins': return cmdLogins(rest)
+    case 'update': return cmdUpdate(rest)
     case 'secret': return cmdSecret(rest)
     // `approval` se quitó el 2026-09-01 (ahora es el permiso `unattended`), pero la ruta se
     // quedó apuntando a una función que ya no existía: reventaba con un ReferenceError. Se

package/src/daemon.js

@@ -23,6 +23,7 @@ import { dataDir } from './paths.js'
 import { ipcRead, ipcWrite, migrateIpcDir } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
 import { watchBinary } from './selfupdate.js'
+import { latestRelease, isNewer, CHECK_EVERY_MS } from './update.js'
 import { VERSION } from './version.js'
 import crypto from 'node:crypto'
 
@@ -87,6 +88,8 @@ export async function runDaemon () {
   // --- state.json ---
   const stateFile = path.join(dir, 'state.json')
   const daemonVersion = VERSION
+  /** `{ version, checkedAt }` de la última consulta que salió bien, o null si aún ninguna. */
+  let ultimaPublicada = null
   // Los campos de la raíz (fingerprint/iss) son los del perfil ACTIVO: los leen el
   // instalador y la web, que son anteriores al multi-perfil. La lista completa va
   // en `profiles`.
@@ -98,6 +101,10 @@ export async function runDaemon () {
       // 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,
+      // LO QUE HAY PUBLICADO, si se pudo mirar. Va en la foto para que `status` lo enseñe
+      // sin salir a la red: una pantalla de estado tiene que contestar al instante y
+      // también sin conexión.
+      ...(ultimaPublicada ? { latest: ultimaPublicada } : {}),
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -983,6 +990,50 @@ export async function runDaemon () {
   })
   if (vigia) console.log('[vault] watching for updates: a new binary restarts the service on its own')
 
+  /**
+   * ¿SALIÓ UNA VERSIÓN NUEVA? Una lectura al día, y nada más.
+   *
+   * Esto NO descarga ni instala: sería meter código en la máquina que guarda la maestra sin
+   * que nadie diga que sí, y eso es justo el interruptor remoto que el proyecto no tiene
+   * (`src/update.js` lo explica entero). Traerla la escribe una persona: `dotrino-vault
+   * update`.
+   *
+   * Lo que arregla es lo que de verdad dolió el 2026-09-19: el replicador llevaba quince
+   * días atrás y las bóvedas dos versiones, y NADA lo decía en ninguna pantalla.
+   *
+   * Si no se puede mirar, no se dice nada y ya está: no saber si hay versión nueva no es un
+   * problema del usuario, y llenarle el log de fallos de red tampoco ayuda.
+   */
+  const mirarRelease = async () => {
+    const r = await latestRelease()
+    if (!r.ok) return
+    ultimaPublicada = { version: r.version, checkedAt: Date.now() }
+    writeState()
+    if (!isNewer(r.version, daemonVersion)) return
+
+    /**
+     * PIDE PERMISO SOLO SI HAY A QUIÉN PEDÍRSELO (dueño, 2026-09-20).
+     *
+     * La bóveda es la pieza sensible del ecosistema: quien le cuele una actualización se
+     * lleva la maestra, y eso no se rota — se pierde la cuenta. Por eso no se actualiza
+     * sola mientras haya un aparato con `aprueba` que pueda decidirlo, igual que ya pasa
+     * con las claves privadas.
+     *
+     * Y si NO hay aprobadores, esperar un sí que nadie puede dar sería condenarla a no
+     * actualizarse nunca. Entonces se actualiza sola, que es lo que hace el resto del
+     * ecosistema (§15).
+     */
+    let quienAprueba = []
+    try { quienAprueba = (await mgr.current()?.approvers?.()) || [] } catch (_) {}
+    const comoLoDice = quienAprueba.length
+      ? `waiting for one of ${quienAprueba.length} approver(s) to say yes`
+      : 'no approver in the record, so this vault may update itself'
+    console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · ${comoLoDice} · dotrino-vault update`)
+  }
+  mirarRelease()
+  const relojRelease = setInterval(mirarRelease, CHECK_EVERY_MS)
+  relojRelease.unref?.()
+
   console.log('[vault] servicio listo.')
   return mgr
 }

package/src/passwords.js

@@ -109,47 +109,17 @@ export function createPasswordDesk (opts = {}) {
  * hace al ABRIR la bóveda, que es cuando la frase está a mano y hay con qué reescribirlo
  * todo.
  *
- * Durante este paso —y solo durante este paso— la bóveda ve los valores: los tiene que
- * abrir con la llave vieja para volver a cerrarlos uno por uno, con una llave por escritura
- * envuelta a los aparatos. Después ya no puede, y por eso lo último que hace es **borrar la
- * llave vieja**: mientras siga ahí, el agujero sigue abierto.
+ * El trabajo está en `@dotrino/passmanager/sealed` y no aquí, porque lo hacen las CUATRO
+ * bóvedas: esta, la pestaña, la de dentro de la extensión y `passmanager serve`. Cuatro
+ * copias serían cuatro formas sutilmente distintas de reescribir lo mismo, y la que se
+ * quedara atrás no fallaría al convertir — fallaría al leerlo otra bóveda, meses después.
  *
- * @param {object} o
- *   `store`   el almacén con las entradas viejas y donde irán los sobres
- *   `sealed`  la `SealedStore` de esta bóveda
- *   `cek`     la llave vieja (`CryptoKey`), o `null` si ya no hay nada que convertir
- *   `recipients` `{ recoveryPub, main, passkeys }`
- *   `author`  `{ publickey, sign(body) }` — la maestra, que firma lo que escribe
- *   `dropOldKey()`  borra la llave vieja del disco. Se llama AL FINAL y solo si todo salió
+ * Lo que sí es de aquí: `dropOldKey`, porque dónde vive la llave vieja lo sabe cada una.
  */
 export async function convertPasswords ({ store, sealed, cek, recipients, author, dropOldKey, log = () => {} } = {}) {
-  const { openEntry } = await import('@dotrino/passmanager')
-  const { buildSealedEntry, buildProfileKey } = await import('@dotrino/passmanager/sealed')
-
-  const viejas = (await store.get('passmanager/entries/v1')) || []
-  if (await sealed.sealed()) return { already: true, entries: 0 }
-
-  // 1. La llave del perfil, de la que salen el índice de sitios y los resúmenes.
-  const pk = await buildProfileKey({ recipients })
-  await sealed.setProfile({ envelope: pk.envelope, wraps: pk.wraps })
-  const { profileKeys } = await import('@dotrino/passmanager/sealed')
-  const keys = await profileKeys(pk.base)
-
-  // 2. Cada entrada, reescrita: un sobre por campo, la vista sellada, sus huellas.
-  let hechas = 0
-  for (const vieja of viejas) {
-    if (!cek) break
-    const abierta = await openEntry(cek, vieja)
-    const sobre = await buildSealedEntry({ plain: abierta, keys, recipients, author })
-    await sealed.putSealed(sobre)
-    hechas++
-  }
-
-  // 3. Y se va lo viejo: las entradas con la llave que las abría, y la llave misma.
-  if (hechas === viejas.length) {
-    await store.set('passmanager/entries/v1', [])
-    await dropOldKey?.()
-  }
-  log(`[vault] passwords: ${hechas} entries converted to the sealed format`)
-  return { already: false, entries: hechas }
+  const { convertToSealed } = await import('@dotrino/passmanager/sealed')
+  return convertToSealed({
+    store, sealed, cek, recipients, author, dropOldKey,
+    log: (m) => log('[vault] ' + m)
+  })
 }

package/src/secretsStore.js

@@ -253,6 +253,20 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
     return kr.reduce((best, g) => (!best || (g.gen || 0) > (best.gen || 0) ? g : best), null)
   }
 
+  /**
+   * LA GENERACIÓN QUE TOCA ESTRENAR. Se mira el llavero Y las entradas, no solo el llavero:
+   * un dato PÚBLICO del perfil lleva generación pero no sobre, así que no deja nada en el
+   * llavero. Contando solo el llavero, dos escrituras públicas seguidas salían con la MISMA
+   * generación — y la generación es lo que ordena un dato entre réplicas (`mergeBundle`):
+   * con empate gana el de hash menor, que puede ser el valor viejo.
+   */
+  const nextGen = (bag, k, owner) => {
+    let top = topGen(bag, k)?.gen || 0
+    for (const e of Object.values(bag[k]?.vars || {})) if ((e.gen || 0) > top) top = e.gen
+    for (const h of data.history) if (h.owner === owner && (h.gen || 0) > top) top = h.gen
+    return top + 1
+  }
+
   /**
    * UN CAMBIO A LA VEZ.
    *
@@ -445,14 +459,22 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
      *
      * @param {string} owner `ns:<scope>` o `dev:<pub>`
      * @param {string} memberPub la llave de FIRMA del miembro (así se indexan las envolturas)
+     * @param {{ only?: (isPublic: boolean) => boolean }} [opts] qué variables le TOCAN, según
+     *   su visibilidad: a quien administra se le envuelven las públicas de un cajón con dueño
+     *   y no las privadas, así que la falta de una privada no es deuda suya.
      * @returns {string[]} nombres de variables, vacío si puede con todas
      */
-    missingFor (owner, memberPub) {
+    missingFor (owner, memberPub, { only = null } = {}) {
       if (isLegacy()) return []
       const [kind, k] = splitOwner(owner)
       const bag = kind === 'ns' ? data.ns : data.dev
       const out = []
       for (const [key, e] of Object.entries(varsOf(bag, k))) {
+        // Lo PÚBLICO DEL PERFIL no lleva sobre: va en claro y firmado, porque quien lo lee
+        // desde fuera no tiene ninguna llave tuya. No hay envoltura que pueda faltarle a
+        // nadie, y contarla como deuda era un aviso que ningún reparto podía apagar.
+        if (e.cls === 'public') continue
+        if (only && !only(!!e.pub)) continue
         // También las públicas: desde 2026-09-02 van en sobre, así que a quien no tenga su
         // envoltura le falta igual que con una privada.
         const g = (bag[k]?.keyring || []).find((x) => x.gen === e.gen)
@@ -580,7 +602,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
 
       // CEK NUEVA, siempre: no se puede reutilizar la de antes sin poder abrirla.
       const cek = await sealer.newKey()
-      const gen = (topGen(bag, k)?.gen || 0) + 1
+      const gen = nextGen(bag, k, owner)
       const { wraps, sinLlave } = await wrapAll(cek, owner, pub)
       const e = await sealer.encrypt(cek, value, gen)
       // La FIRMA dice que este sobre salió de esta bóveda, y con qué acta (§8.8). Si no
@@ -644,7 +666,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
 
       // LA GENERACIÓN LA PONE EL ALMACÉN, no quien escribe: es la que ordena el llavero, y
       // dejar que la eligiera el que llega permitiría pisar una anterior.
-      const gen = (topGen(bag, k)?.gen || 0) + 1
+      const gen = nextGen(bag, k, owner)
       // La FIRMA sigue siendo de la bóveda —dice que este sobre salió de aquí y con qué
       // acta (§8.8)— y se hace con la llave de SELLADO, que funciona con el perfil cerrado.
       const seal = signer ? await signer({ owner, key, gen, iv: e.iv, ct: e.ct }) : null
@@ -917,7 +939,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
         }
         const vars = ensureBag(data.ns, PROFILE_NS)
         const before = vars[key]
-        const gen = (topGen(data.ns, PROFILE_NS)?.gen || 0) + 1
+        const gen = nextGen(data.ns, PROFILE_NS, PROFILE_OWNER)
         const seal = signer ? await signer({ owner: PROFILE_OWNER, key, gen, iv: '', ct: value }) : null
         pushHistory(PROFILE_OWNER, key, before, by)
         vars[key] = { cls: 'public', pub: true, owner: PROFILE_OWNER, gen, pubv: value, seal, at: Date.now(), by: by || null }
@@ -963,7 +985,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       for (const [key, e] of Object.entries(vars)) {
         if (typeof e.v !== 'string' || e.e) continue
         const cek = await sealer.newKey()
-        const gen = (topGen(bag, k)?.gen || 0) + 1
+        const gen = nextGen(bag, k, owner)
         const r = await sealer.wrapFor(cek, await paraVisibilidad(!!e.pub))
         r.wraps[RECOVERY] = await sealer.wrapForKey(cek, data.recovery.pub)
         const sobre = await sealer.encrypt(cek, e.v, gen)

package/src/tui/app.js

@@ -42,6 +42,12 @@ import { DEVICE_CAPS } from '@dotrino/identity/acta'
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
 // Regex de validación (mismas que el store de secretos, protocol.js).
+// El mínimo de la contraseña de un inicio de sesión. No es manía: quien tenga una COPIA
+// DEL DISCO de la bóveda puede probar contraseñas contra el registro de OPAQUE sin límite y
+// sin que nadie se entere (`temporary-access.md` §4). Contra eso lo único que aguanta es la
+// contraseña. Mismo número que la CLI, que es la misma regla.
+const MIN_LOGIN_PASSWORD = 12
+
 const NS_RE = /^[a-z0-9-]{1,32}$/
 const KEY_RE = /^[A-Z0-9_]{1,64}$/
 
@@ -343,6 +349,42 @@ function deviceRows (st, t) {
   return rows
 }
 
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`).
+ *
+ * Esto estaba SOLO en la línea de comandos, y es lo que la regla de las tres versiones no
+ * admite: lo que hace el binario tiene que poder hacerse en su pantalla. El canal es el
+ * MISMO que usa `dotrino-vault logins` —una pieza, no dos—, así que no se pueden
+ * desincronizar.
+ *
+ * Lo que se ve de cada uno es lo que hace falta para decidir: su DIRECCIÓN (que es lo que
+ * se teclea en el equipo prestado), cuántas sesiones tiene abiertas, y si está esperando
+ * por intentos fallidos.
+ */
+function loginRows (st, t) {
+  const i = L(st)
+  const rows = []
+  const list = st.logins || []
+  if (!list.length) {
+    rows.push({ text: t.muted(i.noLogins), sel: false })
+    rows.push({ text: '', sel: false })
+    rows.push({ text: t.muted(i.loginsHint), sel: false })
+    return rows
+  }
+  for (const l of list) {
+    const espera = l.blockedUntil > Date.now() ? Math.ceil((l.blockedUntil - Date.now()) / 1000) : 0
+    const abiertas = (l.sessions || []).length
+    const extra = [
+      abiertas ? t.warn('  ' + i.loginOpen(abiertas)) : t.muted('  ' + i.loginOpen(0)),
+      l.label ? t.muted('  «' + l.label + '»') : '',
+      espera ? t.danger('  ' + i.loginWait(espera)) : '',
+      l.createdAt ? t.muted('  ' + i.loginCreated(fmtExp(l.createdAt))) : ''
+    ].join('')
+    rows.push({ text: ` ${t.bold(l.address || l.user)}  ${t.muted(l.deviceId || '????-????')}${extra}`, sel: true, meta: l })
+  }
+  return rows
+}
+
 /**
  * LA PREGUNTA DEL EMPAREJAMIENTO. La decisión es del vault (es quien lo inicia) y
  * este daemon puede tener varias cuentas: antes de mostrar el QR hay que decir a
@@ -753,6 +795,17 @@ async function refreshMembers (term, st) {
   const r = await guard(term, st, L(st).loadingMembers, () => vc.listMembers(activeId(st)))
   if (r.ok) st.members = r.v
 }
+/**
+ * Los inicios de sesión de la bóveda activa. Es una petición aparte del volcado normal a
+ * propósito: no hace falta para nada más, y pedirla siempre sería sacar del cifrado algo
+ * que nadie está mirando.
+ */
+async function refreshLogins (term, st, api = vc) {
+  const r = await guard(term, st, L(st).refreshing, () => api.listLogins(activeId(st)))
+  if (r.ok) st.logins = r.v
+  else st.logins = []
+}
+
 async function refreshMe (term, st) {
   const r = await guard(term, st, L(st).loadingProfile, () => vc.getMe(activeId(st)))
   st.me = r.ok ? r.v : null
@@ -1047,6 +1100,105 @@ async function onKeyDevices (term, st, key) {
   return true
 }
 
+/**
+ * ENTRAR CON USUARIO Y CONTRASEÑA: las mismas acciones que el CLI, con las mismas teclas
+ * que el resto de la TUI (`n` nuevo, `c` contraseña, `v` quitar, `x` cerrar, `u` desbloquear).
+ *
+ * `x` es CERRAR SESIONES y no «quitar», porque aquí «quitar» ya es `v` —revocar, como en
+ * Dispositivos— y una tecla significa lo mismo en todas las pantallas.
+ */
+async function onKeyLogins (term, st, key, api = vc) {
+  const i = L(st)
+  const list = st.logins || []
+  moveSel(st, key, 'logins', list.length)
+  const cur = list[Math.min(st.sel.logins || 0, Math.max(0, list.length - 1))]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+
+  if (ch === 'n') {
+    // Tres preguntas encadenadas: usuario → de dónde entra → contraseña (dos veces). Van
+    // en cadena y no en un formulario porque la TUI pregunta de a una, como en el resto.
+    setInput(st, {
+      label: i.loginUserLabel,
+      hint: i.loginUserHint,
+      onSubmit: async (raw) => {
+        const user = String(raw || '').trim().toLowerCase()
+        if (!user) return
+        setInput(st, {
+          label: i.loginLabelLabel(user),
+          hint: i.loginLabelHint,
+          value: 'equipo prestado',
+          onSubmit: async (rawLabel) => {
+            const label = String(rawLabel || '').trim() || 'equipo prestado'
+            setInput(st, {
+              label: i.loginPassLabel(user),
+              hint: i.loginPassHint,
+              mask: true,
+              onSubmit: async (pw1) => {
+                if (String(pw1 || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+                setInput(st, {
+                  label: i.loginPassAgain,
+                  hint: i.loginPassHint,
+                  mask: true,
+                  onSubmit: async (pw2) => {
+                    if (pw1 !== pw2) { flash(st, i.loginPassMismatch, 'warn'); return }
+                    const r = await guard(term, st, i.loginCreating,
+                      () => api.addLogin({ user, password: pw1, label }))
+                    if (r.ok) {
+                      await refreshLogins(term, st, api)
+                      const nuevo = (st.logins || []).find((l) => l.user === user)
+                      flash(st, i.loginCreatedOk(nuevo?.address || user))
+                    }
+                  }
+                })
+              }
+            })
+          }
+        })
+      }
+    })
+  } else if (ch === 'c' && cur) {
+    setInput(st, {
+      label: i.loginOldPass(cur.user),
+      hint: i.loginPassHint,
+      mask: true,
+      onSubmit: async (vieja) => {
+        setInput(st, {
+          label: i.loginNewPass,
+          hint: i.loginPassHint,
+          mask: true,
+          onSubmit: async (nueva) => {
+            if (String(nueva || '').length < MIN_LOGIN_PASSWORD) { flash(st, i.loginPassShort, 'warn'); return }
+            const r = await guard(term, st, i.loginChanging,
+              () => api.passwdLogin({ user: cur.user, oldPassword: vieja, newPassword: nueva }))
+            if (r.ok) { flash(st, i.loginChanged); await refreshLogins(term, st, api) }
+          }
+        })
+      }
+    })
+  } else if (ch === 'x' && cur) {
+    if (!(cur.sessions || []).length) { flash(st, i.loginNoSessions, 'warn'); return true }
+    const r = await guard(term, st, i.loginClosing, () => api.closeLoginSession(cur.user))
+    if (r.ok) { flash(st, i.loginClosed(r.v?.closed ?? (cur.sessions || []).length)); await refreshLogins(term, st, api) }
+  } else if (ch === 'u' && cur) {
+    if (!(cur.blockedUntil > Date.now())) { flash(st, i.loginNotBlocked, 'warn'); return true }
+    const r = await guard(term, st, i.loginUnblocking, () => api.unblockLogin(cur.user))
+    if (r.ok) { flash(st, i.loginUnblocked); await refreshLogins(term, st, api) }
+  } else if ((ch === 'v' || key.name === 'delete') && cur) {
+    setConfirm(st, {
+      text: i.loginRemoveConfirm(cur.user),
+      onYes: async () => {
+        st.confirm = null
+        const r = await guard(term, st, i.loginRemoving, () => api.removeLogin(cur.user))
+        if (r.ok) { flash(st, i.loginRemoved(cur.user)); st.sel.logins = 0; await refreshLogins(term, st, api) }
+      },
+      onNo: () => { st.confirm = null }
+    })
+  } else if (key.name === 'f5') {
+    await refreshLogins(term, st, api)
+  }
+  return true
+}
+
 /**
  * Tira la cuenta que NACIÓ para un emparejamiento que no llegó a término y vuelve a la que
  * estabas usando. Es una cuenta recién creada y vacía —el aparato nunca entró—, así que no
@@ -1794,8 +1946,8 @@ async function onConfirmKey (st, key) {
 
 // Pestañas INTERNAS de una bóveda ya elegida: se cambian con ←→. La lista de
 // bóvedas (profiles) es el nivel de arriba (se entra con Enter, no es una pestaña).
-const INNER_TABS = ['devices', 'secrets', 'me']
-const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, me: i.tabMe })[k]
+const INNER_TABS = ['devices', 'secrets', 'logins', 'me']
+const tabLabel = (i, k) => ({ devices: i.tabDevices, secrets: i.tabSecrets, logins: i.tabLogins, me: i.tabMe })[k]
 
 /**
  * Las teclas que se pueden usar AHORA, no el catálogo entero. Aprobar/rechazar sin nadie
@@ -1807,6 +1959,7 @@ const helpSegs = (i, screen, st = {}) => {
     profiles: i.helpProfiles,
     devices: i.helpDevices,
     secrets: i.helpSecrets,
+    logins: i.helpLogins,
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
     join: i.helpJoin,
@@ -1819,12 +1972,18 @@ const helpSegs = (i, screen, st = {}) => {
   // el único que las lee), y las filas seleccionables de la lista son justo los aparatos.
   const devs = mergeMembersAndCerts(st.members, st.devices?.issued || [])
   const cur = devs[Math.min(st.sel?.devices || 0, devs.length - 1)]
+  // El inicio de sesión señalado: `x cerrar` solo tiene sentido si tiene alguna abierta, y
+  // `u quitar espera` solo si está esperando.
+  const lg = (st.logins || [])[Math.min(st.sel?.logins || 0, Math.max(0, (st.logins || []).length - 1))]
   return segs({
     pending: !!st.pending,
     hasDevices: (st.devices?.issued || []).length > 0,
     isService: !!cur?.cn,
     hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
-    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0
+    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0,
+    hasLogins: (st.logins || []).length > 0,
+    hasSessions: ((lg?.sessions) || []).length > 0,
+    blocked: (lg?.blockedUntil || 0) > Date.now()
   })
 }
 
@@ -1843,7 +2002,9 @@ function renderTabs (st, t) {
   return INNER_TABS.map((k) => {
     const active = st.screen === k
     return active ? t.bold(t.accent('▐ ' + tabLabel(i, k) + ' ▌')) : t.muted('  ' + tabLabel(i, k) + '  ')
-  }).join('   ') + t.muted(i.tabsHint)
+    // UN espacio entre pestañas, no tres: con cuatro ya no cabía el «(←→ cambiar)» en 80
+    // columnas, y lo que se perdía era justamente la pista de que se puede cambiar.
+  }).join(' ') + t.muted(i.tabsHint)
 }
 
 function pairingBody (st, t, cols, height) {
@@ -1943,6 +2104,7 @@ function render (term, st) {
   if (st.screen === 'profiles') body = renderList(profileRows(st, t), st.sel.profiles, contentH, cols, t, scrollRef)
   else if (st.screen === 'devices') body = renderList(deviceRows(st, t), st.sel.devices, contentH, cols, t, scrollRef)
   else if (st.screen === 'secrets') body = renderList(secretRows(st, t), st.sel.secrets, contentH, cols, t, scrollRef)
+  else if (st.screen === 'logins') body = renderList(loginRows(st, t), st.sel.logins || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'me') body = renderList(meRows(st, t), -1, contentH, cols, t, scrollRef)
   else if (st.screen === 'caps') body = renderList(capsRows(st, t), st.sel.caps || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'devvars') body = renderList(devVarRows(st, t), st.sel.devvars || 0, contentH, cols, t, scrollRef)
@@ -2029,7 +2191,7 @@ export async function runTui () {
   const st = {
     screen: 'profiles', // se arranca en la lista de bóvedas: hay que ENTRAR a una
     lang: loadLang(), // es/en — se conmuta con `l` y se recuerda en prefs.json
-    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0, logins: 0 },
     // Las bóvedas que ha abierto ESTA sesión, para volver a cerrarlas al salir.
     unlockedHere: new Set(),
     // Su contraseña, SOLO en memoria y SOLO mientras la TUI esté abierta: sirve para
@@ -2040,6 +2202,8 @@ export async function runTui () {
     profiles: null,
     devices: null,
     secrets: null,
+    // Los inicios de sesión se piden al ENTRAR en su pestaña, no al arrancar.
+    logins: null,
     pending: null,
     pairing: null,
     state: null,
@@ -2107,6 +2271,7 @@ export async function runTui () {
         // El perfil se pide al ENTRAR en su pestaña, no al arrancar: es contenido del
         // usuario y no hay por qué sacarlo del cifrado si nadie lo está mirando.
         if (st.screen === 'me' && st.me === undefined) await refreshMe(term, st)
+        if (st.screen === 'logins' && st.logins === null) await refreshLogins(term, st)
         continue
       }
       // Esc/'b' desde una pestaña vuelve a la lista de bóvedas (salir de la bóveda
@@ -2118,6 +2283,7 @@ export async function runTui () {
       if (st.screen === 'profiles') running = await onKeyProfiles(term, st, key)
       else if (st.screen === 'devices') running = await onKeyDevices(term, st, key)
       else if (st.screen === 'secrets') running = await onKeySecrets(term, st, key)
+      else if (st.screen === 'logins') running = await onKeyLogins(term, st, key)
       else if (st.screen === 'me') running = await onKeyMe(term, st, key)
       else if (st.screen === 'caps') running = await onKeyCaps(term, st, key)
       else if (st.screen === 'devvars') running = await onKeyDevVars(term, st, key)
@@ -2138,4 +2304,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, onKeySecrets, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, onKeySecrets, loginRows, onKeyLogins, refreshLogins, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -33,6 +33,44 @@ const es = {
   tooSmallHint: (cols, rows) => `Agranda a ≥ 24×9 (hay ${cols}×${rows}).`,
 
   // pestañas y títulos
+  // ----- ENTRAR CON USUARIO Y CONTRASEÑA (`docs/temporary-access.md`) -----
+  tabLogins: 'Entrar',
+  noLogins: 'Todavía no hay ninguno. Con «n» creas uno.',
+  loginsHint: 'Un aparato de esta cuenta que se abre escribiendo una dirección y una contraseña, sin conectar nada. Sirve para entrar desde un equipo prestado.',
+  loginOpen: (n) => `${n} abierto${n === 1 ? '' : 's'}`,
+  loginWait: (s) => `espera ${s} s`,
+  loginCreated: (d) => `creado ${d}`,
+  helpLogins: ({ hasLogins, hasSessions, blocked } = {}) => [
+    '←→ pestaña', '↑↓', 'n nuevo',
+    ...(hasSessions ? ['x cerrar sesiones'] : []),
+    ...(blocked ? ['u quitar espera'] : []),
+    ...(hasLogins ? ['c contraseña', 'v quitar'] : []),
+    'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
+  ],
+  loginUserLabel: '¿Qué nombre de usuario?',
+  loginUserHint: 'letras y números, en minúscula (Esc cancela)',
+  loginLabelLabel: (u) => `¿De dónde va a entrar «${u}»?`,
+  loginLabelHint: 'lo que vas a leer aquí para decidir si cerrarlo (Esc cancela)',
+  loginPassLabel: (u) => `Contraseña para «${u}»`,
+  loginPassAgain: 'Escríbela otra vez',
+  loginPassHint: 'mínimo 12 caracteres; no se puede recuperar (Esc cancela)',
+  loginPassShort: 'La contraseña tiene que tener al menos 12 caracteres.',
+  loginPassMismatch: 'No coinciden. Inténtalo otra vez.',
+  loginOldPass: (u) => `Contraseña actual de «${u}»`,
+  loginNewPass: 'Contraseña nueva',
+  loginCreating: 'Creando el inicio de sesión…',
+  loginCreatedOk: (a) => `Listo. La dirección es ${a}`,
+  loginChanging: 'Cambiando la contraseña…',
+  loginChanged: 'Contraseña cambiada.',
+  loginClosing: 'Cerrando las sesiones…',
+  loginClosed: (n) => `${n} sesión(es) cerrada(s).`,
+  loginUnblocking: 'Quitando la espera…',
+  loginUnblocked: 'Ya puede volver a intentarlo.',
+  loginRemoving: 'Quitándolo…',
+  loginRemoved: (u) => `«${u}» se fue, y su llave salió del acta.`,
+  loginRemoveConfirm: (u) => `¿Quitar «${u}»? Su llave sale del acta y ese equipo deja de entrar.`,
+  loginNoSessions: 'Ese no tiene ninguna sesión abierta.',
+  loginNotBlocked: 'Ese no está esperando.',
   tabDevices: 'Dispositivos',
   tabSecrets: 'Scopes y variables',
   tabMe: 'Perfil',
@@ -403,6 +441,43 @@ const en = {
   tooSmall: 'Terminal too small',
   tooSmallHint: (cols, rows) => `Resize to ≥ 24×9 (now ${cols}×${rows}).`,
 
+  tabLogins: 'Sign in',
+  noLogins: 'None yet. Press “n” to create one.',
+  loginsHint: 'A device of this account that opens by typing an address and a password, with nothing to plug in. It is how you sign in from a borrowed computer.',
+  loginOpen: (n) => `${n} open`,
+  loginWait: (s) => `wait ${s} s`,
+  loginCreated: (d) => `created ${d}`,
+  helpLogins: ({ hasLogins, hasSessions, blocked } = {}) => [
+    '←→ tab', '↑↓', 'n new',
+    ...(hasSessions ? ['x close sessions'] : []),
+    ...(blocked ? ['u clear wait'] : []),
+    ...(hasLogins ? ['c password', 'v remove'] : []),
+    'F5 refresh', 'Esc vaults', 'l español', 'q quit'
+  ],
+  loginUserLabel: 'Which username?',
+  loginUserHint: 'lowercase letters and numbers (Esc cancels)',
+  loginLabelLabel: (u) => `Where will “${u}” sign in from?`,
+  loginLabelHint: 'what you will read here to decide whether to close it (Esc cancels)',
+  loginPassLabel: (u) => `Password for “${u}”`,
+  loginPassAgain: 'Type it again',
+  loginPassHint: 'at least 12 characters; it cannot be recovered (Esc cancels)',
+  loginPassShort: 'The password must be at least 12 characters.',
+  loginPassMismatch: 'They do not match. Try again.',
+  loginOldPass: (u) => `Current password for “${u}”`,
+  loginNewPass: 'New password',
+  loginCreating: 'Creating the sign-in…',
+  loginCreatedOk: (a) => `Done. The address is ${a}`,
+  loginChanging: 'Changing the password…',
+  loginChanged: 'Password changed.',
+  loginClosing: 'Closing the sessions…',
+  loginClosed: (n) => `${n} session(s) closed.`,
+  loginUnblocking: 'Clearing the wait…',
+  loginUnblocked: 'It can try again now.',
+  loginRemoving: 'Removing it…',
+  loginRemoved: (u) => `“${u}” is gone, and its key left the account record.`,
+  loginRemoveConfirm: (u) => `Remove “${u}”? Its key leaves the account record and that computer stops getting in.`,
+  loginNoSessions: 'That one has no open sessions.',
+  loginNotBlocked: 'That one is not waiting.',
   tabDevices: 'Devices',
   tabSecrets: 'Scopes & variables',
   tabMe: 'Profile',

package/src/update.js

@@ -0,0 +1,39 @@
+/**
+ * update.js — lo que es DEL VAULT al actualizarse, y nada más.
+ *
+ * La mecánica —comparar versiones, preguntar a GitHub, bajar y verificar contra sigstore—
+ * vive en `@dotrino/update`, porque es la misma para el proxio, geo, los agentes y los
+ * comandos (CONVENCIONES §15). Aquí solo queda lo que sabe el vault de sí mismo: en qué
+ * repo sale y cómo se llaman sus archivos.
+ *
+ * Antes de existir el paquete esto era una copia entera de esa mecánica. Dos copias de lo
+ * mismo son dos sitios donde arreglar el mismo fallo, y el segundo siempre se olvida.
+ */
+import fs from 'node:fs'
+import { latestVersion, isNewer, CHECK_EVERY_MS } from '@dotrino/update'
+import { pickAsset, download, verifyArtifact as verify } from '@dotrino/update/fetch'
+import { VERSION } from './version.js'
+
+export const REPO = 'imdotrino/dotrino-vault'
+export { isNewer, CHECK_EVERY_MS, download }
+
+/** La última release del vault. `{ ok:false, reason }` si no se pudo mirar, que NO es «al día». */
+export const latestRelease = (opts = {}) =>
+  latestVersion({ source: 'github', repo: REPO, product: 'dotrino-vault', version: VERSION, ...opts })
+
+/**
+ * Qué archivo le toca a esta máquina. El `.deb` donde hay `dpkg`; en cualquier otro Linux,
+ * el tarball. Fuera de Linux no se emite binario, y se dice en vez de bajar algo inútil.
+ */
+export function assetFor (assets, { platform = process.platform, arch = process.arch, hasDpkg = null } = {}) {
+  if (platform !== 'linux') return { ok: false, reason: `there is no binary for ${platform}: update with npm (npx @dotrino/vaultd)` }
+  if (arch !== 'x64') return { ok: false, reason: `there is no binary for ${arch}` }
+  const deb = hasDpkg === null ? fs.existsSync('/usr/bin/dpkg') : hasDpkg
+  return pickAsset(assets, [
+    { kind: 'deb', re: /_amd64\.deb$/, when: () => deb },
+    { kind: 'tar', re: /-linux-x64\.tar\.gz$/ }
+  ])
+}
+
+/** Verifica contra la atestación del release del vault. Sin `gh`, no se instala. */
+export const verifyArtifact = (file, opts = {}) => verify(file, { repo: REPO, ...opts })

package/src/vault.js

@@ -2745,28 +2745,28 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   async function incompleteMembers () {
     if (secrets.isLegacy?.()) return []
-    const record = (await identity.profileActa?.().catch(() => null))?.acta
-    const out = []
-    for (const m of record?.members || []) {
-      if (!m.encPub || m.pub === master) continue
-      const owners = {}
-      // Un servicio lee su cajón de ns y el suyo propio; un aparato que administra
-      // puede DESTAPAR cualquiera, así que se le miran todos: sin envoltura, el botón
-      // «Ver» de la consola le fallaría sin explicar por qué.
-      // Un aparato que administra NO debe tener envoltura de los cajones con dueño
-      // (`recipientsOf`), así que no se le cuenta como falta: lo que ahí falta es a
-      // propósito y ponerlo en la lista sería pedir que se «arregle» lo correcto.
-      const ownedNs = new Set((record?.members || []).filter((x) => x.cn).map((x) => x.cn))
-      const drawers = m.cn
-        ? [`ns:${m.cn}`, `dev:${m.pub}`]
-        : [...Object.keys(secrets.list()).filter((ns) => !ownedNs.has(ns)).map((ns) => `ns:${ns}`), `dev:${m.pub}`]
-      for (const owner of drawers) {
-        const missing = secrets.missingFor(owner, m.pub)
-        if (missing.length) owners[owner] = missing
+    // A QUIÉN LE FALTA ALGO LO DICE `recipientsOf`, Y SOLO ÉL — la misma lista con la que
+    // se envuelve al escribir y se rehace el llavero al abrir. Aquí había otra: «un aparato
+    // sin `cn` puede destapar cualquier cajón sin dueño». Para `@me` no es cierto —el
+    // perfil se envuelve a quien puede FIRMAR por ti—, así que un aparato sin `firma` salía
+    // con todos los datos del perfil «sin llave todavía», y abrir la bóveda, que es lo que
+    // el aviso pedía, no podía apagarlo: el llavero ya estaba como decía el acta. Dos
+    // listas para la misma pregunta acaban siempre así.
+    const out = new Map()
+    for (const owner of secrets.owners()) {
+      // Por VISIBILIDAD: a quien administra se le envuelve la pública de un cajón con dueño
+      // y no la privada. La lista de las públicas contiene siempre a la de las privadas.
+      const privados = new Set((await recipientsOf(owner)).map((m) => m.pub))
+      for (const m of await recipientsOf(owner, { public: true })) {
+        if (!m.encPub || m.pub === master) continue
+        const missing = secrets.missingFor(owner, m.pub, { only: (esPublica) => esPublica || privados.has(m.pub) })
+        if (!missing.length) continue
+        const row = out.get(m.pub) || { pub: m.pub, cn: m.cn || null, owners: {} }
+        row.owners[owner] = missing
+        out.set(m.pub, row)
       }
-      if (Object.keys(owners).length) out.push({ pub: m.pub, cn: m.cn || null, owners })
     }
-    return out
+    return [...out.values()]
   }
 
   /**
@@ -3552,6 +3552,22 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // (`unattended`), no una lista de esta máquina — por eso ya no hay `setApproval` ni
     // `supervised`: se concede y se quita como cualquier otro permiso, con `caps`.
     needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
+    /**
+     * QUIÉN PUEDE APROBAR EN ESTA CUENTA. Lo usa la actualización (§15): la bóveda pide
+     * permiso al teléfono **solo si hay a quién pedírselo**; si no hay ningún aparato con
+     * `aprueba`, se actualiza sola.
+     *
+     * Es la regla del dueño (2026-09-20) y evita la trampa evidente: una bóveda sin
+     * aprobadores que se quedaría sin poder actualizarse nunca, esperando un sí que nadie
+     * puede dar. Mismo sitio del que ya sale el «rang N approver(s)» de los secretos.
+     */
+    approvers: async () => {
+      const record = await refreshActa()
+      if (!record) return []
+      return (record.members || [])
+        .filter((m) => Acta.memberCan(record, m.pub, 'approve'))
+        .map((m) => ({ id: m.id, label: m.label || '', pub: m.pub }))
+    },
     // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
     // llave. Lo que no puede es listarla un aparato.
     passwordDevices,

package/src/vaultControl.js

@@ -49,7 +49,11 @@ const F = {
   secretReq: 'secret-request.json',
   profileReq: 'profile-request.json',
   meReq: 'me-request.json',
-  dumpReq: 'dump-request.json'
+  dumpReq: 'dump-request.json',
+  // ENTRAR CON USUARIO Y CONTRASEÑA. La respuesta NO se llama `logins.json`: ese nombre ya
+  // es el almacén del escritorio dentro del dir del perfil, y pisarlo los borraría.
+  loginsReq: 'logins-request.json',
+  loginsList: 'logins-list.json'
 }
 
 const p = (name) => path.join(dir, name)
@@ -242,6 +246,96 @@ export const setProfilePassword = (profile, password, current) => profileOp('pas
 // Quitarla también la pide: se re-sella a la llave de la máquina antes de que se vaya.
 export const removeProfilePassword = (profile, password) => profileOp('password-rm', { profile, password })
 
+// ---------------------------------------------------------------------------
+// Inicios de sesión con contraseña (`docs/temporary-access.md`)
+// ---------------------------------------------------------------------------
+
+/**
+ * Un viaje al mostrador de inicios de sesión del daemon. Es el MISMO canal que usa el CLI
+ * (`dotrino-vault logins`) —una pieza, no dos— y por eso la pantalla de la TUI y el
+ * comando no se pueden desincronizar.
+ *
+ * La respuesta se BORRA al leerla: puede traer el paquete de llaves de un aparato.
+ */
+export async function loginsOp (op, extra = {}) {
+  requireAlive()
+  rm(F.loginsList)
+  const since = Date.now()
+  const id = await writeReq(F.loginsReq, { op, ...extra })
+  signalOrCleanup('SIGUSR2', [F.loginsReq])
+  const d = await waitFor(F.loginsList, { req: id, since })
+  rm(F.loginsList)
+  if (!d) throw coded('the daemon did not reply', 'NO_REPLY')
+  if (d.ok === false) {
+    // `too-many-tries` trae cuánto falta, y `PROFILE_LOCKED` se arregla abriendo la bóveda:
+    // los dos cambian lo que hay que hacer, así que viajan con su dato.
+    throw Object.assign(coded(d.error || 'logins: the vault refused', d.code), { waitMs: d.waitMs })
+  }
+  return d
+}
+
+/** Los inicios de sesión de este perfil, con la dirección ya montada. */
+export async function listLogins (profile) {
+  const { logins = [], fingerprint } = await loginsOp('list', profile ? { profile } : {})
+  const { loginAddress } = await import('../lib/src/passwordLogins.js')
+  return logins.map((l) => ({ ...l, address: fingerprint ? loginAddress(l.user, fingerprint) : '' }))
+}
+
+/**
+ * ALTA. Las llaves del aparato NACEN aquí, en esta terminal, y salen ya cerradas con lo
+ * que deriva de la contraseña: lo que la bóveda guarda es un paquete que no puede abrir.
+ *
+ * Se pueden tener VARIOS por perfil, cada uno con sus permisos: son miembros del acta como
+ * cualquier otro aparato.
+ */
+export async function addLogin ({ user, password, label = 'equipo prestado', caps = ['sign', 'read', 'store'] } = {}) {
+  const { client: opaque } = await import('@dotrino/opaque')
+  const { makeDeviceKey, makeDeviceEncKey } = await import('@dotrino/identity/capabilities')
+  const { capScope } = await import('@dotrino/identity/acta')
+  const { sealDeviceKeys } = await import('../lib/src/passwordLogins.js')
+  const start = opaque.registrationStart({ password })
+  const begun = await loginsOp('register-begin', { user, request: start.request })
+  const fin = opaque.registrationFinish({ state: start.state, response: begun.response, password })
+  const device = await makeDeviceKey({ label })
+  const enc = await makeDeviceEncKey()
+  const blob = await sealDeviceKeys(fin.exportKey, { sign: device.privateJwk, enc: enc.privateJwk })
+  // El acta habla de PERMISOS y el papel de SCOPES: los traduce el pilar, no esta pantalla.
+  // `unattended` no es un scope —es «no me pidas aprobación»— y por eso viaja aparte.
+  return loginsOp('register-finish', {
+    user, upload: fin.upload, pub: device.publickey, encPub: enc.publickey, label, blob,
+    scope: caps.filter((c) => c !== 'unattended').map((c) => capScope(c)).filter(Boolean),
+    unattended: caps.includes('unattended')
+  })
+}
+
+/**
+ * Cambiar la contraseña es ABRIR y volver a cerrar, así que hace falta la vieja: el
+ * paquete de llaves está cerrado con lo que salía de ella, y sin abrirlo no hay qué
+ * volver a cerrar. Perderla no se arregla desde aquí — se quita el aparato y se crea otro.
+ */
+export async function passwdLogin ({ user, oldPassword, newPassword } = {}) {
+  const { client: opaque } = await import('@dotrino/opaque')
+  const { sealDeviceKeys, openDeviceKeys } = await import('../lib/src/passwordLogins.js')
+  const start = opaque.loginStart({ password: oldPassword })
+  const begun = await loginsOp('login-begin', { user, request: start.request })
+  let fin
+  try { fin = opaque.loginFinish({ state: start.state, response: begun.response, password: oldPassword }) }
+  catch (_) { throw coded('wrong password', 'login-failed') }
+  const entrada = await loginsOp('login-end', { lid: begun.lid, finalization: fin.finalization, label: 'la consola' })
+  const keys = await openDeviceKeys(fin.exportKey, entrada.blob)
+  const reg = opaque.registrationStart({ password: newPassword })
+  const { response } = await loginsOp('register-begin', { user, request: reg.request, replace: true })
+  const nueva = opaque.registrationFinish({ state: reg.state, response, password: newPassword })
+  return loginsOp('register-finish', {
+    user, upload: nueva.upload, blob: await sealDeviceKeys(nueva.exportKey, keys), replace: true
+  })
+}
+
+export const closeLoginSession = (user, sid = null) => loginsOp('close', { user, ...(sid ? { sid } : {}) })
+export const unblockLogin = (user) => loginsOp('unblock', { user })
+/** Quitarlo lo saca del mostrador **y su llave del acta**: las dos cosas, o ninguna. */
+export const removeLogin = (user) => loginsOp('rm', { user })
+
 // ---------------------------------------------------------------------------
 // Volcado de dispositivos + secretos de un perfil
 // ---------------------------------------------------------------------------