@dotrino/vaultd 0.146.0 → 0.148.0

package/lib/src/service.js

@@ -620,6 +620,173 @@ 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 function reportUpdated (o = {}) { return reportToVault('update-done', o) }
+
+/**
+ * HAY VERSIÓN NUEVA Y NO PUEDO INSTALARLA SOLO: necesita permisos de administrador (el
+ * servicio está instalado para todo el sistema, no como usuario). El aparato se lo dice a su
+ * bóveda y ella avisa a quien aprueba, que es quien puede ir a esa máquina e instalarla a
+ * mano (dueño, 2026-10-08). No instala nada ni pide permiso: solo avisa.
+ *
+ * Mismos parámetros y errores que `reportUpdated`. Avisar una sola vez por versión es cosa
+ * de quien llama.
+ * @returns {Promise<{ ok: true }>}
+ */
+export function reportUpdateNeedsRoot (o = {}) { return reportToVault('update-needs-root', o) }
+
+/**
+ * LOS TRES GANCHOS DE ACTUALIZACIÓN, YA ARMADOS para pasárselos a `watchSelfUpdateNpm` de
+ * `@dotrino/update/npm`: una pieza, para que cada agente no lo escriba por su cuenta. No
+ * depende de ese paquete: solo devuelve funciones con la forma que él espera.
+ *
+ *   · `mayUpdate({ version, from })` → pregunta a la bóveda y devuelve si se puede. Si la
+ *     bóveda NO CONTESTA, lanza: para quien llama eso es «no pude preguntar» y se reintenta.
+ *     Si el pedido VENCE sin respuesta devuelve `false`: vencido es no, y no se repite.
+ *   · `onUpdated({ version, from })` → le dice a la bóveda que se actualizó. Deja pasar el
+ *     error, para que quien llama conserve su marcador y lo reintente.
+ *   · `onNeedsRoot({ version, from })` → le dice que hay versión nueva y necesita permisos de
+ *     administrador. Igual.
+ *
+ * @param {object} o
+ * @param {string} o.product  nombre npm de la pieza
+ * @param {(m: string) => void} [o.log]
+ *   …y la conexión como en los demás: `dir`, o `proxyUrl` + `masterPubkey` + `device` + `cert`.
+ * @returns {{ mayUpdate: (u: { version: string, from?: string }) => Promise<boolean>,
+ *   onUpdated: (u: { version: string, from?: string }) => Promise<void>,
+ *   onNeedsRoot: (u: { version: string, from?: string }) => Promise<void> }}
+ */
+export function vaultUpdateHooks ({ product, log = () => {}, dir, proxyUrl, masterPubkey, device, cert, _ask = askUpdateApproval, _done = reportUpdated, _root = reportUpdateNeedsRoot } = {}) {
+  if (typeof product !== 'string' || !product) throw new Error('vaultUpdateHooks: needs product')
+  const conn = { dir, proxyUrl, masterPubkey, device, cert }
+  return {
+    async mayUpdate ({ version, from = null } = {}) {
+      let r
+      try { r = await _ask({ ...conn, product, version, from, onPending: () => log(`[update] ${product} ${version}: waiting for approval on your vault`) }) } catch (e) {
+        if (e?.code === 'unanswered') { log(`[update] ${product} ${version}: nobody answered in time, so it is a no`); return false }
+        throw e
+      }
+      log(`[update] ${product} ${version}: ${r.ok ? (r.asked ? 'approved' : 'no approval needed') : 'not approved'}`)
+      return r.ok === true
+    },
+    async onUpdated ({ version, from = null } = {}) { await _done({ ...conn, product, version, from }) },
+    async onNeedsRoot ({ version, from = null } = {}) { await _root({ ...conn, product, version, from }) }
+  }
+}
+
+/** Lo común de los dos avisos: firmar, mandar, y comprobar quién contesta. */
+async function reportToVault (op, { 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(`${op}: 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, 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 === op && 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(`${op}: 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 ${op} 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.146.0",
+  "version": "0.148.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 '' }
@@ -158,15 +162,22 @@ 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', a.id, a.label || '(sin nombre)', avisosTxt(a.notifiedAt))
+      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í.
@@ -1813,6 +1824,18 @@ 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.
@@ -1823,7 +1846,7 @@ async function cmdUpdate (args = []) {
     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»).'
+      ? '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
   }
@@ -1858,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
   }
@@ -1897,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')
 }
 
@@ -2209,7 +2234,8 @@ function help () {
                      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» · sin valor, dice cómo está
+                     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

@@ -28,10 +28,15 @@ 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, readRootTold, writeRootTold, shouldTellRoot } 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.
@@ -90,13 +95,18 @@ 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
@@ -1131,11 +1141,16 @@ export async function runDaemon () {
       console.log(`[vault] version ${r.version} is out, but the settings could not be read (${e?.message || e}) · not updating`)
       return
     }
-    // Y si hay que pedir y no se puede saber a quién, tampoco: lista vacía sería «nadie
-    // aprueba, adelante», el repliegue que abre la puerta justo cuando algo se rompió.
+    // 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 mgr.current().approvers() } catch (e) {
+      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
       }
