@dotrino/vaultd 0.123.1 → 0.124.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.123.1",
+  "version": "0.124.1",
   "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)
@@ -604,7 +612,11 @@ async function cmdMembers () {
     // Un servicio SIN llave de cifrado no puede leer ninguna variable privada: van
     // selladas a esa llave. Se dice aquí, junto a él, porque es el único sitio donde
     // 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)
+    //
+    // Solo si LEE variables (`secrets`). La llave de comunicación de la bóveda entra con
+    // `cn: 'vault'` y solo `firma`, y no tiene llave de cifrado a propósito: salía marcada
+    // en rojo «NO puede leer sus variables» cuando no tiene ninguna que leer.
+    if (m.cn && !m.canSeal && m.caps.includes('secrets')) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
     // QUÉ CORRE, y si cuadra con esta bóveda (CONVENCIONES §14). Sin esto una
     // incompatibilidad de versiones se ve como que ese aparato «no responde», que es el
     // fallo más caro que ha tenido el ecosistema. No bloquea nada: se enseña.
@@ -1689,6 +1701,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 +2168,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/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

@@ -27,7 +27,7 @@ import { startSealersPublisher } from './sealers.js'
 import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
-import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
+import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_NS, PROFILE_OWNER } from './secretsStore.js'
 import { openSubacta } from './subacta.js'
 import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.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()]
   }
 
   /**
@@ -2785,8 +2785,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   /**
-   * TODO lo que está a deber, por cajón: las rotaciones anotadas y, CALCULADO, cada
-   * envoltura que falta. La falta de una envoltura no se anota nunca: se mira. Una nota
+   * Lo que deben las VARIABLES, por cajón: las rotaciones anotadas y, CALCULADO, cada
+   * envoltura que falta. El perfil no entra (ver el bucle). La falta de una envoltura no se anota nunca: se mira. Una nota
    * se desincroniza en cuanto alguien salda la deuda por un camino que no pasa por donde
    * se anotó (pasó dos veces: el reparto por el hermano y el rehacer al abrir), y
    * entonces la consola avisa de algo que ya no existe. Lo que se calcula no miente.
@@ -2796,6 +2796,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const out = rotationsDue()
     for (const m of await incompleteMembers()) {
       for (const [owner, keys] of Object.entries(m.owners)) {
+        // El perfil tampoco va aquí: esto es lo que se enseña como «variables sin
+        // entregar». Lo que un aparato no puede abrir del perfil sigue a la vista en SU
+        // fila (`incomplete`), y `secret settle` y abrir la bóveda lo saldan igual, porque
+        // leen `incompleteMembers` y no esto.
+        if (owner === PROFILE_OWNER) continue
         if (out[owner]?.kind === 'rotate') continue
         out[owner] = out[owner] || { kind: 'rewrap', members: [] }
         out[owner].members.push({ pub: m.pub, keys })
@@ -3409,7 +3414,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // sobre, «pública» dejó de significar «en claro»: dice a quién se le despacha sin
     // aprobación, nada más. Para ver un valor hay que poder abrirlo, igual que cualquiera —
     // y en un cajón con dueño, quien administra deliberadamente no puede.
-    return secrets.list()
+    //
+    // EL PERFIL NO ES UN GRUPO DE VARIABLES (dueño, 2026-09-21). `@me` vive en este
+    // almacén porque se guarda igual —mismo sobre, mismo llavero—, pero no es configuración
+    // de nadie: salía en `secret list` como «scope vault:secrets:@me», un scope que por
+    // diseño no puede existir, y en la pantalla de variables como un grupo más. El perfil
+    // tiene su sitio (`dotrino-vault me`, profile.dotrino.com).
+    const variables = secrets.list()
+    delete variables[PROFILE_NS]
+    return variables
   }
   /** Cambiar SOLO quién puede ver el valor (no toca el valor ni avisa: el servicio lee lo mismo). */
   async function setSecretVisibility (ns, key, isPublic, adminKey) {
@@ -3552,6 +3565,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,