@dotrino/vaultd 0.145.0 → 0.147.0

package/src/settings.js

@@ -0,0 +1,37 @@
+/**
+ * AJUSTES DE ESTA BÓVEDA: lo que el dueño elige distinto del comportamiento por defecto.
+ *
+ * Hoy es uno: `updateApproval`. Por defecto la bóveda se actualiza sola (lo que baja se
+ * verifica contra la atestación del release, se pida permiso o no); con `updateApproval:
+ * true` antes le pide permiso a los aparatos con `approve` (dueño, 2026-10-08).
+ *
+ * Va por el canal local (`ipc.js`): lo escribe la CLI (`dotrino-vault update --approval
+ * on|off`) y lo lee el daemon cada vez que mira si hay versión nueva, sin señal ni reinicio.
+ *
+ * UN ARCHIVO QUE EXISTE Y NO SE PUEDE LEER NO ES «EL VALOR POR DEFECTO»: el por defecto es
+ * actualizarse sin preguntar, así que tragarse el fallo sería saltarse la aprobación que el
+ * dueño pidió justo cuando algo se rompió. Se lanza.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { ipcRead, ipcWrite } from './ipc.js'
+
+export const SETTINGS_FILE = 'settings.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/** @returns {{ updateApproval: boolean }} */
+export function readSettings (dir) {
+  const file = path.join(dir, SETTINGS_FILE)
+  if (!fs.existsSync(file)) return { updateApproval: false }
+  const raw = ipcRead(file, null)
+  if (!raw || typeof raw !== 'object' || typeof raw.updateApproval !== 'boolean') {
+    throw fail('settings-unreadable', `${SETTINGS_FILE} exists but cannot be read`)
+  }
+  return { updateApproval: raw.updateApproval }
+}
+
+export function writeSettings (dir, { updateApproval }) {
+  if (typeof updateApproval !== 'boolean') throw fail('bad-setting', 'updateApproval must be true or false')
+  ipcWrite(path.join(dir, SETTINGS_FILE), { v: 1, updateApproval })
+}

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'
@@ -155,7 +156,9 @@ function mergeMembersAndCerts (members, issued) {
       noAccess: !cert && !m.isMaster && !m.cn,
       // QUÉ CORRE ESE APARATO (CONVENCIONES §14). Lo apunta la bóveda cuando le habla, así
       // que aquí solo hay que dejarlo pasar — que es justo lo que le faltaba a `addedAt`.
-      running: m.running || null
+      running: m.running || null,
+      // SI LE LLEGAN LOS AVISOS, solo en quien aprueba (`undefined` = no aprueba, no se pinta).
+      notifiedAt: (m.caps || []).includes('approve') && 'notifiedAt' in m ? m.notifiedAt : undefined
     }
   })
 }
@@ -336,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 = []
@@ -386,6 +433,9 @@ function deviceRows (st, t) {
     const extra = (d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : '') +
       (vars ? t.muted(`  vars:${vars}`) : '') +
       corre +
+      // En quien aprueba: si dijo que le llegan los avisos. No cambia a quién se le pide
+      // (a todos); deja ver a cuál no le suena el pedido. Es un dato, va en gris.
+      (d.notifiedAt === undefined ? '' : t.muted(`  ${d.notifiedAt ? i.notifyYes : i.notifyUnknown}`)) +
       // EN DEUDA: en el acta y sin poder abrir lo suyo. Va en color de aviso al lado de
       // sus variables, que es donde se mira cuando algo no arranca.
       (debt ? t.warn(`  ${i.deviceDebt(debt)}`) : '')
@@ -1199,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
@@ -2303,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,
@@ -2338,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,
@@ -2438,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.
@@ -2463,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)
@@ -2546,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.
@@ -2653,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)
@@ -2670,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',
@@ -272,6 +285,8 @@ const es = {
   revokedCount: (n) => `  Revocados: ${n}`,
   startingPairing: 'Iniciando emparejamiento…',
   deviceSince: 'desde',
+  notifyYes: 'le llegan avisos',
+  notifyUnknown: 'no ha dicho si le llegan avisos',
   nameDeviceLabel: '¿Cómo se va a llamar este aparato?',
   nameDeviceHint: 'Enter para dejar que lo diga él (usará tu apodo, y así no se distinguen)',
   noPending: 'No hay ningún dispositivo pendiente',
@@ -414,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.
@@ -452,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"
@@ -499,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',
@@ -622,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',
@@ -719,6 +748,8 @@ const en = {
   revokedCount: (n) => `  Revoked: ${n}`,
   startingPairing: 'Starting pairing…',
   deviceSince: 'since',
+  notifyYes: 'gets notifications',
+  notifyUnknown: 'has not said if notifications reach it',
   nameDeviceLabel: 'What will this device be called?',
   nameDeviceHint: 'Enter to let it say (it will use your nickname, and then they all look alike)',
   noPending: 'No device is waiting',
@@ -843,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'] : []),
@@ -875,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,110 @@
+/**
+ * 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'
+}