@@ -1146,31 +1161,79 @@ export async function runDaemon () {
     // proceso no puede tocarlo. Se dice, con las dos salidas, y no se intenta nada.
     if (!isUserInstall()) {
       console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · installed as a system package, so it cannot update itself: \`dotrino-vault update\` (needs sudo), or move to a user install with the tarball's install.sh`)
+      // …Y SE LE DICE A QUIEN APRUEBA, en todos los perfiles (dueño, 2026-10-08: «si se
+      // requiere root por algún motivo, simplemente se notifica al aprobador que hay
+      // actualización y necesita root»). El log no lo lee nadie; el teléfono sí. UNA vez por
+      // versión, apuntado para que un reinicio no lo repita (`update-root-told.json`).
+      let dicho
+      try { dicho = readRootTold(dir) } catch (e) {
+        console.log(`[vault] update: whether the approvers were already told could not be read (${e?.message || e}) · not telling them again`)
+        return
+      }
+      if (shouldTellRoot(dicho, r.version, isNewer) && avisandoRoot !== r.version) {
+        avisandoRoot = r.version
+        contarATodos({ ev: 'update-needs-root', version: r.version, from: daemonVersion }, ({ todos, alguno }) => {
+          avisandoRoot = null
+          // Con que salió en algún perfil ya está dicho: repetirlo mañana a los que sí lo
+          // oyeron por uno que no pudo sería timbrar de más.
+          if (todos || alguno) { try { writeRootTold(dir, { version: r.version, at: Date.now() }) } catch (e) { console.log(`[vault] update: could not note that the approvers were told: ${e.message}`) } }
+          else console.log(`[vault] update: the approvers could not be told that ${r.version} needs administrator rights · it will try again on the next check`)
+        })
+      }
       return
     }
     if (actualizando) return
     actualizando = true
     try {
-      if (quienAprueba.length) {
-        console.log(`[vault] version ${r.version} is out (this one is ${daemonVersion}) · asking one of ${quienAprueba.length} approver(s) · ${conAvisos} of them said notifications reach it`)
-        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,
-            // A QUIÉN SE LE PIDIÓ, y si dijo que le llegan los avisos: es lo que hay que mirar
-            // cuando nadie contesta.
-            approvers: quienAprueba.map((a) => ({ id: a.id, label: a.label, notifiedAt: a.notifiedAt }))
-          }
+          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
         }
+        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 approver in the record: updating on its own`)
+        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}) · updating on its own`)
       }
+      clearAsked(dir)
       if (pedidoSinRespuesta) { pedidoSinRespuesta = null; writeState() }
       const res = await installUserRelease(r, { log: (m) => console.log(m) })
       if (!res.ok) {
@@ -1183,6 +1246,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}`)
@@ -1194,6 +1263,58 @@ export async function runDaemon () {
     } finally { actualizando = false }
   }
   let actualizando = false
+  let aprobada = null
+  let avisandoRoot = 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
+    }
+    contarATodos({ version: m.to, from: typeof m.from === 'string' ? m.from : null }, ({ todos }) => {
+      if (todos) rm(updatedFile)
+      else console.log('[vault] update: some approvers were not told · it will try again on the next start')
+    })
+  }
+
+  /**
+   * Cuenta algo a quien aprueba en TODOS los perfiles en marcha (`announceUpdate`), cada uno
+   * en cuanto está identificado en el proxio: reintenta cada pocos segundos hasta que salió
+   * en todos o se agotan los intentos. `alTerminar({ todos, alguno })`.
+   */
+  function contarATodos (aviso, alTerminar) {
+    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(aviso); 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) return alTerminar({ todos: true, alguno: hechos.size > 0 })
+      if (intentos >= ANNOUNCE_TRIES) return alTerminar({ todos: false, alguno: hechos.size > 0 })
+      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,75 @@
+/**
+ * LO QUE LA BÓVEDA TIENE QUE CONTARLE A QUIEN APRUEBA, y que no es un pedido.
+ *
+ * Son dos, de la bóveda o de uno de sus aparatos: «me actualicé» y «hay versión nueva y
+ * necesita permisos de administrador: instálala a mano» (`update-needs-root`). (`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
+/** Los avisos que existen. */
+export const NOTICE_EVS = ['updated', 'update-needs-root']
+
+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 un aviso y lo devuelve tal como viaja. `ev`: `updated` (se actualizó) o
+     * `update-needs-root` (hay versión nueva y hay que instalarla a mano, con permisos de
+     * administrador). `product`: qué (`@dotrino/vaultd` es la propia bóveda);
+     * `deviceId`/`label`: el aparato, si fue uno.
+     */
+    add (ev, { version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null }) {
+      if (!NOTICE_EVS.includes(ev)) throw fail('bad-notice', `unknown notice: ${ev}`)
+      if (typeof version !== 'string' || !version) throw fail('bad-notice', `${ev}: a version is required`)
+      if (typeof product !== 'string' || !product) throw fail('bad-notice', `${ev}: a product is required`)
+      const n = {
+        id: crypto.randomBytes(8).toString('hex'), ev, 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
+    },
+    updated (o) { return this.add('updated', o) },
+    /** Los avisos vivos, del más viejo al más nuevo. */
+    list () { return items.filter(alive).map((n) => ({ ...n })) }
+  }
+}

package/src/tui/app.js

@@ -36,6 +36,7 @@ import { createTerm, widthOf } from './term.js'
 import { qrToString } from '../qr.js'
 import { dict, otherLang, loadLang, saveLang } from './i18n.js'
 import * as vc from '../vaultControl.js'
+import { readSettings, writeSettings } from '../settings.js'
 import * as hw from '../hwkeys.js'
 import { VERSION } from '../version.js'
 import { DEVICE_CAPS } from '@dotrino/identity/acta'
@@ -338,6 +339,50 @@ function doorRows (st, t) {
   return rows
 }
 
