@dotrino/vaultd 0.78.0 → 0.80.0

package/lib/src/env.js

@@ -29,18 +29,63 @@ export function serviceRoot () {
   return process.env.DOTRINO_ENV_HOME || path.join(os.homedir(), '.dotrino', 'service')
 }
 
-/** Directorio de la identidad del servicio `ns` (`DOTRINO_ENV_DIR` lo pisa). */
-export function serviceDir (ns) {
+/**
+ * DE QUÉ BÓVEDA VINO ESTO: `~/.dotrino/service/<bóveda>/<ns>`.
+ *
+ * Es una ETIQUETA TUYA, de esta máquina: nadie la manda por la red, no entra en el acta y
+ * no se compara con nada — puedes llamarla como quieras. Sirve solo para que dos bóvedas
+ * puedan tener un cajón que se llame igual.
+ *
+ * Se llama `--vault` y no `--profile` a propósito (dueño): `dotrino-vault --profile` ya
+ * significa OTRA cosa —el perfil de la bóveda— y los dos comandos se usan seguidos. Dos
+ * banderas con el mismo nombre y distinto significado se confunden el día que hay prisa.
+ *
+ * Antes la ruta era `<raíz>/<ns>` y el nombre del cajón era una CLAVE GLOBAL del usuario:
+ * si dos bóvedas usaban `aws`, el segundo enrolamiento pisaba al primero y lo dejaba
+ * inservible —avisaba, pero el papel del primero seguía existiendo en su bóveda sin
+ * identidad en disco que lo usara—. Obligar a nombrar el perfil quita esa colisión de
+ * raíz en vez de pedirle al usuario que se acuerde de no repetir nombres.
+ *
+ * Mismo alfabeto que el `ns` porque es lo mismo: un segmento de ruta.
+ */
+export const isValidVaultLabel = (p) => typeof p === 'string' && /^[a-z0-9-]{1,32}$/.test(p)
+
+/** Directorio de la identidad del servicio `ns` bajo la etiqueta de bóveda `vault`. */
+export function serviceDir (vault, ns) {
   if (process.env.DOTRINO_ENV_DIR) return process.env.DOTRINO_ENV_DIR
+  if (!isValidVaultLabel(vault)) {
+    throw new Error('missing vault label: pass --vault <nombre> (use [a-z0-9-]{1,32}). It is a label of YOUR machine: it says which vault this drawer came from')
+  }
   if (!isValidSecretsNs(ns)) throw new Error('invalid ns (use [a-z0-9-]{1,32}, e.g. "myapp")')
-  return path.join(serviceRoot(), ns)
+  return path.join(serviceRoot(), vault, ns)
 }
 
-/** Namespaces ya enrolados en esta máquina. */
+/** La etiqueta de bóveda: `--vault`, o `DOTRINO_ENV_VAULT`. */
+export const resolveVaultLabel = (v) => v || process.env.DOTRINO_ENV_VAULT || null
+
+/**
+ * Lo enrolado en esta máquina: `[{ vault, ns }]`. Recorre DOS niveles.
+ *
+ * Y avisa de lo que quedó en el nivel de antes (`<raíz>/<ns>`): no se lee ni se usa —
+ * repescarlo en silencio sería fingir que la migración no hace falta— pero callarlo
+ * dejaría al dueño con un servicio que «desapareció» sin explicación.
+ */
 export function listEnrolled () {
-  let names = []
-  try { names = fs.readdirSync(serviceRoot()) } catch (_) { return [] }
-  return names.filter((ns) => isValidSecretsNs(ns) && readServiceIdentity(path.join(serviceRoot(), ns)))
+  const out = []
+  let dirs = []
+  try { dirs = fs.readdirSync(serviceRoot(), { withFileTypes: true }) } catch (_) { return out }
+  for (const d of dirs) {
+    if (!d.isDirectory() || !isValidVaultLabel(d.name)) continue
+    // Un enrolamiento del formato viejo es un directorio con `service-identity.json`
+    // DENTRO; uno del nuevo tiene subdirectorios. Así se distinguen sin adivinar.
+    if (readServiceIdentity(path.join(serviceRoot(), d.name))) { out.push({ legacy: true, ns: d.name }); continue }
+    let hijos = []
+    try { hijos = fs.readdirSync(path.join(serviceRoot(), d.name)) } catch (_) { continue }
+    for (const ns of hijos) {
+      if (isValidSecretsNs(ns) && readServiceIdentity(path.join(serviceRoot(), d.name, ns))) out.push({ vault: d.name, ns })
+    }
+  }
+  return out
 }
 
 /**
@@ -98,10 +143,12 @@ let lastApplied = null
  *   `overridden` = las que YA tenían otro valor en el entorno y el vault pisó. Es
  *   el dato que delata un `.env` rancio, así que se reporta en vez de callarse.
  */
-export async function loadEnv ({ ns, dir, override, wait = true, required = [], onRetry, onPending } = {}) {
+export async function loadEnv ({ ns, vault, dir, override, wait = true, required = [], onRetry, onPending } = {}) {
   if (override === undefined) override = overrideByDefault()
   ns = resolveNs(ns)
-  dir = dir || serviceDir(ns)
+  // La ETIQUETA DE BÓVEDA es obligatoria salvo que se diga el directorio a pelo: es lo que
+  // hace que dos bóvedas puedan tener un cajón con el mismo nombre sin pisarse.
+  dir = dir || serviceDir(resolveVaultLabel(vault), ns)
   const load = wait ? waitForSecrets : fetchSecrets
   const secrets = await load({ dir, ns, onRetry, onPending })
 
@@ -199,9 +246,9 @@ export function applyEnv (secrets, override = overrideByDefault()) {
  *   también. Se elige 0 porque salir a propósito no es un fallo.
  * @returns {Promise<{stop:()=>void}>}
  */
-export async function watchEnv ({ ns, dir, applied = lastApplied ?? undefined, onUpdate, exitCode = 0, quiet = false, ...rest } = {}) {
+export async function watchEnv ({ ns, vault, dir, applied = lastApplied ?? undefined, onUpdate, exitCode = 0, quiet = false, ...rest } = {}) {
   ns = resolveNs(ns)
-  dir = dir || serviceDir(ns)
+  dir = dir || serviceDir(resolveVaultLabel(vault), ns)
   const say = (m) => { if (!quiet) console.error(m) }
 
   const exitNow = (reason) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.78.0",
+  "version": "0.80.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": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "0.74.1",
+    "@dotrino/identity": "0.76.0",
     "@dotrino/passmanager": "^0.9.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -202,9 +202,10 @@ async function cmdPair (args = []) {
   // `secrets:<ns>`, y los dos se combinan (`--service eco --scope sign` = un bot que
   // firma como aparato del acta y lee solo su cajón). `admin` no se empareja: se
   // concede desde el PC (`caps <ID> +administra`).
-  // --approval: el aparato que entre pedirá tu aprobación (teléfono) en cada petición de
-  // claves privadas. Por defecto NO pide; se cambia después con `caps <ID> +permiso`.
-  const approval = args.includes('--approval')
+  // (Aquí vivía `--approval`. Ya no hace falta: PEDIR APROBACIÓN ES EL DEFECTO, y lo
+  // contrario —`unattended`— no se empareja, por el mismo motivo que `admin`: un QR que
+  // circula no puede conceder «llévate mis claves privadas sin preguntar». Se concede
+  // después y a mano con `caps <ID> +desatendido`.)
   // --name <n>: CÓMO SE VA A LLAMAR el aparato que entre, decidido aquí y antes de nada.
   // Sin esto el nombre lo ponía el propio aparato, que por defecto usa el apodo del
   // PERFIL: acababas con varios dispositivos llamados igual que tú, y para distinguirlos
@@ -311,7 +312,7 @@ async function cmdPair (args = []) {
 
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
-  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}), ...(approval ? { approval: true } : {}), ...(admin ? { admin: true } : {}), ...(label ? { label } : {}) })
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}), ...(admin ? { admin: true } : {}), ...(label ? { label } : {}) })
   sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
