@dotrino/vaultd 0.145.0 → 0.147.0

package/lib/src/service.js

@@ -620,6 +620,119 @@ export async function fetchDigest ({ dir, ns, proxyUrl, masterPubkey, device, ce
   } finally { client.close() }
 }
 
+/** Cuánto espera un aparato a que alguien apruebe su actualización (el pedido vive un día). */
+export const UPDATE_APPROVAL_TIMEOUT_MS = 24 * 60 * 60 * 1000 + 10 * 1000
+
+/**
+ * ¿PUEDO ACTUALIZARME? Lo pregunta un aparato a su bóveda ANTES de instalar una versión
+ * nueva, y SOLO si tiene encendido su propio interruptor de «pedir aprobación» (CONVENCIONES
+ * §15, dueño 2026-10-08: todo se actualiza solo; pedir aprobación es un ajuste de cada pieza,
+ * independiente del de la bóveda). Quien no lo tiene encendido no llama a esto.
+ *
+ *   · nadie aprueba en la cuenta → `{ ok: true, asked: false }`, ya.
+ *   · hay aprobadores → la bóveda contesta «pendiente», timbra a quien aprueba y el resultado
+ *     llega por esta misma conexión cuando alguien decide: `{ ok, asked: true }`. El pedido
+ *     dura un día; vencido es no.
+ *
+ * LANZA si la bóveda no contesta (`code: 'vault-no-reply'`) o si quedó «pendiente» y el
+ * resultado no llegó (`code: 'unanswered'`): quien llama decide qué hacer. Que nadie conteste
+ * NUNCA es un sí. Preguntar otra vez por lo mismo mientras el pedido vive no vuelve a timbrar;
+ * no repetir la pregunta por la misma versión es cosa de quien llama.
+ *
+ * @param {object} o
+ * @param {string} o.product  nombre npm de lo que se actualiza, p. ej. `@dotrino/terminal-agent`
+ * @param {string} o.version  la versión que se quiere instalar
+ * @param {string} [o.from]   la que corre ahora
+ * @param {string} [o.dir]    identidad guardada por `enrollService`; o, en su lugar, la
+ *   identidad por parámetros (`proxyUrl`, `masterPubkey`, `device`, `cert`), como en los demás.
+ * @param {(p: { id: string, exp: number }) => void} [o.onPending]
+ * @returns {Promise<{ ok: boolean, asked: boolean }>}
+ */
+export async function askUpdateApproval ({ product, version, from = null, dir, proxyUrl, masterPubkey, device, cert, timeoutMs = 30000, approvalTimeoutMs = UPDATE_APPROVAL_TIMEOUT_MS, onPending } = {}) {
+  const saved = dir ? readServiceIdentity(dir) : null
+  proxyUrl = proxyUrl || saved?.proxy
+  masterPubkey = masterPubkey || saved?.iss
+  device = device || saved?.device
+  cert = cert || saved?.cert
+  if (typeof product !== 'string' || !product || typeof version !== 'string' || !version) throw new Error('askUpdateApproval: needs product and version')
+  if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
+  try {
+    await identifyAsService(client, device)
+    const data = { op: 'update-ask', product, version, ...(typeof from === 'string' && from ? { from } : {}), publickey: device.publickey, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
+    const mine = (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === 'update-ask' && p.body.product === product && p.body.version === version)
+    const check = async (res) => {
+      if (res.type === MSG.ERROR) throw vaultError(res)
+      await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
+      if (typeof res.body.ts !== 'number' || Math.abs(Date.now() - res.body.ts) > FRESH_WINDOW_MS) throw new Error('stale update-ask reply')
+      return res.body
+    }
+    // UNA COLA, no dos esperas seguidas: el resultado puede llegar mientras todavía se
+    // comprueba el «pendiente», y una escucha puesta después lo perdería (y se esperaría un
+    // día por algo que ya se contestó).
+    const queue = []
+    let wake = null
+    const off = client.on('message', (_from, p) => { if (p && typeof p === 'object' && mine(p)) { queue.push(p); wake?.() } })
+    const next = (ms, code, message) => new Promise((resolve, reject) => {
+      if (queue.length) return resolve(queue.shift())
+      const t = setTimeout(() => { wake = null; reject(Object.assign(new Error(message), { code })) }, ms)
+      wake = () => { clearTimeout(t); wake = null; resolve(queue.shift()) }
+    })
+    let body
+    try {
+      client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
+      body = await check(await next(timeoutMs, 'vault-no-reply', 'update-ask: the vault did not answer'))
+      if (body.pending === true) {
+        try { onPending?.({ id: body.id, exp: body.exp }) } catch (_) {}
+        const until = typeof body.exp === 'number' ? Math.max(5000, body.exp - Date.now() + 5000) : approvalTimeoutMs
+        do {
+          body = await check(await next(Math.min(until, approvalTimeoutMs), 'unanswered', 'update-ask: nobody answered the request in time'))
+        } while (body.pending === true)
+      }
+    } finally { off() }
+    if (typeof body.ok !== 'boolean') throw new Error('malformed update-ask reply')
+    return { ok: body.ok, asked: body.asked === true }
+  } finally { client.close() }
+}
+
+/**
+ * ME ACTUALICÉ: un aparato se lo dice a su bóveda DESPUÉS de instalar, y ella se lo cuenta a
+ * quien aprueba en la cuenta (un aviso, y queda 24 h en la lista de avisos). Se llama solo
+ * si el aparato tiene encendido su interruptor de avisos de actualización.
+ *
+ * Quién es el aparato lo pone la bóveda desde el acta, no lo que él diga.
+ * LANZA si la bóveda no contesta (`code: 'vault-no-reply'`) o no pudo avisar.
+ *
+ * @param {object} o  `product`, `version`, `from` y la conexión, como en `askUpdateApproval`
+ * @returns {Promise<{ ok: true }>}
+ */
+export async function reportUpdated ({ product, version, from = null, dir, proxyUrl, masterPubkey, device, cert, timeoutMs = 30000 } = {}) {
+  const saved = dir ? readServiceIdentity(dir) : null
+  proxyUrl = proxyUrl || saved?.proxy
+  masterPubkey = masterPubkey || saved?.iss
+  device = device || saved?.device
+  cert = cert || saved?.cert
+  if (typeof product !== 'string' || !product || typeof version !== 'string' || !version) throw new Error('reportUpdated: needs product and version')
+  if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
+  try {
+    await identifyAsService(client, device)
+    const data = { op: 'update-done', product, version, ...(typeof from === 'string' && from ? { from } : {}), publickey: device.publickey, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
+    const pending = waitForMsg(client, (p) => p.type === MSG.ERROR || (p.type === MSG.SECRETS_RESULT && p.body?.op === 'update-done' && p.body.product === product && p.body.version === version), timeoutMs)
+    client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
+    const res = await pending.catch((e) => {
+      if (/timeout/.test(e.message)) throw Object.assign(new Error('update-done: the vault did not answer'), { code: 'vault-no-reply' })
+      throw e
+    })
+    if (res.type === MSG.ERROR) throw vaultError(res)
+    await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
+    if (res.body.ok !== true) throw new Error('malformed update-done reply')
+    return { ok: true }
+  } finally { client.close() }
+}
+
 /**
  * Pide los secretos del ns al vault (una petición puntual; lanza si falla).
  * Usa la identidad persistida por `enrollService` salvo que se pase explícita.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.145.0",
+  "version": "0.147.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": {

package/src/ctl.js

@@ -79,6 +79,10 @@ const D = '\x1b[2m' // apagado: para el dato que acompaña sin competir con el n
  * En español, como el resto de esta CLI: con el idioma del sistema salía «Jul 29, 2026»
  * en medio de una frase en español, que es peor que cualquiera de los dos por separado.
  */
+function fechaHora (ms) {
+  try { return new Date(ms).toLocaleString('es', { year: 'numeric', month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }) }
+  catch (_) { return '' }
+}
 function fechaCorta (ms) {
   try { return new Date(ms).toLocaleDateString('es', { year: 'numeric', month: 'short', day: 'numeric' }) }
   catch (_) { return '' }
@@ -131,6 +135,11 @@ function deviceIdOf (sub) {
   return pubkeyId(sub).then((id) => id.slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
 }
 
+/** Lo que dijo un aprobador sobre sus avisos, para enseñarlo. No decide nada. */
+function avisosTxt (notifiedAt) {
+  return notifiedAt ? `dijo que le llegan los avisos (${fechaCorta(notifiedAt)})` : 'no ha dicho que le lleguen los avisos'
+}
+
 function cmdStatus () {
   const s = readState()
   const up = alive(s.pid)
@@ -153,11 +162,30 @@ function cmdStatus () {
     console.log('  %s⬆ hay %s publicada%s (esta es la %s) · tráela con:  dotrino-vault update',
       B, s.latest.version, Z, VERSION)
   }
-  // …Y LLEVA DÍAS PIDIENDO PERMISO SIN RESPUESTA. Es un bloqueo que desde fuera no se ve:
-  // la bóveda parece normal y simplemente no se actualiza.
+  // …Y SE PIDIÓ PERMISO. El pedido se hace UNA vez por versión y dura un día: mientras
+  // espera se dice hasta cuándo; si no se aprobó, que ya no se vuelve a pedir y cómo
+  // instalarla. Es un freno que desde fuera no se ve: la bóveda parece normal.
   if (s.updateAsk?.version && isNewer(s.updateAsk.version, VERSION)) {
-    console.log('    pidió permiso para instalarla %s (%d %s) y nadie lo ha aprobado · mira Pedidos en tu teléfono',
-      hace(s.updateAsk.since), s.updateAsk.asks, s.updateAsk.asks === 1 ? 'vez' : 'veces')
+    const u = s.updateAsk
+    if (u.result === 'pending') {
+      console.log('    se pidió permiso para instalar la %s el %s y está esperando respuesta hasta el %s · mira Pedidos en tu teléfono',
+        u.version, fechaHora(u.askedAt), fechaHora(u.askedAt + 24 * 60 * 60 * 1000))
+    } else {
+      console.log('    se pidió permiso para instalar la %s el %s y no se aprobó: no se vuelve a pedir · instálala con:  dotrino-vault update',
+        u.version, fechaHora(u.askedAt))
+    }
+    // A QUIÉN SE LE PIDIÓ, y si dijo que le llegan los avisos: el que no lo ha dicho es el
+    // primer sitio donde mirar cuando nadie contesta.
+    for (const a of s.updateAsk.approvers || []) {
+      console.log('      %s  %s%s · %s', a.id, a.label || '(sin nombre)', a.profile ? ` [${a.profile}]` : '', avisosTxt(a.notifiedAt))
+    }
+  }
+  // CÓMO SE ACTUALIZA. Va siempre, también al día: es un ajuste y se mira aquí.
+  if (up && 'updateApproval' in s) {
+    console.log('  actualizar  : %s', s.updateApproval === null
+      ? `${R}no se pudo leer el ajuste: no se actualiza${Z} · ponlo de nuevo con:  dotrino-vault update --approval on|off`
+      : s.updateApproval ? 'pide aprobación (dotrino-vault update --approval off para que lo haga sola)'
+        : 'sola, sin pedir aprobación (dotrino-vault update --approval on para que pida)')
   }
   const profiles = s.profiles || []
   if (profiles.length) {
@@ -631,6 +659,9 @@ async function cmdMembers () {
     // 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.
+    // SI LE LLEGAN LOS AVISOS, en quien aprueba. No cambia a quién se le pide —se le pide a
+    // todos—: es para ver a cuál no le suena el pedido.
+    if (m.caps.includes('approve') && 'notifiedAt' in m) console.log('      %s%s%s', D, avisosTxt(m.notifiedAt), Z)
     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
@@ -1793,7 +1824,32 @@ async function waitForService (version, { timeoutMs = 4 * 60_000 } = {}) {
   return false
 }
 
+/**
+ * DEJA DICHO QUE SE INSTALÓ una versión nueva, para que el servicio se lo cuente a quien
+ * aprueba cuando arranque con ella (`anunciarActualizacion` en daemon.js). Es el mismo
+ * marcador que deja el servicio cuando se actualiza solo. Si no se puede escribir se dice:
+ * la actualización está hecha, lo que se pierde es el aviso.
+ */
+function noteUpdated (to) {
+  try { ipcWrite(path.join(dir, 'updated.json'), { v: 1, from: readState().version || VERSION, to, at: Date.now() }) } catch (e) {
+    console.error('No se pudo dejar el aviso de actualización para tus aprobadores: %s', e.message)
+  }
+}
+
 async function cmdUpdate (args = []) {
+  // PEDIR PERMISO PARA ACTUALIZARSE es un ajuste, apagado por defecto. Se guarda aquí y el
+  // servicio lo lee la próxima vez que mire si hay versión nueva: no hace falta reiniciarlo.
+  const iAp = args.indexOf('--approval')
+  if (iAp !== -1) {
+    const { readSettings, writeSettings } = await import('./settings.js')
+    const v = args[iAp + 1]
+    if (v === 'on' || v === 'off') writeSettings(dir, { updateApproval: v === 'on' })
+    else if (v !== undefined) { console.error('uso: dotrino-vault update --approval [on|off]'); process.exit(2) }
+    console.log(readSettings(dir).updateApproval
+      ? 'Esta bóveda pide aprobación antes de actualizarse (a los aparatos con «aprueba» de cualquiera de sus perfiles).'
+      : 'Esta bóveda se actualiza sola, sin pedir aprobación.')
+    return
+  }
   const { latestRelease, assetFor, download, verifyArtifact, isNewer, isUserInstall, installUserRelease } = await import('./update.js')
   const soloMirar = args.includes('--check')
 
@@ -1825,6 +1881,7 @@ async function cmdUpdate (args = []) {
     }
     console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
     console.log('Instalada la %s.', res.version)
+    noteUpdated(res.version)
     if (!args.includes('--no-wait')) await waitForService(res.version)
     return
   }
@@ -1864,6 +1921,7 @@ async function cmdUpdate (args = []) {
       B, file, r.version, Z)
     return
   }
+  noteUpdated(r.version)
   console.log('Listo. El servicio se reinicia solo; compruébalo con:  dotrino-vault status')
 }
 
@@ -2174,6 +2232,10 @@ function help () {
   status | info       estado del servicio + fingerprint + el id de cada perfil
   update [--check]   trae la versión nueva (verificando la firma) y espera a que el
                      servicio la arranque · --check solo mira · --no-wait no espera
+  update --approval [on|off]
+                     el servicio se actualiza solo; con «on» antes pide aprobación a los
+                     aparatos con «aprueba» de cualquier perfil (vale para todos) · sin
+                     valor, dice cómo está
   pair [--save <f>]   inicia un emparejamiento (QR + espera); --save escribe la invitación (.dpair)
   pair --kms <config.json>
                       el sitio que se cree (--adopt o --new-account) NACE con su clave

package/src/daemon.js

@@ -27,10 +27,16 @@ import { capScope } from '@dotrino/identity/acta'
 import { watchBinary } from './selfupdate.js'
 import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelease } from './update.js'
 import { VERSION } from './version.js'
+import { readSettings } from './settings.js'
+import { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo } from './updateApproval.js'
+import { UPDATE_TTL_MS } from './approvals.js'
 import crypto from 'node:crypto'
 
 const readJsonSafe = (f) => ipcRead(f, null)
 const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
+/** Cada cuánto se reintenta contar la actualización, y cuántas veces (≈10 min). */
+const ANNOUNCE_EVERY_MS = 5000
+const ANNOUNCE_TRIES = 120
 
 /**
  * UNA sola bóveda por directorio de datos.
@@ -89,18 +95,24 @@ export async function runDaemon () {
 
   // --- state.json ---
   const stateFile = path.join(dir, 'state.json')
+  // Lo que deja quien instala una versión nueva, para que la nueva lo cuente al arrancar.
+  const updatedFile = path.join(dir, 'updated.json')
+  /** Los perfiles que están atendiendo ahora mismo, con su nombre para los mensajes. */
+  const perfilesEnMarcha = () => [...mgr.running.entries()].map(([id, vault]) => ({ id, vault, name: mgr.profiles.get(id)?.name || id }))
   const daemonVersion = VERSION
   /** `{ version, checkedAt }` de la última consulta que salió bien, o null si aún ninguna. */
   let ultimaPublicada = null
   /**
-   * EL PEDIDO DE ACTUALIZACIÓN QUE NADIE HA CONTESTADO: `{ version, since, asks }`, o null.
-   * Va en la foto para que `status` y la TUI lo DIGAN. Sin esto, una bóveda que lleva días
-   * pidiendo permiso y sin respuesta se veía igual que una al día.
+   * EL PEDIDO DE ACTUALIZACIÓN: `{ version, askedAt, result, approvers }`, o null. `result`
+   * es `pending` mientras espera (un día) y `denied`/`expired` cuando no se aprobó — y
+   * entonces no se vuelve a pedir por esa versión. Va en la foto para que `status` y la TUI
+   * lo DIGAN: una bóveda que no se actualiza por esto se vería igual que una al día.
    */
   let pedidoSinRespuesta = 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`.
+  const ajusteActualizar = () => { try { return readSettings(dir).updateApproval } catch (_) { return null } }
   const writeState = () => {
     const cur = mgr.summary().find((p) => p.current) || {}
     ipcWrite(stateFile, {
@@ -114,6 +126,9 @@ export async function runDaemon () {
       // también sin conexión.
       ...(ultimaPublicada ? { latest: ultimaPublicada } : {}),
       ...(pedidoSinRespuesta ? { updateAsk: pedidoSinRespuesta } : {}),
+      // Si para actualizarse pide permiso (`src/settings.js`). `null` = el ajuste no se
+      // pudo leer, que `status` dice distinto de «no».
+      updateApproval: ajusteActualizar(),
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -1103,35 +1118,44 @@ export async function runDaemon () {
     if (!isNewer(r.version, daemonVersion)) return
 
     /**
-     * PIDE PERMISO SOLO SI HAY A QUIÉN PEDÍRSELO (dueño, 2026-09-20).
+     * SE ACTUALIZA SOLA. PEDIR PERMISO ES UN AJUSTE (dueño, 2026-10-08).
      *
-     * 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.
+     * Por defecto no se le pregunta a nadie: lo que se baja se verifica contra la
+     * atestación del release antes de tocar el disco, y eso no depende de que alguien
+     * conteste. Antes se pedía permiso según quién hubiera en el acta y según si decía que
+     * le llegan los avisos; eran condiciones que explicar y que se desalineaban, y una
+     * bóveda podía quedarse atrás sin que nadie lo viera.
      *
-     * 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).
+     * Quien quiera decidir cada actualización lo enciende: `dotrino-vault update --approval
+     * on` (`src/settings.js`). Entonces se le pide a TODO el que tenga `aprueba`, reciba
+     * avisos o no, y sin un sí no se instala. Si en el acta no aprueba nadie, se actualiza
+     * igual: esperar un sí que nadie puede dar sería no actualizarse nunca.
+     *
+     * Lo que cada aprobador dijo de sus avisos (`notifiedAt`, `src/notifiable.js`) no
+     * decide nada: se enseña junto al pedido sin respuesta, para ver a cuál no le suena.
      */
-    // SI NO SE PUEDE SABER QUIÉN APRUEBA, NO SE ACTUALIZA. Antes un fallo aquí dejaba la
-    // lista vacía, y lista vacía es «nadie aprueba, adelante»: el repliegue que abre la
-    // puerta justo cuando algo se rompió. Se dice y se vuelve a mirar en la próxima pasada.
-    let enElActa
-    try { enElActa = await mgr.current().approvers() } catch (e) {
-      console.log(`[vault] version ${r.version} is out, but the approvers could not be read (${e?.message || e}) · not updating`)
+    // SI EL AJUSTE NO SE PUEDE LEER, NO SE ACTUALIZA: el valor por defecto es no preguntar,
+    // así que suponerlo sería saltarse la aprobación que el dueño pidió.
+    let pedirPermiso
+    try { pedirPermiso = readSettings(dir).updateApproval } catch (e) {
+      console.log(`[vault] version ${r.version} is out, but the settings could not be read (${e?.message || e}) · not updating`)
       return
     }
-    /**
-     * Y SOLO CUENTA EL APROBADOR QUE PUEDE ENTERARSE (dueño, 2026-10-07). Uno que no recibe
-     * avisos no ve el pedido si no abre la app por su cuenta: la bóveda pedía cada día y se
-     * quedaba atrás para siempre, que es el mismo bloqueo de «sin aprobadores» un paso
-     * después. Lo dice el propio aparato, firmado, y caduca (`src/notifiable.js`).
-     *
-     * Esto vale SOLO para actualizarse. Lo que se instala se verifica igual contra la
-     * atestación del release, se haya pedido permiso o no.
-     */
-    const quienAprueba = enElActa.filter((a) => a.notifiedAt)
+    // EN TODOS LOS PERFILES: el ajuste es de la bóveda, no de una cuenta (dueño, 2026-10-08).
+    // Basta con que UNO tenga quien apruebe para que se pida, y se le pide a todos.
+    //
+    // Y si hay que pedir y no se puede saber a quién, tampoco se actualiza: una lista vacía
+    // o a medias sería «nadie aprueba, adelante», el repliegue que abre la puerta justo
+    // cuando algo se rompió.
+    const enMarcha = perfilesEnMarcha()
+    let quienAprueba = []
+    if (pedirPermiso) {
+      try { quienAprueba = await approversOfAll(enMarcha) } catch (e) {
+        console.log(`[vault] version ${r.version} is out, but the approvers could not be read (${e?.message || e}) · not updating`)
+        return
+      }
+    }
+    const conAvisos = quienAprueba.filter((a) => a.notifiedAt).length
 
     // INSTALADA COMO PAQUETE DEL SISTEMA (.deb en /usr/bin): el binario es de root y este
     // proceso no puede tocarlo. Se dice, con las dos salidas, y no se intenta nada.
@@ -1142,23 +1166,55 @@ export async function runDaemon () {
     if (actualizando) return
     actualizando = true
     try {
-      // PIDE PERMISO SOLO SI HAY A QUIÉN PEDÍRSELO (dueño, 2026-09-20); sin aprobadores
-      // no se necesita aprobación (dueño, 2026-09-24).
-      if (quienAprueba.length) {
-        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking one of ${quienAprueba.length} approver(s)`)
-        const si = await mgr.current().askUpdateApproval({ version: r.version })
+      // (`aprobada`: ya dijeron que sí a esta versión y la instalación falló; no se vuelve a
+      // preguntar por lo que ya se aprobó, se reintenta instalar.)
+      if (quienAprueba.length && aprobada !== r.version) {
+        // UNA VEZ POR VERSIÓN (dueño, 2026-10-08): el pedido dura un día y no se repite. Si
+        // se denegó o venció, esa versión queda sin aprobar y se vuelve a preguntar solo
+        // cuando salga una MÁS NUEVA. Lo preguntado se apunta al pedir y sobrevive a un
+        // reinicio (`update-asked.json`); si no se puede leer, no se actualiza y se dice.
+        let preguntado
+        try { preguntado = readAsked(dir) } catch (e) {
+          console.log(`[vault] version ${r.version} is out, but what was already asked could not be read (${e?.message || e}) · not updating`)
+          return
+        }
+        const quienes = quienAprueba.map((a) => ({ profile: a.profile, id: a.id, label: a.label, notifiedAt: a.notifiedAt }))
+        if (!shouldAsk(preguntado, r.version, isNewer)) {
+          // Un «pendiente» que no es de este proceso es de antes de un reinicio: el pedido
+          // murió con él, y nadie puede contestarlo ya.
+          if (preguntado.result === 'pending') { preguntado = { ...preguntado, result: 'expired' }; writeAsked(dir, preguntado) }
+          const nuevo = pedidoSinRespuesta?.version !== preguntado.version || pedidoSinRespuesta?.result !== preguntado.result
+          pedidoSinRespuesta = { ...preguntado, approvers: quienes }
+          writeState()
+          if (nuevo) console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · approval for ${preguntado.version} was asked on ${new Date(preguntado.askedAt).toISOString()} and not given (${preguntado.result}) · not asking again until a newer version · install it with: dotrino-vault update`)
+          return
+        }
+        const askedAt = Date.now()
+        writeAsked(dir, { version: r.version, askedAt, result: 'pending' })
+        pedidoSinRespuesta = { version: r.version, askedAt, result: 'pending', approvers: quienes }
+        writeState()
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking ${quienAprueba.length} approver(s) across ${new Set(quienAprueba.map((a) => a.profileId)).size} profile(s), once · ${conAvisos} of them said notifications reach it`)
+        // Un pedido por perfil que tenga quien apruebe, a la vez. El primer sí basta, y los
+        // que queden vivos en los demás se retiran (`src/updateApproval.js`).
+        const conAprobador = new Set(quienAprueba.map((a) => a.profileId))
+        const si = await firstYes(enMarcha.filter((p) => conAprobador.has(p.id)).map((p) => p.vault.askUpdateApproval({ version: r.version })))
         if (!si) {
-          const antes = pedidoSinRespuesta?.version === r.version ? pedidoSinRespuesta : null
-          pedidoSinRespuesta = { version: r.version, since: antes?.since || Date.now(), asks: (antes?.asks || 0) + 1 }
+          const result = resultOfNo(askedAt, UPDATE_TTL_MS)
+          writeAsked(dir, { version: r.version, askedAt, result })
+          pedidoSinRespuesta = { version: r.version, askedAt, result, approvers: quienes }
           writeState()
-          console.log(`[vault] update to ${r.version}: not approved (denied or expired) · asked ${pedidoSinRespuesta.asks} time(s) since ${new Date(pedidoSinRespuesta.since).toISOString()} · it will ask again`)
+          console.log(`[vault] update to ${r.version}: not approved (${result}) · it will not ask again for this version · install it with: dotrino-vault update`)
           return
         }
-      } else if (enElActa.length) {
-        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · ${enElActa.length} approver(s) in the record but none receives notifications: updating on its own`)
+        aprobada = r.version
+      } else if (quienAprueba.length) {
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · already approved: installing`)
+      } else if (pedirPermiso) {
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · approval is on but no profile has an approver: updating on its own`)
       } else {
-        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · no approver in the record: updating on its own`)
+        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · updating on its own`)
       }
+      clearAsked(dir)
       if (pedidoSinRespuesta) { pedidoSinRespuesta = null; writeState() }
       const res = await installUserRelease(r, { log: (m) => console.log(m) })
       if (!res.ok) {
@@ -1171,6 +1227,12 @@ export async function runDaemon () {
       // minutos con el CLI y la TUI nuevos hablando con el daemon viejo; el dueño abrió la
       // TUI justo ahí y no arrancó (2026-09-24). Solo bajo systemd, que es quien nos levanta:
       // sin él, irnos sería quedarnos apagados.
+      // DEJAR DICHO QUE SE INSTALÓ, para que la versión nueva se lo cuente a quien aprueba al
+      // arrancar (`anunciarActualizacion`). Si no se puede escribir se dice: la actualización
+      // está hecha igual, lo que se pierde es el aviso.
+      try { ipcWrite(updatedFile, { v: 1, from: daemonVersion, to: r.version, at: Date.now() }) } catch (e) {
+        console.log(`[vault] update: ${r.version} installed, but the note to tell the approvers could not be written: ${e.message}`)
+      }
       if (vigia) {
         console.log(`[vault] update: ${r.version} installed · restarting now to run it`)
         shutdown(`updated to ${r.version}`)
@@ -1182,6 +1244,45 @@ export async function runDaemon () {
     } finally { actualizando = false }
   }
   let actualizando = false
+  let aprobada = null
+
+  /**
+   * «ME ACTUALICÉ»: se lo cuenta a quien aprueba la versión NUEVA, ya corriendo (dueño,
+   * 2026-10-08). Quien instaló —este daemon o `dotrino-vault update`— dejó `updated.json`;
+   * si dice la versión que corre ahora, cada perfil avisa a sus aprobadores en cuanto está
+   * identificado en el proxio, y el marcador se borra cuando salió en todos.
+   *
+   * No se borra lo que no se pudo leer ni lo que no salió: se dice y se reintenta. Un
+   * marcador de una versión ya superada sí se quita: esa noticia caducó.
+   */
+  const anunciarActualizacion = () => {
+    if (!fs.existsSync(updatedFile)) return
+    const m = ipcRead(updatedFile, null)
+    if (!m || typeof m.to !== 'string') { console.log('[vault] update: updated.json exists but cannot be read · the approvers were not told'); return }
+    if (m.to !== daemonVersion) {
+      if (isNewer(daemonVersion, m.to)) rm(updatedFile)
+      return   // todavía no corre esa versión: se anuncia cuando arranque
+    }
+    const hechos = new Set()
+    let intentos = 0
+    const intento = async () => {
+      intentos++
+      let falta = false
+      for (const p of perfilesEnMarcha()) {
+        if (hechos.has(p.id)) continue
+        if (!p.vault.isIdentified?.()) { falta = true; continue }
+        try { await p.vault.announceUpdate({ version: m.to, from: typeof m.from === 'string' ? m.from : null }); hechos.add(p.id) } catch (e) {
+          falta = true
+          if (intentos === 1 || intentos === ANNOUNCE_TRIES) console.log(`[vault] update: profile ${p.name} could not tell its approvers yet: ${e?.message || e}`)
+        }
+      }
+      if (!falta) { rm(updatedFile); return }
+      if (intentos >= ANNOUNCE_TRIES) { console.log('[vault] update: some approvers were not told · it will try again on the next start'); return }
+      setTimeout(intento, ANNOUNCE_EVERY_MS).unref?.()
+    }
+    setTimeout(intento, ANNOUNCE_EVERY_MS).unref?.()
+  }
+  anunciarActualizacion()
   mirarRelease()
   const relojRelease = setInterval(mirarRelease, CHECK_EVERY_MS)
   relojRelease.unref?.()

package/src/notices.js

@@ -0,0 +1,68 @@
+/**
+ * LO QUE LA BÓVEDA TIENE QUE CONTARLE A QUIEN APRUEBA, y que no es un pedido.
+ *
+ * Hoy es uno: «me actualicé» —la bóveda o uno de sus aparatos— (`ev: 'updated'`, dueño 2026-10-08: «las actualizaciones, que se
+ * envíe una notificación de que ocurrieron a los aprobadores»). Sale como aviso por el
+ * proxio, pero el timbre de una app nativa llega VACÍO —lo leen Google y Apple—, así que la
+ * app pregunta por su lista (`op: 'approvals'`) y lo lee de aquí, en `notices`.
+ *
+ * Caduca a las 24 h: es una noticia, no un registro (eso es la bitácora).
+ *
+ * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer se LANZA: callar
+ * sería decir «no pasó nada» de algo que sí pasó.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+export const NOTICES_FILE = 'notices.json'
+/** Cuánto se sigue contando un aviso. */
+export const NOTICE_TTL_MS = 24 * 60 * 60 * 1000
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ dir: string, atRest: { encrypt: (s: string) => string, decrypt: (s: string) => string }, now?: () => number }} opts
+ */
+export function openNotices ({ dir, atRest, now = Date.now }) {
+  const file = path.join(dir, NOTICES_FILE)
+  let items = load()
+
+  function load () {
+    if (!fs.existsSync(file)) return []
+    try {
+      const d = JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8')))
+      if (!d || !Array.isArray(d.items)) throw new Error('not a list')
+      return d.items.filter((n) => n && typeof n.id === 'string' && typeof n.ts === 'number')
+    } catch (e) { throw fail('notices-unreadable', `${NOTICES_FILE} cannot be read: ${e.message}`) }
+  }
+
+  function save () {
+    const tmp = file + '.tmp'
+    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items })), { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  }
+
+  const alive = (n) => now() - n.ts < NOTICE_TTL_MS
+
+  return {
+    /**
+     * Apunta que algo se actualizó. Devuelve el aviso tal como viaja. `product`: qué
+     * (`@dotrino/vaultd` es la propia bóveda); `deviceId`/`label`: el aparato, si fue uno.
+     */
+    updated ({ version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null }) {
+      if (typeof version !== 'string' || !version) throw fail('bad-notice', 'updated: a version is required')
+      if (typeof product !== 'string' || !product) throw fail('bad-notice', 'updated: a product is required')
+      const n = {
+        id: crypto.randomBytes(8).toString('hex'), ev: 'updated', product, version, from: typeof from === 'string' ? from : null,
+        ...(typeof deviceId === 'string' && deviceId ? { deviceId, label: typeof label === 'string' ? label : '' } : {}),
+        ts: now()
+      }
+      items = [...items.filter(alive), n]
+      save()
+      return n
+    },
+    /** Los avisos vivos, del más viejo al más nuevo. */
+    list () { return items.filter(alive).map((n) => ({ ...n })) }
+  }
+}

package/src/notifiable.js

@@ -2,24 +2,25 @@
  * QUÉ APROBADORES PUEDEN RECIBIR UN AVISO: lo dice cada uno, y caduca.
  *
  * Un aparato con `approve` que no recibe avisos es un aprobador solo en el papel: el pedido
- * no le suena y solo lo ve si abre la app por su cuenta. Para la ACTUALIZACIÓN eso era un
- * bloqueo mudo — la bóveda pedía cada día, nadie se enteraba y se quedaba atrás para siempre
- * (dueño, 2026-10-07).
+ * no le suena y solo lo ve si abre la app por su cuenta.
  *
  * Así que el aprobador lo declara: al pedir su lista de pedidos (`op: 'approvals'`, que ya
  * manda firmado cada vez que se abre) dice `notify: true` si tiene los avisos encendidos.
  * Aquí se apunta CUÁNDO lo dijo por última vez, y vale `NOTIFIABLE_TTL_MS`: una app que se
- * desinstala deja de renovarlo y sale sola de la cuenta.
+ * desinstala deja de renovarlo.
  *
- * SOLO DECIDE LA ACTUALIZACIÓN. Las claves, las contraseñas y guardar variables siguen
- * pidiendo aprobación mientras haya un aparato con `approve` en el acta, pueda o no recibir
- * avisos: ahí «nadie se entera» se resuelve esperando, no entregando.
+ * NO DECIDE NADA: SE ENSEÑA (dueño, 2026-10-08). Un día decidió si la bóveda pedía permiso
+ * para actualizarse —sin nadie que lo hubiera dicho, se actualizaba sola— y se quitó: era
+ * una condición más, y el silencio de un aprobador abría la puerta. Quién aprueba lo dice
+ * el acta y nada más; los avisos salen a todos los que tienen `approve`, lo hayan dicho o
+ * no. Esto sirve para VER a cuál no le está sonando el pedido (`members`, `status`, la
+ * consola).
  *
  * Y NO SE LE PREGUNTA AL PROXIO, que es quien guarda las suscripciones: es la pieza de la
  * que el diseño no se fía, y creerle sería dejarle decidir cuándo no hace falta permiso.
  *
  * Cifrado en reposo como lo demás. Un archivo que existe y no se puede leer NO es «nadie
- * puede recibir avisos» (eso saltaría la aprobación): se lanza.
+ * puede recibir avisos»: se lanza.
  */
 import fs from 'node:fs'
 import path from 'node:path'