+/**
+ * AJUSTES DE LA BÓVEDA (no de un perfil). Cada regla se lee como una frase con su estado, y
+ * Enter la cambia. Hoy hay una: pedir aprobación para actualizarse.
+ *
+ * `st.settings` es lo leído al entrar: `{ updateApproval }`, o `{ error }` si el ajuste no se
+ * pudo leer — que se DICE, no se pinta como apagado: apagado es «se actualiza sola».
+ */
+const settingsDir = (st) => st.settingsDir || vc.vaultDir()
+function loadSettings (st) {
+  try { st.settings = readSettings(settingsDir(st)) } catch (e) { st.settings = { error: e?.message || String(e) } }
+}
+function settingsRows (st, t) {
+  const i = L(st)
+  const cfg = st.settings
+  if (!cfg) return [{ text: t.muted(' —'), sel: false }]
+  const rows = []
+  if (cfg.error) {
+    rows.push({ text: ' ' + t.warn(i.settingsUnreadable), sel: false })
+    rows.push({ text: t.muted('   ' + i.settingsUnreadableHint), sel: false })
+    rows.push({ text: '', sel: false })
+  }
+  const frase = cfg.error ? i.settingUpdateUnknown : cfg.updateApproval ? i.settingUpdateAsks : i.settingUpdateAlone
+  rows.push({ text: ` ${t.bold(frase)}   ${t.accent(i.settingChange)}`, sel: true, meta: { setting: 'updateApproval' } })
+  rows.push({ text: t.muted('   ' + i.settingUpdateHint1), sel: false })
+  rows.push({ text: t.muted('   ' + i.settingUpdateHint2), sel: false })
+  return rows
+}
+async function onKeySettings (term, st, key) {
+  const i = L(st)
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+  if (key.name === 'escape' || ch === 'b') { st.screen = 'profiles'; return true }
+  if (key.name === 'enter' || (key.name === 'char' && key.ch === ' ')) {
+    // Con el ajuste ilegible, Enter lo ESCRIBE de nuevo (encendido: es lo prudente cuando
+    // no se sabe qué había); así la pantalla también es la salida del atasco.
+    const next = st.settings?.error ? true : !st.settings?.updateApproval
+    try {
+      writeSettings(settingsDir(st), { updateApproval: next })
+      loadSettings(st)
+      flash(st, next ? i.settingUpdateNowAsks : i.settingUpdateNowAlone)
+    } catch (e) { flash(st, i.settingSaveFailed(e?.message || String(e)), 'danger') }
+  }
+  return true
+}
+
 function deviceRows (st, t) {
   const i = L(st)
   const rows = []
@@ -1204,6 +1249,11 @@ async function onKeyProfiles (term, st, key) {
       },
       onCancel: () => { st.input = null }
     }))