@@ -545,7 +546,11 @@ async function cmdMembers () {
   const CAP = {
     sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves',
     admin: `${B}administra el perfil${Z}`, approve: `${B}aprueba pedidos${Z}`,
-    sealer: `${B}sella el acta${Z}`, passwords: `${B}pide contraseñas${Z}`
+    sealer: `${B}sella el acta${Z}`, passwords: `${B}pide contraseñas${Z}`,
+    // Resaltado como los otros cuatro: dice si esa máquina se lleva tus claves privadas
+    // sola o si te lo pregunta. Sin traducción salía el identificador en crudo
+    // (`unattended`) en una lista que lee un humano.
+    unattended: `${B}recibe claves sin aprobación${Z}`
   }
   // El nombre del perfil es una pubkey JWK. Recortarla no la hace legible: la deja
   // pareciendo un error (`{"key_ops":["verify"],"e…`). Se muestra su huella corta, la
@@ -575,7 +580,7 @@ async function cmdMembers () {
     // se mira quién es quién — y en la lista de variables ya seria tarde.
     if (m.cn && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
   }
-  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +permiso')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +desatendido')
   console.log('  «Permiso»: ese aparato solo recibe claves privadas cuando lo apruebas desde un aparato con «aprueba» (en cada arranque).')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
   console.log('  No deja cambiar permisos ni traspasar el mando: eso solo se hace en esta máquina.')
@@ -617,28 +622,22 @@ async function findMember (id) {
   return m
 }
 
-/**
- * `dotrino-vault approval <ID> on|off` — ese aparato solo recibe claves privadas con el
- * visto bueno de un aparato con `aprueba` (el teléfono). Es propiedad del APARATO, no del
- * cajón: el VPS desatendido no pide; la PC del dueño sí. Pide en cada petición, que para un
- * servicio bien hecho es una por arranque.
+/*
+ * Aquí vivía `dotrino-vault approval <ID> on|off`. Ya no existe: pedir aprobación para
+ * recibir claves privadas dejó de ser una marca local de esta bóveda y pasó a ser un
+ * PERMISO DEL ACTA (`unattended`, dueño 2026-09-01). Se concede y se quita como cualquier
+ * otro, y por lo tanto viaja, se ve en la pantalla de permisos y lo respeta cualquier
+ * bóveda de la cuenta:
+ *
+ *   dotrino-vault caps <ID> +desatendido    ← se lleva las claves solo
+ *   dotrino-vault caps <ID> -desatendido    ← vuelve a pedir permiso (el defecto)
  */
-async function cmdApproval (args = []) {
-  const [id, val] = args
-  if (!id || !['on', 'off'].includes(val)) { console.error('uso: dotrino-vault approval <ID> on|off'); process.exit(2) }
-  const m = await findMember(id)
-  writeReq('secret-request.json', { op: 'approval', pub: m.pub, id: m.id, approval: val === 'on' })
-  sendSignal(requireDaemon().pid, 'SIGUSR2')
-  console.log(val === 'on'
-    ? `Listo: ${m.id} solo recibirá claves privadas cuando un aparato con  caps <ID> +aprueba  lo apruebe (en cada arranque).`
-    : `Listo: ${m.id} vuelve a recibir sus claves sin aprobación.`)
-}
 
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
   const [id, ...changes] = args
   if (!id || !changes.length) {
-    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+sella|-sella|+permiso|-permiso')
+    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba|+contrasenas|-contrasenas|+sella|-sella|+desatendido|-desatendido')
     process.exit(2)
   }
   const CAP_BY_WORD = {
@@ -650,25 +649,34 @@ async function cmdCaps (args = []) {
     // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
     // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
     contrasenas: 'passwords', 'contraseñas': 'passwords',
+    // `desatendido`: RECIBE CLAVES PRIVADAS SIN QUE NADIE APRUEBE. Sin él, la bóveda no
+    // entrega nada hasta que un aparato con `aprueba` lo firme (una vez por arranque).
+    //
+    // No se llama `permiso` —como la marca local de antes— a propósito: aquella significaba
+    // «este aparato PIDE permiso» y esta significa lo contrario. Reusar la palabra con el
+    // sentido invertido es la clase de trampa que se paga una madrugada.
+    desatendido: 'unattended', unattended: 'unattended',
     sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve',
     passwords: 'passwords'
   }
   const s = requireDaemon()
   const m = await findMember(id)
 
-  // `+permiso` / `-permiso` no es una capacidad del acta: es la marca de la bóveda «este
-  // aparato pide aprobación al recibir claves». Se cambia aquí, como cualquier permiso.
-  const rest = []
+  // El desvío de `+permiso` a una marca local de la bóveda se fue: ahora TODO es un
+  // permiso del acta y sigue el mismo camino, incluido `desatendido`.
+  //
+  // Y `permiso` se rechaza en voz alta en vez de ignorarse: significaba lo CONTRARIO
+  // («este aparato pide aprobación»), así que quien lo teclee de memoria estaría pidiendo
+  // justo lo opuesto a lo que cree.
   for (const c of changes) {
     const w = c.slice(1).toLowerCase()
-    if ((c[0] === '+' || c[0] === '-') && (w === 'permiso' || w === 'approval')) {
-      writeReq('secret-request.json', { op: 'approval', pub: m.pub, id: m.id, approval: c[0] === '+' })
-      sendSignal(s.pid, 'SIGUSR2')
-      console.log(c[0] === '+' ? `Listo: ${m.id} pedirá tu aprobación en cada petición de claves.` : `Listo: ${m.id} ya no pide aprobación.`)
-      await sleep(300)
-    } else rest.push(c)
+    if (w === 'permiso' || w === 'approval') {
+      console.error('`%s` ya no existe. Pedir aprobación es el DEFECTO; lo que se concede es lo contrario:', w)
+      console.error('  dotrino-vault caps %s +desatendido   ← se lleva las claves privadas sin aprobación', m.id)
+      process.exit(2)
+    }
   }
-  if (!rest.length) return
+  const rest = changes
   const caps = new Set(m.caps)
   for (const c of rest) {
     const sign = c[0]
@@ -1495,7 +1503,6 @@ function help () {
   pair --name <nombre>  cómo se llamará el aparato que entre. Sin esto el nombre lo pone
                       ÉL, y por defecto usa el apodo del perfil: acabas con varios
                       dispositivos llamados igual que tú
-  pair --approval       el aparato que entre pedirá tu aprobación (teléfono) al recibir claves
   pair --admin          el aparato que entre podrá ADMINISTRAR (es lo que es una consola).
                       El QR no lleva nada: el permiso se aplica al aprobar el código aquí
   pair --quiet          escupe SOLO la invitación (una línea) y termina: sin QR y sin

package/src/daemon.js

@@ -143,7 +143,6 @@ export async function runDaemon () {
 
   // --- SIGUSR1: iniciar emparejamiento ---
   const pairFile = path.join(dir, 'pair.json')
-  let pendingApproval = false // lo pidió `pair --approval`; se aplica al aprobar
   /**
    * Lo pidió `pair --admin`: el aparato que entre por ESTA invitación podrá administrar.
    *
@@ -199,9 +198,6 @@ export async function runDaemon () {
       // La etiqueta por defecto de un servicio es su ns a secas: la lista ya marca [servicio «ns»],
       // y el prefijo «service:» confundía (el cajón se llama claude, no service:claude).
       const label = pairReq?.label || (isService ? pairReq.service : 'cli')
-      // `pair --approval`: el aparato que entre por esta invitación pedirá el visto bueno del
-      // teléfono cada vez que reciba claves privadas (se aplica al aprobarlo, abajo).
-      pendingApproval = !!pairReq?.approval
       pendingAdmin = !!pairReq?.admin
       // `profile`/`profileName`: la CUENTA del vault a la que entra el dispositivo.
       // Con varias bóvedas en el mismo daemon, el QR sale de UNA y quien empareja
@@ -392,8 +388,6 @@ export async function runDaemon () {
           const vault = targetOf(appr)
           if (!vault) throw Object.assign(new Error('profile locked'), { code: 'PROFILE_LOCKED' })
           const r = await vault.approveDevice(appr.code); rm(pendingEnrollFile); rm(pairFile)
-          if (pendingApproval && r?.cert?.sub) { try { await vault.setApproval(r.cert.sub, true); console.log('[vault] the new device will need approval on every key request') } catch (e) { console.error('[vault] could not flag approval: %s', e.message) } }
-          pendingApproval = false
           // `pair --admin`: se le SUMA `admin` a lo que ya tiene, no se le reescriben los
           // permisos — el aparato acaba de entrar con el scope que pidió la invitación.
           if (pendingAdmin && r?.deviceId) {
@@ -542,7 +536,6 @@ export async function runDaemon () {
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
           } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
-          else if (sec.op === 'approval') { const r = await vault.setApproval(sec.pub, !!sec.approval); console.log('[vault] device %s: approval %s', sec.id || '?', r.approval ? 'REQUIRED on every key request' : 'off') }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
           // Saldar lo que quedó a deber: heredarle a un aparato nuevo lo ya guardado y

package/src/passwords.js

@@ -27,7 +27,8 @@ export const PASSWORDS_CAP = 'passwords'
  *   `cek`         la llave de la bóveda de contraseñas (CryptoKey AES-GCM)
  *   `isAllowed(pubkey)`   qué aparatos pueden pedir — lo decide el acta, no esto
  *   `encPubOf(pubkey)`    su llave de cifrado, para sellarle la respuesta
- *   `needsApproval(pubkey)`  si ese aparato está marcado para aprobar. Se compone con el
+ *   `needsApproval(pubkey)`  (async) si ese aparato tiene que pedir aprobación según el
+ *                            ACTA (`unattended`). Se compone con el
  *                        criterio del propio protocolo: solo lo PRIVADO pregunta
  *   `approve({ pubkey, op })`  pide el visto bueno (el teléfono) y espera
  *   `devices()` / `unlink(pubkey)`   administración, opcional
@@ -66,7 +67,11 @@ export function createPasswordDesk (opts = {}) {
     // reescribirlo aquí: si cada bóveda tuviera su idea de qué es privado, serían tres
     // bóvedas distintas otra vez.
     needsApproval: async (op, payload, pubkey) =>
-      needsApproval(pubkey) && await responder.wantsPrivate(op, payload),
+      // `await` OBLIGATORIO: `needsApproval` pasó a ser asíncrona (lee el acta en vivo), y
+      // una promesa SIEMPRE es verdadera. Sin el await esto decía «sí, pide aprobación»
+      // para todo el mundo, y en el otro sentido —si algún día devuelve false— diría que
+      // no hace falta. Un `&&` sobre una promesa es una comprobación que no comprueba.
+      await needsApproval(pubkey) && await responder.wantsPrivate(op, payload),
     approve,
     admin: devices && unlink ? { devices, unlink } : null,
     onRequest: (r) => {

package/src/tui/app.js

@@ -332,8 +332,13 @@ function pairModeRows (st, t) {
  * `sealer` es justo el que hay que entender para el multivault. Se ven siempre, aunque en
  * un teléfono normal `sealer` no lo vaya a usar nadie: verlo apagado explica el modelo
  * (dueño, 2026-08-31).
+ *
+ * `unattended` entró por lo mismo (dueño, 2026-09-01): era una marca local de la bóveda
+ * —invisible aquí y solo tocable por la CLI— y encima con el sentido invertido. Es EL
+ * permiso que hay que entender para un servidor: dice si esa máquina se lleva tus claves
+ * privadas sola o si te lo pregunta. Verlo apagado es la mitad del mensaje.
  */
-const CAPS_ORDER = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer']
+const CAPS_ORDER = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended']
 
 function capsRows (st, t) {
   const i = L(st)
@@ -342,20 +347,31 @@ function capsRows (st, t) {
   const member = (st.members || []).find((m) => m.pub === target.pub)
   if (!member) return [{ text: t.muted(i.capsNoMember), sel: false }]
 
-  const has = new Set(member.caps || [])
+  // EL BORRADOR manda sobre lo que hay en el acta: es lo que estás a punto de dejar.
+  const real = new Set(member.caps || [])
+  const has = st.capsDraft?.pub === member.pub ? new Set(st.capsDraft.caps) : real
+
   const rows = [
     { text: ' ' + t.bold(i.capsFor(target.deviceId, member.label || '')), sel: false },
     { text: '', sel: false }
   ]
+  let tocados = 0
   for (const cap of CAPS_ORDER) {
     const mark = has.has(cap) ? '[x]' : '[ ]'
     const name = i.capName[cap]
-    const line = ` ${mark}  ${cap === 'admin' ? t.bold(name) : name}`
+    // LO QUE CAMBIA SE SEÑALA. Sin esto el borrador es indistinguible del acta y no sabes
+    // qué vas a firmar — que es justo lo que hace peligroso acumular cambios.
+    const cambia = has.has(cap) !== real.has(cap)
+    if (cambia) tocados++
+    const line = ` ${mark}${cambia ? t.bold('*') : ' '} ${cap === 'admin' ? t.bold(name) : name}`
     rows.push({ text: line, sel: true, meta: { cap } })
     rows.push({ text: t.muted('      ' + i.capHint[cap]), sel: false })
   }
   rows.push({ text: '', sel: false })
-  rows.push({ text: t.muted(' ' + i.capsApplyHint), sel: false })
+  rows.push({
+    text: tocados ? ' ' + t.bold(i.capsPending(tocados)) : t.muted(' ' + i.capsApplyHint),
+    sel: false
+  })
   return rows
 }
 
@@ -924,6 +940,8 @@ async function onKeyDevices (term, st, key) {
     })
   } else if (ch === 'c' && cur?.sub) {
     st.capsFor = { pub: cur.sub, deviceId: cur.deviceId }
+    // Borrador limpio al entrar: arrastrar el de otro aparato sería firmar lo que no viste.
+    st.capsDraft = null
     st.sel.caps = 0
     await refreshMembers(term, st)
     st.screen = 'caps'
@@ -998,9 +1016,19 @@ async function beginPairing (term, st, profile, service = null, label = null) {
 }
 
 /**
- * Enter marca o desmarca un permiso y lo aplica en el acto. Sin botón de «guardar»: cada
- * cambio se sella en el acta y se avisa a los demás aparatos, así que acumularlos en
- * pantalla solo serviría para que el acta y lo que ves dijeran cosas distintas.
+ * UN BORRADOR QUE SE GUARDA O SE DESCARTA (dueño, 2026-09-01).
+ *
+ * Antes cada Enter sellaba un acta. Cambiar cuatro permisos eran cuatro actas, cuatro
+ * avisos a todos los aparatos y cuatro renovaciones de certificado — absurdo, y encima
+ * dejaba la cuenta pasando por estados intermedios que nadie quiso (un aparato con
+ * `admin` pero todavía sin `read`, por ejemplo).
+ *
+ * Ahora Enter mueve un borrador LOCAL —nada firmado, nada avisado— y `G` lo aplica de
+ * golpe. `applyChanges` ya tomaba una LISTA de cambios y producía UNA acta: el borrador es
+ * esa lista, sin firmar, hasta que confirmas.
+ *
+ * Lo que se cambia va marcado con `*` y contado abajo: un borrador que no se distingue del
+ * acta es peor que no tenerlo, porque firmas sin saber qué.
  */
 async function onKeyCaps (term, st, key) {
   const i = L(st)
@@ -1010,31 +1038,51 @@ async function onKeyCaps (term, st, key) {
   const cur = sels[Math.min(st.sel.caps || 0, sels.length - 1)]
   const ch = key.name === 'char' ? key.ch.toLowerCase() : null
 
-  if (key.name === 'escape' || ch === 'b') { st.screen = 'devices'; st.capsFor = null; return true }
-  if (key.name === 'f5') { await refreshMembers(term, st); return true }
-  if ((key.name !== 'enter' && ch !== ' ') || !cur) return true
-
   const member = (st.members || []).find((m) => m.pub === st.capsFor?.pub)
-  if (!member) return true
-  const caps = new Set(member.caps || [])
-  const giving = !caps.has(cur.cap)
-  if (giving) caps.add(cur.cap); else caps.delete(cur.cap)
-
-  const apply = async () => {
-    const r = await guard(term, st, i.applyingCaps, () => vc.setDeviceCaps(member.pub, [...caps], activeId(st)))
-    if (!r.ok) return
-    applyDump(st, r.v)
-    await refreshMembers(term, st)
-    flash(st, giving ? i.capGiven(i.capName[cur.cap]) : i.capTaken(i.capName[cur.cap]))
+  if (!member) {
+    if (key.name === 'escape' || ch === 'b') { st.screen = 'devices'; st.capsFor = null }
+    return true
   }
+  const real = new Set(member.caps || [])
+  if (st.capsDraft?.pub !== member.pub) st.capsDraft = { pub: member.pub, caps: [...real] }
+  const draft = new Set(st.capsDraft.caps)
+  const sucio = [...new Set([...draft, ...real])].some((c) => draft.has(c) !== real.has(c))
 
-  // Administrar se PREGUNTA: es el permiso que deja a ese aparato admitir y expulsar
-  // dispositivos sin pasar por aquí. Los otros tres se marcan y ya.
-  if (cur.cap === 'admin' && giving) {
-    setConfirm(st, { text: i.confirmAdmin(st.capsFor.deviceId), onYes: apply })
+  const salir = () => { st.screen = 'devices'; st.capsFor = null; st.capsDraft = null }
+  if (key.name === 'escape' || ch === 'b') {
+    // SALIR CON CAMBIOS SIN GUARDAR SE PREGUNTA. Tirarlos callando es perder trabajo sin
+    // decirlo, y es justo lo que un borrador no debe hacer.
+    if (sucio) setConfirm(st, { text: i.capsDiscard, onYes: async () => { salir() } })
+    else salir()
     return true
   }
-  await apply()
+  if (key.name === 'f5') { st.capsDraft = null; await refreshMembers(term, st); return true }
+
+  // GUARDAR: UNA sola acta con todo lo que hayas tocado.
+  if (ch === 'g') {
+    if (!sucio) { flash(st, i.capsNothing); return true }
+    const cuantos = [...new Set([...draft, ...real])].filter((c) => draft.has(c) !== real.has(c)).length
+    const guardar = async () => {
+      const r = await guard(term, st, i.applyingCaps, () => vc.setDeviceCaps(member.pub, [...draft], activeId(st)))
+      if (!r.ok) return
+      applyDump(st, r.v)
+      st.capsDraft = null
+      await refreshMembers(term, st)
+      flash(st, i.capsSaved(cuantos))
+    }
+    // Administrar se PREGUNTA, y se pregunta AL GUARDAR: es cuando pasa a ser verdad.
+    if (draft.has('admin') && !real.has('admin')) {
+      setConfirm(st, { text: i.confirmAdmin(st.capsFor.deviceId), onYes: guardar })
+      return true
+    }
+    await guardar()
+    return true
+  }
+
+  if ((key.name !== 'enter' && ch !== ' ') || !cur) return true
+  // Enter solo mueve el BORRADOR: no firma, no avisa, no se puede equivocar caro.
+  if (draft.has(cur.cap)) draft.delete(cur.cap); else draft.add(cur.cap)
+  st.capsDraft = { pub: member.pub, caps: [...draft] }
   return true
 }
 
@@ -1814,4 +1862,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -40,7 +40,11 @@ const es = {
   titleCaps: 'Permisos del dispositivo',
   capsFor: (id, name) => `Permisos de ${id}${name ? ' · ' + name : ''}`,
   capsNoMember: '  (este dispositivo ya no está en el acta)',
-  capsApplyHint: 'Enter marca o desmarca. Cada cambio se aplica y se avisa a tus otros aparatos.',
+  capsApplyHint: 'Enter marca o desmarca · G guarda los cambios · Esc sale',
+  capsPending: (n) => `${n} cambio(s) sin guardar (*) · G para guardarlos en UNA sola acta · Esc para descartarlos`,
+  capsSaved: (n) => `${n} cambio(s) guardados en una sola acta`,
+  capsNothing: 'No has cambiado nada',
+  capsDiscard: '¿Descartar los cambios sin guardar?',
   capName: {
     sign: 'Firmar como tú',
     store: 'Guardar tus datos',
@@ -48,7 +52,8 @@ const es = {
     admin: 'Administrar el perfil',
     passwords: 'Pedir tus contraseñas',
     approve: 'Aprobar pedidos',
-    sealer: 'Sellar el acta'
+    sealer: 'Sellar el acta',
+    unattended: 'Recibir claves sin aprobación'
   },
   capHint: {
     sign: 'usar tu identidad en las apps del ecosistema',
@@ -61,14 +66,15 @@ const es = {
     // daemon, o un navegador que se puso de bóveda). En un teléfono normal se concede y no
     // lo usa nadie. Se enseña igual, y se dice: verlo desactivado explica el modelo;
     // esconderlo hacía creer que no existe (dueño, 2026-08-31).
-    sealer: 'admitir aparatos y cambiar permisos él solo, si esta bóveda no está. Solo sirve en otra BÓVEDA'
+    sealer: 'admitir aparatos y cambiar permisos él solo, si esta bóveda no está. Solo sirve en otra BÓVEDA',
+    unattended: 'llevarse claves privadas SIN preguntarte. Apagado, cada vez que arranque tienes que aprobarlo desde un aparato con «Aprobar»'
   },
   confirmAdmin: (id) => `¿Dejar que ${id} conecte y quite dispositivos sin venir aquí?`,
   capGiven: (n) => `Concedido: ${n}`,
   capTaken: (n) => `Quitado: ${n}`,
   applyingCaps: 'Aplicando…',
   loadingMembers: 'Cargando el acta…',
-  helpCaps: ['↑↓', 'Enter marcar', 'F5 refrescar', 'Esc dispositivos', 'l English', 'q salir'],
+  helpCaps: ['↑↓', 'Enter marcar', 'G guardar', 'F5 refrescar', 'Esc dispositivos', 'l English', 'q salir'],
   // Perfil del usuario (lo que sincronizan los dispositivos). Solo lectura: se edita en
   // el aparato, no en la máquina donde vive la bóveda.
   loadingProfile: 'Cargando el perfil…',
@@ -350,7 +356,11 @@ const en = {
   titleCaps: 'Device permissions',
   capsFor: (id, name) => `Permissions for ${id}${name ? ' · ' + name : ''}`,
   capsNoMember: '  (this device is no longer in the record)',
-  capsApplyHint: 'Enter ticks or unticks. Each change applies and your other devices are told.',
+  capsApplyHint: 'Enter ticks or unticks · G saves · Esc leaves',
+  capsPending: (n) => `${n} unsaved change(s) (*) · G to save them in ONE record · Esc to discard`,
+  capsSaved: (n) => `${n} change(s) saved in a single record`,
+  capsNothing: 'You have not changed anything',
+  capsDiscard: 'Discard the unsaved changes?',
   capName: {
     sign: 'Sign as you',
     store: 'Save your data',
@@ -358,7 +368,8 @@ const en = {
     admin: 'Manage the profile',
     passwords: 'Ask for your passwords',
     approve: 'Approve requests',
-    sealer: 'Seal the record'
+    sealer: 'Seal the record',
+    unattended: 'Take keys without approval'
   },
   capHint: {
     sign: 'use your identity across the ecosystem apps',
@@ -367,14 +378,15 @@ const en = {
     admin: 'connect and remove devices from that device, without coming here',
     passwords: 'the manager: ask for one credential per site, never the whole list',
     approve: 'give the go-ahead when another device asks for private keys',
-    sealer: 'admit devices and change permissions on its own if this vault is gone. Only useful on another VAULT'
+    sealer: 'admit devices and change permissions on its own if this vault is gone. Only useful on another VAULT',
+    unattended: 'take private keys WITHOUT asking you. Off, you must approve it from a device with «Approve» every time it starts'
   },
   confirmAdmin: (id) => `Let ${id} connect and remove devices without coming here?`,
   capGiven: (n) => `Granted: ${n}`,
   capTaken: (n) => `Removed: ${n}`,
   applyingCaps: 'Applying…',
   loadingMembers: 'Loading the record…',
-  helpCaps: ['↑↓', 'Enter tick', 'F5 refresh', 'Esc devices', 'l Español', 'q quit'],
+  helpCaps: ['↑↓', 'Enter tick', 'G save', 'F5 refresh', 'Esc devices', 'l Español', 'q quit'],
   loadingProfile: 'Loading profile…',
   noProfile: '  (this vault has no profile yet)',
   noProfileHint: '  Edit your name or photo on a paired device and press F5.',

package/src/vault.js

@@ -113,18 +113,25 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * dos clases de espera.
    */
   const waiters = new Map()
-  // APARATOS QUE PIDEN APROBACIÓN: una lista de llaves en `approval.json` (cifrado en reposo
-  // como todo el dir). Es decisión de esta bóveda, no del acta: es ella la que entrega.
-  const approvalFile = path.join(dir, 'approval.json')
-  const approvalAtRest = atRestFor(dir)
-  const readSupervised = () => { try { const d = JSON.parse(approvalAtRest.decrypt(fs.readFileSync(approvalFile, 'utf8'))); return Array.isArray(d?.members) ? d.members : [] } catch (_) { return [] } }
-  const needsApproval = (pub) => readSupervised().includes(pub)
-  async function setApproval (pub, on) {
-    const cur = new Set(readSupervised())
-    if (on) cur.add(pub); else cur.delete(pub)
-    fs.writeFileSync(approvalFile, approvalAtRest.encrypt(JSON.stringify({ v: 1, members: [...cur] })), { mode: 0o600 })
-    audit('approval', { device: await deviceIdOf(pub).catch(() => null), on: !!on })
-    return { approval: !!on }
+  /**
+   * ¿ESTE APARATO TIENE QUE PEDIR PERMISO PARA RECIBIR CLAVES PRIVADAS?
+   *
+   * Lo dice el ACTA, con el permiso `unattended`: quien lo tiene se las lleva solo; quien
+   * no, espera a que un aparato con `approve` lo firme.
+   *
+   * Antes era al revés y vivía aquí: una lista local de «estos SÍ piden permiso», así que
+   * un aparato nuevo nacía pudiendo llevarse las claves y nadie elegía eso — se elegía por
+   * omisión. Ahora hay que conceder a propósito quién puede llevárselas solo, y **si falta
+   * el dato se pide permiso**, que es lo que hay que hacer cuando no se sabe (dueño,
+   * 2026-09-01).
+   *
+   * Y al estar en el acta lo respeta cualquier bóveda de la cuenta, se ve en la pantalla de
+   * permisos como los demás, y se quita quitándolo — sin acordarse de un registro escondido
+   * en una máquina.
+   */
+  function needsApproval (pub, record) {
+    if (!record) return true          // sin acta no se decide que sí: se pide permiso
+    return !Acta.memberCan(record, pub, 'unattended')
   }
   // LA BÓVEDA DE CONTRASEÑAS: entradas y su llave, en el dir del perfil y cifradas en
   // reposo como todo lo demás. QUIÉN PUEDE PEDIR LO DICE EL ACTA (capacidad
@@ -835,7 +842,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // claves en memoria y no vuelve a pedir. El pedido se apunta, se avisa a quien aprueba y se
     // contesta «pendiente»; la respuesta de verdad sale cuando el teléfono firme
     // (`handleApproval`), sellada a la misma `ek`.
-    if (needsApproval(chk.device)) {
+    if (needsApproval(chk.device, record)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
       const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
@@ -1057,7 +1064,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // que haya una segunda lista que acordarse de tocar.
       isAllowed: (pub) => !!actaCache && Acta.memberCan(actaCache, pub, 'passwords'),
       encPubOf: (pub) => (actaCache?.members || []).find((m) => m.pub === pub)?.encPub || null,
-      needsApproval: (pub) => needsApproval(pub),
+      // EN VIVO, no del caché: conceder o quitar `unattended` tiene que surtir efecto en
+      // el acto. Con el caché, la mesa de contraseñas seguía decidiendo con la foto del
+      // último refresco — y en el sentido peligroso: un aparato al que le acabas de quitar
+      // el permiso se seguía sirviendo solo.
+      needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
       // El teléfono: se apunta el pedido, se le avisa y esta promesa espera su firma.
       // Es el mismo camino que ya recorren los cajones de secretos.
       approve: async ({ pubkey, op }) => {
@@ -2076,11 +2087,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     startPairing: desk.startPairing,
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
-    // Cajones con aprobación por uso (`approvals.js`).
-    // Aparatos que piden aprobación al recibir claves (`approvals.js`).
-    needsApproval,
-    setApproval,
-    supervised: () => readSupervised(),
+    // ¿Pide permiso este aparato para recibir claves privadas? Lo dice el ACTA
+    // (`unattended`), no una lista de esta máquina — por eso ya no hay `setApproval` ni
+    // `supervised`: se concede y se quita como cualquier otro permiso, con `caps`.
+    needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
     // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
     // llave. Lo que no puede es listarla un aparato.
     passwordDevices,