+  } else if (ch === 's') { // ajustes de la bóveda (no de un perfil: no hace falta elegir uno)
+    loadSettings(st)
+    st.sel.settings = 0
+    st.scroll.settings = { value: 0 }
+    st.screen = 'settings'
   } else if (ch === 'y' && cur) { // las llaves: con qué se abre la bóveda
     await ensureUnlocked(term, st, cur, async (p = cur) => {
       st.doorsFor = p.id
@@ -2308,6 +2358,7 @@ const helpSegs = (i, screen, st = {}) => {
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
     doors: i.helpDoors,
+    settings: i.helpSettings,
     paircaps: i.helpPairCaps,
     join: i.helpJoin,
     me: i.helpMe,
@@ -2343,6 +2394,7 @@ const title = (i, screen) => ({
   pairing: i.titlePairing,
   pairmode: i.titlePairMode,
   doors: i.titleDoors,
+  settings: i.titleSettings,
   paircaps: i.titlePairCaps,
   join: i.titleJoin,
   caps: i.titleCaps,
@@ -2443,10 +2495,15 @@ function render (term, st) {
   // instalar, peor: el daemon se queda con el binario viejo, ya borrado, y hay dos copias
   // en RAM). `status` ya lo avisa; aquí también, que es donde uno se queda mirando.
   lines[2] = (up && s?.version && VERSION !== 'dev' && s.version !== VERSION) ? ' ' + t.warn(i.daemonStale(s.version, VERSION)) : ''
-  // Una actualización que lleva tiempo pidiendo permiso sin respuesta: la bóveda parece
+  // Una actualización que pidió permiso (una vez por versión, dura un día): la bóveda parece
   // normal y simplemente no se actualiza, así que se dice aquí.
   if (!lines[2] && up && s?.updateAsk?.version) {
-    lines[2] = ' ' + t.warn(i.updateUnanswered(s.updateAsk.version, Math.floor((Date.now() - s.updateAsk.since) / 86400000)))
+    const u = s.updateAsk
+    const dia = (ms) => new Date(ms).toISOString().slice(0, 16).replace('T', ' ')
+    // Esperando es un estado normal (gris); no aprobada es lo que hay que ver (aviso).
+    lines[2] = ' ' + (u.result === 'pending'
+      ? t.muted(i.updateWaiting(u.version, dia(u.askedAt + 24 * 60 * 60 * 1000)))
+      : t.warn(i.updateNotApproved(u.version, dia(u.askedAt))))
   }
   // Dispositivos/Scopes son pestañas de la bóveda activa (se entra desde Bóvedas);
   // el resto muestra su título simple.
@@ -2468,6 +2525,7 @@ function render (term, st) {
   else if (st.screen === 'devvars') body = renderList(devVarRows(st, t), st.sel.devvars || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairmode') body = renderList(pairModeRows(st, t), st.sel.pairmode, contentH, cols, t, scrollRef)
   else if (st.screen === 'doors') body = renderList(doorRows(st, t), st.sel.doors || 0, contentH, cols, t, scrollRef)
+  else if (st.screen === 'settings') body = renderList(settingsRows(st, t), st.sel.settings || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'paircaps') body = renderList(pairCapsRows(st, t), st.sel.paircaps || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
@@ -2551,7 +2609,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, paircaps: 0, devvars: 0, logins: 0, doors: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, paircaps: 0, devvars: 0, logins: 0, doors: 0, settings: 0 },
     // Permisos tocados y sin guardar, por llave del aparato (ver `setCapsDraft`).
     capsDrafts: {},
     // Las bóvedas que ha abierto ESTA sesión, para volver a cerrarlas al salir.
@@ -2658,6 +2716,7 @@ export async function runTui () {
       else if (st.screen === 'devvars') running = await onKeyDevVars(term, st, key)
       else if (st.screen === 'pairmode') running = await onKeyPairMode(term, st, key)
       else if (st.screen === 'doors') running = await onKeyDoors(term, st, key)
+      else if (st.screen === 'settings') running = await onKeySettings(term, st, key)
       else if (st.screen === 'paircaps') running = await onKeyPairCaps(term, st, key)
       else if (st.screen === 'pairing') running = await onKeyPairing(term, st, key)
       else if (st.screen === 'join') running = await onKeyJoin(term, st, key)
@@ -2675,4 +2734,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, doorRows, onKeyDoors, pairCapsRows, onKeyPairCaps, onKeyDevices, draftChanges, saveCapsDrafts, 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 } }
+export const __test = { render, settingsRows, onKeySettings, doorRows, onKeyDoors, pairCapsRows, onKeyPairCaps, onKeyDevices, draftChanges, saveCapsDrafts, 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

@@ -26,7 +26,8 @@ const es = {
   // encabezado / estado
   daemonRunning: 'corriendo',
   daemonStopped: 'DETENIDO',
-  updateUnanswered: (version, days) => `⬆ la ${version} espera tu aprobación desde hace ${days < 1 ? 'menos de un día' : days === 1 ? '1 día' : days + ' días'}: mira Pedidos en tu teléfono`,
+  updateWaiting: (version, until) => `⬆ la ${version} espera tu aprobación hasta ${until} UTC: mira Pedidos en tu teléfono`,
+  updateNotApproved: (version, when) => `⬆ se pidió permiso para la ${version} el ${when} UTC y no se aprobó: no se vuelve a pedir · dotrino-vault update`,
   daemonStale: (running, installed) => `⚠ el servicio corre ${running} y el binario instalado es ${installed}: reinícialo (systemctl --user restart dotrino-vault)`,
   activeVault: 'Bóveda activa: ',
   noName: '(sin nombre)',
@@ -169,6 +170,18 @@ const es = {
   titlePairing: 'Emparejar un dispositivo',
   titlePairMode: 'Emparejar: ¿a qué cuenta entra?',
   titleDoors: 'Con qué se abre la bóveda',
+  titleSettings: 'Ajustes de esta bóveda',
+  settingUpdateAlone: 'Esta bóveda se actualiza sola, sin pedir aprobación.',
+  settingUpdateAsks: 'Esta bóveda pide aprobación antes de actualizarse.',
+  settingUpdateUnknown: 'No se sabe si esta bóveda pide aprobación para actualizarse.',
+  settingChange: 'Enter cambiar',
+  settingUpdateHint1: 'Vale para todos los perfiles: se pide a los aparatos con «aprueba» de cualquiera de ellos, una vez por versión.',
+  settingUpdateHint2: 'Si ningún perfil tiene un aparato con «aprueba», la bóveda se actualiza sola.',
+  settingsUnreadable: 'El ajuste no se pudo leer: mientras siga así, la bóveda no se actualiza.',
+  settingsUnreadableHint: 'Pulsa Enter para volver a guardarlo (queda pidiendo aprobación; Enter otra vez lo cambia).',
+  settingUpdateNowAsks: 'Hecho: pide aprobación antes de actualizarse.',
+  settingUpdateNowAlone: 'Hecho: se actualiza sola.',
+  settingSaveFailed: (m) => `No se pudo guardar el ajuste: ${m}`,
   doorsIntro: (name) => `Con qué se abre «${name}». Abre cualquiera de estas.`,
   doorsNone: 'Sin candado: se abre sola en esta máquina.',
   doorPassword: 'contraseña',
@@ -416,7 +429,7 @@ const es = {
   // INGLÉS: new/rename/delete/password/unlock/locK/pair/approve/revoke/refresh/
   // language/quit); lo único que se traduce es la palabra que las explica.
   // Segmentos, no una línea: si no caben en una, el render los reparte en varias.
-  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'j unirse', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'y llaves', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
+  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'j unirse', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'y llaves', 'u desbloq', 'k bloquear', 's ajustes', 'l English', 'q salir'],
   // La barra dice lo que se PUEDE hacer AHORA, no todo lo que existe: aprobar/rechazar solo
   // valen si hay alguien esperando, y renombrar/revocar solo si hay un aparato seleccionado.
   // Anunciar teclas muertas confunde y además las quema para otros usos.
@@ -454,6 +467,7 @@ const es = {
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', '↑↓ scroll', 'Esc atrás', 'l English'],
   helpPairMode: ['↑↓', 'Enter elegir', 'Esc atrás', 'l English', 'q salir'],
   helpDoors: ['↑↓', 'Enter añadir', 'd quitar', 'Esc atrás', 'l English', 'q salir'],
+  helpSettings: ['Enter cambiar', 'Esc atrás', 'l English', 'q salir'],
   helpJoin: ['Esc bóvedas', 'l English', 'q salir'],
 
   // pantalla "daemon caído"
@@ -501,7 +515,8 @@ const en = {
 
   daemonRunning: 'running',
   daemonStopped: 'STOPPED',
-  updateUnanswered: (version, days) => `⬆ ${version} has been waiting for your approval for ${days < 1 ? 'less than a day' : days === 1 ? '1 day' : days + ' days'}: check Requests on your phone`,
+  updateWaiting: (version, until) => `⬆ ${version} is waiting for your approval until ${until} UTC: check Requests on your phone`,
+  updateNotApproved: (version, when) => `⬆ approval for ${version} was asked on ${when} UTC and not given: it will not ask again · dotrino-vault update`,
   daemonStale: (running, installed) => `⚠ the service runs ${running} but the installed binary is ${installed}: restart it (systemctl --user restart dotrino-vault)`,
   activeVault: 'Active vault: ',
   tooSmall: 'Terminal too small',
@@ -624,6 +639,18 @@ const en = {
   titlePairing: 'Pair a device',
   titlePairMode: 'Pairing: which account does it join?',
   titleDoors: 'What opens this vault',
+  titleSettings: 'Settings of this vault',
+  settingUpdateAlone: 'This vault updates on its own, without asking for approval.',
+  settingUpdateAsks: 'This vault asks for approval before updating.',
+  settingUpdateUnknown: 'It is not known whether this vault asks for approval to update.',
+  settingChange: 'Enter change',
+  settingUpdateHint1: 'It applies to every profile: devices with “approve” in any of them are asked, once per version.',
+  settingUpdateHint2: 'If no profile has a device with “approve”, the vault updates on its own.',
+  settingsUnreadable: 'The setting could not be read: while it stays like this, the vault does not update.',
+  settingsUnreadableHint: 'Press Enter to save it again (it will ask for approval; Enter again changes it).',
+  settingUpdateNowAsks: 'Done: it asks for approval before updating.',
+  settingUpdateNowAlone: 'Done: it updates on its own.',
+  settingSaveFailed: (m) => `The setting could not be saved: ${m}`,
   doorsIntro: (name) => `What opens “${name}”. Any of these opens it.`,
   doorsNone: 'No lock: it opens by itself on this machine.',
   doorPassword: 'password',
@@ -847,7 +874,7 @@ const en = {
   helpInput: 'Enter confirm · Esc cancel · Ctrl-U clear',
   helpConfirm: 'y confirm · n/Esc cancel',
 
-  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'y keys', 'u unlock', 'k lock', 'l Español', 'q quit'],
+  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'y keys', 'u unlock', 'k lock', 's settings', 'l Español', 'q quit'],
   helpDevices: ({ pending, hasDevices, isService, drafts, curBlocked } = {}) => [
     '←→ tab', '↑↓', 'p pair',
     ...(drafts ? ['g save permissions'] : []),
@@ -879,6 +906,7 @@ const en = {
   helpPairing: ['a approve', 'x reject', 'r restart', '↑↓ scroll', 'Esc back', 'l Español'],
   helpPairMode: ['↑↓', 'Enter choose', 'Esc back', 'l Español', 'q quit'],
   helpDoors: ['↑↓', 'Enter add', 'd remove', 'Esc back', 'l Español', 'q quit'],
+  helpSettings: ['Enter change', 'Esc back', 'l Español', 'q quit'],
   helpJoin: ['Esc vaults', 'l Español', 'q quit'],
 
   downTitle: 'The vault daemon is not running.',

package/src/updateApproval.js

@@ -0,0 +1,139 @@
+/**
+ * PEDIR PERMISO PARA ACTUALIZARSE, EN TODOS LOS PERFILES A LA VEZ.
+ *
+ * El ajuste es de la BÓVEDA, no de un perfil (dueño, 2026-10-08): «si se activa funciona si
+ * cualquier perfil tiene aprobador, afecta a todos los perfiles y se envía notificación a
+ * todos los perfiles». El binario es uno solo, así que quien aprueba en cualquiera de las
+ * cuentas que viven aquí decide por la máquina.
+ *
+ * Sin estado y sin red: recibe los perfiles en marcha y lo que cada uno sabe hacer, para
+ * poder probarse sin daemon (`test/actualizar-todos-los-perfiles.test.mjs`).
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { ipcRead, ipcWrite } from './ipc.js'
+
+/**
+ * Quién aprueba, en todos los perfiles. SI UNO NO SE PUEDE LEER, SE LANZA: una lista a medias
+ * sería decidir con menos aprobadores de los que hay, que es el repliegue que abre la puerta
+ * justo cuando algo se rompió.
+ * @param {{ id: string, name?: string, vault: { approvers: () => Promise<any[]> } }[]} profiles
+ * @returns {Promise<{ profile: string, profileId: string, id: string, label: string, pub: string, notifiedAt: number|null }[]>}
+ */
+export async function approversOfAll (profiles) {
+  const out = []
+  for (const p of profiles) {
+    let list
+    try { list = await p.vault.approvers() } catch (e) {
+      throw Object.assign(new Error(`profile ${p.name || p.id}: ${e?.message || e}`), { code: 'approvers-unreadable' })
+    }
+    for (const a of list) out.push({ ...a, profile: p.name || p.id, profileId: p.id })
+  }
+  return out
+}
+
+/**
+ * Pide en cada perfil y espera: EL PRIMER «SÍ» BASTA; es «no» cuando todos dijeron que no o
+ * vencieron. Al resolverse se RETIRAN los pedidos que quedaron vivos en los demás, para que
+ * no se queden un día en la lista de quien aprueba pidiendo algo que ya se decidió.
+ * @param {{ answer: Promise<boolean>, withdraw: () => void }[]} asks
+ * @returns {Promise<boolean>}
+ */
+export function firstYes (asks) {
+  if (!asks.length) return Promise.resolve(false)
+  return new Promise((resolve) => {
+    let left = asks.length
+    let done = false
+    const finish = (ok, winner) => {
+      if (done) return
+      done = true
+      for (const a of asks) { if (a !== winner) { try { a.withdraw() } catch (_) { /* retirar es limpieza: no cambia la respuesta */ } } }
+      resolve(ok)
+    }
+    for (const a of asks) {
+      Promise.resolve(a.answer).then((ok) => {
+        if (ok === true) return finish(true, a)
+        if (--left === 0) finish(false, null)
+      }, () => { if (--left === 0) finish(false, null) })
+    }
+  })
+}
+
+/**
+ * EL PEDIDO SE HACE UNA VEZ POR VERSIÓN (dueño, 2026-10-08): «dura un día, pero se hace una
+ * sola vez; no se reintenta al siguiente día; se asume negado si no se hizo en 24 horas; se
+ * dispara nuevamente en la siguiente actualización».
+ *
+ * Así que se apunta QUÉ versión se preguntó, AL PEDIR, y sobrevive a un reinicio: una bóveda
+ * que se reinicia con el pedido a medias no vuelve a timbrar por lo mismo. Va por el canal
+ * local (cifrado en reposo), junto al resto del estado del daemon.
+ *
+ * UN ARCHIVO QUE EXISTE Y NO SE PUEDE LEER NO ES «NUNCA SE PREGUNTÓ» —eso volvería a pedir— ni
+ * tampoco «ya se aprobó»: se lanza, y quien llama no actualiza y lo dice.
+ */
+
+export const ASKED_FILE = 'update-asked.json'
+const RESULTS = ['pending', 'denied', 'expired']
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/** @returns {{ version: string, askedAt: number, result: 'pending'|'denied'|'expired' } | null} */
+export function readAsked (dir) {
+  const file = path.join(dir, ASKED_FILE)
+  if (!fs.existsSync(file)) return null
+  const d = ipcRead(file, null)
+  if (!d || typeof d.version !== 'string' || !d.version || typeof d.askedAt !== 'number' || !RESULTS.includes(d.result)) {
+    throw fail('asked-unreadable', `${ASKED_FILE} exists but cannot be read`)
+  }
+  return { version: d.version, askedAt: d.askedAt, result: d.result }
+}
+
+export function writeAsked (dir, { version, askedAt, result }) {
+  if (typeof version !== 'string' || !version || typeof askedAt !== 'number' || !RESULTS.includes(result)) throw fail('bad-asked', 'writeAsked: version, askedAt and a known result are required')
+  ipcWrite(path.join(dir, ASKED_FILE), { v: 1, version, askedAt, result })
+}
+
+/** Ya se instaló (o ya no hace falta preguntar): se olvida lo preguntado. */
+export function clearAsked (dir) { fs.rmSync(path.join(dir, ASKED_FILE), { force: true }) }
+
+/**
+ * ¿Hay que pedir permiso por `version`? Solo si nunca se preguntó, o si es MÁS NUEVA que la
+ * que se preguntó. La misma (o una anterior) ya tuvo su pedido: no se repite.
+ * @param {(a: string, b: string) => boolean} isNewer  `isNewer(a, b)`: a es más nueva que b
+ */
+export function shouldAsk (asked, version, isNewer) {
+  return !asked || isNewer(version, asked.version)
+}
+
+/** Un «no» que llega cuando el pedido ya cumplió su día es un vencimiento; antes, alguien lo denegó. */
+export function resultOfNo (askedAt, ttlMs, now = Date.now()) {
+  return now - askedAt >= ttlMs - 60_000 ? 'expired' : 'denied'
+}
+
+/**
+ * «NECESITO PERMISOS DE ADMINISTRADOR» SE DICE UNA VEZ POR VERSIÓN. Una bóveda instalada como
+ * paquete del sistema no puede cambiarse el binario: avisa a quien aprueba y espera a que
+ * alguien la instale a mano. Sin apuntarlo, lo repetiría en cada pasada y en cada reinicio.
+ *
+ * Mismas reglas que lo preguntado: sobrevive al reinicio, y un archivo que existe y no se
+ * puede leer se LANZA (ni «ya se dijo» ni «dilo otra vez»).
+ */
+export const ROOT_TOLD_FILE = 'update-root-told.json'
+
+/** @returns {{ version: string, at: number } | null} */
+export function readRootTold (dir) {
+  const file = path.join(dir, ROOT_TOLD_FILE)
+  if (!fs.existsSync(file)) return null
+  const d = ipcRead(file, null)
+  if (!d || typeof d.version !== 'string' || !d.version || typeof d.at !== 'number') throw fail('root-told-unreadable', `${ROOT_TOLD_FILE} exists but cannot be read`)
+  return { version: d.version, at: d.at }
+}
+
+export function writeRootTold (dir, { version, at }) {
+  if (typeof version !== 'string' || !version || typeof at !== 'number') throw fail('bad-root-told', 'writeRootTold: version and at are required')
+  ipcWrite(path.join(dir, ROOT_TOLD_FILE), { v: 1, version, at })
+}
+
+/** ¿Hay que avisar por `version`? Solo si nunca se avisó, o si es MÁS NUEVA que la avisada. */
+export function shouldTellRoot (told, version, isNewer) {
+  return !told || isNewer(version, told.version)
+}

package/src/vault.js

@@ -31,6 +31,7 @@ import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER }
 import { openSubacta } from './subacta.js'
 import { openBlocked } from './blocked.js'
 import { openNotifiable } from './notifiable.js'
+import { openNotices } from './notices.js'
 import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.js'
 import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
@@ -265,6 +266,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const blocked = openBlocked({ dir, atRest: passwordsAtRest })
   // Qué aprobadores dijeron que pueden recibir avisos (`src/notifiable.js`). No decide nada: se enseña.
   const notifiable = openNotifiable({ dir, atRest: passwordsAtRest })
+  // Lo que hay que contarle a quien aprueba y no es un pedido (`src/notices.js`): hoy, «me actualicé».
+  const notices = openNotices({ dir, atRest: passwordsAtRest })
   const readPasswordsFile = () => {
     try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
   }
@@ -1526,6 +1529,127 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
   }
 
+  /**
+   * UN APARATO PREGUNTA SI PUEDE ACTUALIZARSE (`op: 'update-ask'`, dueño 2026-10-08).
+   *
+   * Pedir aprobación es un interruptor DE CADA AGENTE, independiente del de la bóveda
+   * (`updateApproval` de `src/settings.js` vale solo para la propia bóveda): el agente solo
+   * manda esto cuando lo tiene encendido. Así que aquí no se consulta ningún ajuste:
+   *
+   *   · alguien aprueba en este perfil → un pedido `kind: 'update'` a nombre del aparato, que
+   *     dura un día; se contesta «pendiente» y el resultado sale cuando alguien decide, por
+   *     donde vino la pregunta. Vencido es no.
+   *   · nadie aprueba → sí, sin preguntar: esperar un sí que nadie puede dar sería no
+   *     actualizarse nunca.
+   *
+   * Lo puede preguntar cualquier miembro del acta: no pide nada que no sea suyo.
+   */
+  const updateAsks = new Map()      // device|product|version → { id, dest } del pedido vivo
+  const updateDecisions = new Map() // device|product|version → { ok: true, exp }: lo ya aprobado
+  const cut = (v, n) => (typeof v === 'string' && v && v.length <= n ? v : null)
+  async function handleUpdateAsk (from, p) {
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      ...(await contextoActa()), revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'update-ask')
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (!record || !(record.members || []).some((m) => m.pub === chk.device)) {
+      audit('rejected', { what: 'update-ask', reason: record ? 'acta' : 'sin-acta' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
+    }
+    const product = cut(p.data?.product, 128)
+    const version = cut(p.data?.version, 64)
+    const fromVersion = cut(p.data?.from, 64)
+    if (!product || !version) return reply(from, { type: MSG.ERROR, code: 'bad-request', error: 'update-ask: needs `product` and `version`' })
+    const deviceId = await deviceIdOf(chk.device).catch(() => null)
+    const say = async (dest, extra) => {
+      const body = { op: 'update-ask', product, version, ...extra, ts: Date.now() }
+      reply(dest, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
+    }
+
+    const approvers = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).length
+    if (!approvers) {
+      audit('update-ask', { device: deviceId, product, version, asked: false })
+      log(`[vault] update-ask: ${deviceId || '????-????'} may update ${product} to ${version} on its own (nobody approves in this profile)`)
+      return say(from, { ok: true, asked: false })
+    }
+
+    const key = `${chk.device}|${product}|${version}`
+    const now = Date.now()
+    for (const [k, d] of updateDecisions) if (d.exp <= now) updateDecisions.delete(k)
+    // YA SE DECIDIÓ y quien preguntó no estaba para oírlo: se le dice lo decidido en vez de
+    // volver a timbrar por lo mismo.
+    const decided = updateDecisions.get(key)
+    if (decided) return say(from, { ok: decided.ok, asked: true })
+    // YA HAY UN PEDIDO VIVO por esto mismo (el agente se reinició y vuelve a preguntar): no se
+    // timbra otra vez; la respuesta irá a quien pregunta ahora.
+    const vivo = updateAsks.get(key)
+    if (vivo && waiters.has(vivo.id)) {
+      vivo.dest = from
+      return say(from, { pending: true, id: vivo.id, exp: vivo.exp, asked: true })
+    }
+    const ask = { id: null, exp: null, dest: from }
+    let pend
+    try {
+      pend = await awaitApproval({
+        device: chk.device, ns: 'vault', kind: 'update', what: 'update',
+        ctx: { product, version, from: fromVersion }, ttlMs: UPDATE_TTL_MS,
+        onAnswer: async (ok) => {
+          updateAsks.delete(key)
+          // Solo se recuerda el SÍ. Un no puede ser un vencimiento (nadie lo vio), y
+          // recordarlo dejaría al aparato un día sin poder volver a preguntar.
+          if (ok === true) updateDecisions.set(key, { ok: true, exp: Date.now() + UPDATE_TTL_MS })
+          await say(ask.dest, { ok: ok === true, asked: true, id: ask.id })
+        }
+      })
+    } catch (e) {
+      log(`[vault] update-ask: could not ask for approval: ${e.message}`)
+      return reply(from, { type: MSG.ERROR, code: 'ask-failed', error: 'update-ask: could not ask for approval' })
+    }
+    ask.id = pend.id; ask.exp = pend.exp
+    updateAsks.set(key, ask)
+    return say(from, { pending: true, id: pend.id, exp: pend.exp, asked: true })
+  }
+
+  /**
+   * UN APARATO DICE QUE SE ACTUALIZÓ (`op: 'update-done'`): la bóveda se lo cuenta a quien
+   * aprueba en este perfil, por el mismo camino que su propio «me actualicé». Si el agente
+   * avisa o no lo decide él (su interruptor); aquí solo se reparte.
+   *
+   * Y su hermano `op: 'update-needs-root'`: el aparato vio una versión nueva y no puede
+   * instalarla solo porque necesita permisos de administrador. Mismo reparto, otro `ev`.
+   *
+   * QUIÉN ES lo dice el acta (id y nombre), no lo que el aparato cuente de sí mismo.
+   */
+  async function handleUpdateDone (from, p) {
+    const op = p.data.op
+    const ev = op === 'update-needs-root' ? 'update-needs-root' : 'updated'
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      ...(await contextoActa()), revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, op)
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    const member = (record?.members || []).find((m) => m.pub === chk.device)
+    if (!member) {
+      audit('rejected', { what: op, reason: record ? 'acta' : 'sin-acta' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this device is not in the record' })
+    }
+    const product = cut(p.data?.product, 128)
+    const version = cut(p.data?.version, 64)
+    if (!product || !version) return reply(from, { type: MSG.ERROR, code: 'bad-request', error: `${op}: needs \`product\` and \`version\`` })
+    const deviceId = await deviceIdOf(chk.device).catch(() => null)
+    try {
+      await announceUpdate({ ev, version, from: cut(p.data?.from, 64), product, deviceId, label: member.label || '' })
+    } catch (e) {
+      log(`[vault] ${op}: ${deviceId || '????-????'} reported ${product} ${version}, but the approvers could not be told: ${e.message}`)
+      return reply(from, { type: MSG.ERROR, code: e.code || 'announce-failed', error: `${op}: the approvers could not be told` })
+    }
+    const body = { op, ok: true, product, version, ts: Date.now() }
+    reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body), acta: record })
+  }
+
   const storeNonces = new Map()
   async function handleVarStore (from, p) {
     const ns = p.data?.ns
@@ -1593,6 +1717,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (p.data?.op === 'enckey') return handleEncKey(from, p)
     if (p.data?.op === 'store.recipients' || p.data?.op === 'store') return handleVarStore(from, p)
     if (p.data?.op === 'digest') return handleDigest(from, p)
+    if (p.data?.op === 'update-ask') return handleUpdateAsk(from, p)
+    if (p.data?.op === 'update-done' || p.data?.op === 'update-needs-root') return handleUpdateDone(from, p)
     if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke', 'block', 'blocked'].includes(p.data?.op)) return handleApproval(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
@@ -1772,7 +1898,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (op === 'approvals' && typeof p.data?.notify === 'boolean') {
       try { notifiable.declare(chk.device, p.data.notify) } catch (e) { log(`[vault] could not record whether ${by || '????-????'} can be notified: ${e.message}`) }
     }
-    if (op === 'approvals') return answer({ op: 'approvals', items: await conContextoSellado(approvals.list(), chk.device, record) })
+    // `notices`: lo que no es un pedido y quien aprueba tiene que saber (la bóveda se
+    // actualizó). El timbre de una app nativa llega vacío, así que lo lee de aquí.
+    if (op === 'approvals') return answer({ op: 'approvals', items: await conContextoSellado(approvals.list(), chk.device, record), notices: notices.list() })
     // LO QUE YA ESTÁ APROBADO SE VE Y SE CORTA DESDE DONDE SE APROBÓ. Una concesión que se
     // renueva con cada uso puede durar indefinidamente: si no se puede mirar ni quitar desde
     // el mismo sitio donde se dio, es un permiso invisible, y eso no lo damos por bueno.
@@ -1949,6 +2077,46 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     } catch (e) { log('[vault] could not notify approvers:', e.message) }
   }
 
+  /**
+   * «ME ACTUALICÉ», a todo el que aprueba (dueño, 2026-10-08). Vale con la aprobación
+   * encendida o apagada: lo que se instala solo también se cuenta.
+   *
+   * Lo manda la versión NUEVA ya corriendo —el daemon llama aquí al arrancar, si dejó dicho
+   * que instaló—, que es la prueba de que ocurrió. El aviso queda además en `notices`, de
+   * donde lo lee una app nativa (su timbre llega vacío).
+   *
+   * También reparte el «me actualicé» de un APARATO (`op: 'update-done'`): entonces lleva su
+   * `product`, `deviceId` y `label`.
+   *
+   * Y con `ev: 'update-needs-root'` cuenta lo contrario: hay versión nueva y NO se instaló
+   * sola porque necesita permisos de administrador (dueño, 2026-10-08: «si se requiere root
+   * por algún motivo, simplemente se notifica al aprobador»). Mismo camino, otro `ev`.
+   *
+   * A diferencia de `notifyApprovers`, aquí el fallo SE LANZA: quien llama guarda el
+   * marcador hasta que el aviso salió, y tragarlo sería borrarlo sin haber avisado.
+   * @returns {Promise<{ approvers: number, sent: number, notice: object|null }>}
+   */
+  async function announceUpdate ({ version, from = null, product = '@dotrino/vaultd', deviceId = null, label = null, ev = 'updated' }) {
+    const record = await refreshActa()
+    const who = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).map((m) => m.pub)
+    if (!who.length) return { approvers: 0, sent: 0, notice: null }
+    // `deviceId`/`label`: solo cuando quien se actualizó es un APARATO (`update-done`). El
+    // aviso de la propia bóveda no los lleva.
+    const notice = notices.add(ev, { version, from, product, ...(deviceId ? { deviceId, label: label || '' } : {}) })
+    const { id, ev: _ev, ts, ...rest } = notice
+    const body = { ev, id, ...rest, ts }
+    const seal = await sealOrFail(body)
+    let sent = 0
+    for (const pub of who) {
+      try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, seal }, { app: 'vault' }); sent++ }
+      catch (e) { log(`[vault] could not tell ${pub.slice(0, 24)}… about the update of ${product} to ${version}: ${e.message}`) }
+    }
+    audit(ev === 'updated' ? 'update.announced' : 'update.needs-root', { product, version, from: notice.from, device: deviceId, approvers: who.length, sent })
+    log(`[vault] update: told ${sent} of ${who.length} approver(s) that ${deviceId ? `${deviceId} (${product})` : 'this vault'} ${ev === 'updated' ? 'now runs' : 'needs administrator rights to install'} ${version}`)
+    if (!sent) throw Object.assign(new Error('no approver could be told'), { code: 'announce-failed' })
+    return { approvers: who.length, sent, notice }
+  }
+
   /**
    * UN INCIDENTE: un agente de la cuenta dice que OTRO aparato de la cuenta se equivocó de
    * clave tres veces seguidas (la terminal, `dotrino-terminal lock`). No se decide aquí
@@ -4020,17 +4188,32 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
      * PEDIR PERMISO PARA ACTUALIZARSE a `version` (la instala el daemon si se aprueba). Es
      * un pedido como los demás —sale en Pedidos del teléfono, `kind: 'update'`—, pero dura
      * un día (`UPDATE_TTL_MS`): no hay nadie esperando delante de una terminal.
-     * @returns {Promise<boolean>} sí o no; vencido es no.
+     * @returns {{ answer: Promise<boolean>, withdraw: () => void }} `answer`: sí o no (vencido
+     *   o retirado es no). `withdraw` quita el pedido si sigue vivo.
      */
-    askUpdateApproval: async ({ version }) => {
+    askUpdateApproval: ({ version }) => {
       const yo = identity.me?.publickey || null
-      return new Promise((resolve) => {
-        awaitApproval({
-          device: yo, ns: 'vault', kind: 'update', what: 'update',
-          ctx: { version, from: VERSION }, ttlMs: UPDATE_TTL_MS, onAnswer: resolve
-        }).catch((e) => { log(`[vault] update: could not ask for approval: ${e.message}`); resolve(false) })
-      })
+      let pendId = null
+      let withdrawn = false
+      let settle
+      const answer = new Promise((resolve) => { settle = resolve })
+      // RETIRAR: otro perfil ya contestó por la máquina, o ya no hace falta. El pedido sale
+      // de la lista de quien aprueba en vez de quedarse un día pidiendo algo ya decidido.
+      const retirar = () => {
+        if (!pendId || !waiters.delete(pendId)) return
+        const pend = approvals.take(pendId)
+        audit('update.withdrawn', { device: pend?.deviceId || null, ns: 'vault', id: pendId })
+        log(`[vault] update: request ${pendId} withdrawn`)
+        settle(false)
+      }
+      awaitApproval({
+        device: yo, ns: 'vault', kind: 'update', what: 'update',
+        ctx: { product: '@dotrino/vaultd', version, from: VERSION }, ttlMs: UPDATE_TTL_MS, onAnswer: settle
+      }).then((pend) => { pendId = pend.id; if (withdrawn) retirar() })
+        .catch((e) => { log(`[vault] update: could not ask for approval: ${e.message}`); settle(false) })
+      return { answer, withdraw: () => { withdrawn = true; retirar() } }
     },
+    announceUpdate,
     approvers: async () => {
       const record = await refreshActa()
       if (!record) return []