@dotrino/vaultd 0.131.5 → 0.132.0

package/README.md

@@ -239,10 +239,11 @@ dotrino-vault caps <ID> ±permiso   # cambia lo que puede un dispositivo (+firma
 dotrino-vault revoke  <nonce>      # revoca un dispositivo (le ordena autoborrarse)
 dotrino-vault activity [n]         # bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
 dotrino-vault pair --service <ns>  # empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
-dotrino-vault pair --scope <lista>  # los PERMISOS del cert: sign,read,store,secrets:<ns>. Sin esto, sign,read,store.
+dotrino-vault pair --scope <lista>  # los PERMISOS con los que entra (cualquiera de caps: firma,lee,guarda,administra,aprueba…
+                                    # y secrets:<ns>). Entra al acta ya con ellos, sin otra acta. Sin esto, firma,lee,guarda.
 dotrino-vault caps <ID> +permiso     # ese aparato pide tu aprobación (teléfono) al recibir claves; pair --approval al enrolar
                                     # Se combina con --service: `--service eco --scope sign` = un bot que firma
-                                    # como aparato del acta y lee SOLO su cajón. `admin` no se empareja (caps).
+                                    # como aparato del acta y lee SOLO su cajón.
 dotrino-vault secret set <ns> <CLAVE> <valor>   # variable del SCOPE: la comparten todos los
                                                 # aparatos que sirven ese namespace
 dotrino-vault secret set <ns> CLAVE=valor CLAVE2=valor2 …   # VARIAS de una vez (un solo aviso)

package/lib/src/enroll.js

@@ -30,7 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
-import { verifyContinuity, canSeal } from '@dotrino/identity/acta'
+import { verifyContinuity, canSeal, DEVICE_CAPS } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -159,8 +159,24 @@ export function createEnrollDesk ({
    *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
    *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
    *                       identidad de verdad de la cuenta es `iss`.
+   *   · `caps`          → LOS PERMISOS con los que entra al acta, elegidos por quien
+   *                       empareja (dueño, 2026-09-26: «al emparejar debería escoger los
+   *                       permisos, caso contrario estoy obligado a hacer dos actas»). Sin
+   *                       esto el aparato entraba con lo que da el scope y cualquier otro
+   *                       permiso —`admin`, `approve`…— costaba una segunda acta. Se quedan
+   *                       AQUÍ, en la sesión de la bóveda: NO viajan en el QR, así que la
+   *                       invitación que circula no concede nada; lo concede quien teclea
+   *                       el código, igual que hacía `caps` después.
    */
-  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
+  async function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '', caps = null } = {}) {
+    if (caps != null) {
+      if (!Array.isArray(caps)) throw Object.assign(new Error('caps must be a list'), { code: 'bad-caps' })
+      const cn = scopeToCn(scope)
+      const bad = caps.filter((c) => !(DEVICE_CAPS.includes(c) || (c === 'secrets' && cn)))
+      if (bad.length) throw Object.assign(new Error('unknown permission(s): ' + bad.join(', ')), { code: 'bad-caps' })
+      if (!caps.length) throw Object.assign(new Error('the pairing grants no permission'), { code: 'empty-scope' })
+      caps = [...new Set(caps)]
+    }
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
     const acct = String(account || '').slice(0, 40)
     // INVITACIÓN CORTA: si sabemos cómo alcanzarnos, el QR lleva solo eso y el
@@ -176,12 +192,12 @@ export function createEnrollDesk ({
     const conn = typeof connToken === 'function' ? await connToken() : connToken
     if (conn) {
       const sn = randToken(8)
-      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+      pending.set(sn, { token: sn, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
       return { token: sn, qr: { v: 2, conn, sn, m: mode, proxy }, expiresInMs: PAIRING_TTL_MS }
     }
     const token = randToken(PAIR_TOKEN_BYTES)
     const sn = randToken(PAIR_TOKEN_BYTES)
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
+    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, caps, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
   }
 
@@ -364,8 +380,10 @@ export function createEnrollDesk ({
     // PERMISOS, no tipos (2026-08-22): las capacidades son las del scope ENTERO. Un
     // cajón (`secrets:<ns>`) suma `secrets` y fija el CN; no borra lo demás — un bot
     // con `sign,secrets:eco` firma como aparato del acta Y lee solo su cajón.
+    // Si quien emparejó ELIGIÓ los permisos (`startPairing({ caps })`), entran esos y en
+    // esta misma acta; si no, los que da el scope.
     const cn = scopeToCn(pend.scope)
-    const caps = [...new Set([...scopeToCaps(pend.scope), ...(cn ? ['secrets'] : [])])]
+    const caps = [...new Set([...(pend.caps || scopeToCaps(pend.scope)), ...(cn ? ['secrets'] : [])])]
     if (!caps.length) {
       throw Object.assign(new Error('the pairing scope grants no permission: no certificate was issued'), { code: 'empty-scope' })
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.131.5",
+  "version": "0.132.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": {
@@ -22,11 +22,11 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.101.0",
+    "@dotrino/identity": "0.105.0",
     "@dotrino/opaque": "0.1.0",
     "@dotrino/passmanager": "0.17.0",
     "@dotrino/proxy-client": "0.24.0",
-    "@dotrino/roadmap": "0.3.7",
+    "@dotrino/roadmap": "0.3.19",
     "@dotrino/store": "0.11.0",
     "@dotrino/update": "0.2.2",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -209,16 +209,6 @@ async function cmdPair (args = []) {
       console.error('uso: dotrino-vault pair --service <ns>   (ns en minúsculas, p.ej. proxy)'); process.exit(2)
     }
   }
-  // --scope <lista>: los PERMISOS del cert, y nada más. No hay tipos de aparato
-  // (2026-08-22, dueño): un aparato es un aparato y lo que puede hacer. Sin --scope,
-  // el juego de siempre (sign,read,store); `--service <ns>` es el atajo de
-  // `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`).
-  // (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
@@ -267,32 +257,28 @@ async function cmdPair (args = []) {
       console.error('No se creó ninguna cuenta.'); process.exit(1)
     }
   }
+  // --scope <lista>: LOS PERMISOS con los que entra, cualquiera del acta (dueño,
+  // 2026-09-26: al emparejar se eligen, para no tener que sellar otra acta después). Van
+  // a la bóveda, no al QR: los concede quien teclea el código aquí. `secrets:<ns>` es el
+  // cajón (lo mismo que `--service <ns>`).
   const scIdx = args.indexOf('--scope')
   let scope = null
+  let pairCaps = null
   if (scIdx >= 0) {
     const raw = args[scIdx + 1]
-    if (!raw || raw.startsWith('-')) { console.error('uso: dotrino-vault pair --scope sign,read,store,secrets:<ns>'); process.exit(2) }
-    const ALIAS = { firma: 'sign', lee: 'read', guarda: 'store', contrasenas: 'passwords', 'contraseñas': 'passwords' }
+    if (!raw || raw.startsWith('-')) { console.error('uso: dotrino-vault pair --scope firma,lee,guarda,administra,aprueba,contrasenas,secrets:<ns>'); process.exit(2) }
     scope = []
+    pairCaps = []
     for (const tok of raw.split(',').map((t) => t.trim()).filter(Boolean)) {
-      const t = ALIAS[tok] || tok
-      if (t === 'admin' || t === 'administra') { console.error('`admin` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +administra'); process.exit(2) }
-      if (t === 'approve' || t === 'aprueba') { console.error('`approve` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +aprueba'); process.exit(2) }
-      if (t === 'sealer' || t === 'sella') { console.error('`sella` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +sella'); process.exit(2) }
-      if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
-      // Un REPLICADOR nace acotado: solo esto, ni firma ni lee ni guarda. Se empareja
-      // —al contrario que `sella`— porque se despliega en una máquina sin teclado y el
-      // permiso no concede nada que haya que pensarse dos veces: reparte sobres cerrados.
-      if (t === 'replica' || t === 'replicador') { scope.push('vault:replica'); continue }
-      // El gestor de contraseñas SÍ se empareja con su permiso puesto: es lo único que
-      // va a hacer ese aparato, y pedirlo en dos pasos era el paso que nadie daba.
-      if (t === 'passwords') { scope.push('vault:passwords'); continue }
-      const m = /^secrets:([a-z0-9-]{1,32})$/.exec(t)
+      const m = /^secrets:([a-z0-9-]{1,32})$/.exec(tok)
       if (m) { scope.push('vault:secrets:' + m[1]); continue }
-      console.error('permiso desconocido: %s  (sign | read | store | contrasenas | secrets:<ns>)', tok); process.exit(2)
+      const cap = CAP_BY_WORD[tok.toLowerCase()]
+      if (!cap) { console.error('permiso desconocido: %s  (%s | secrets:<ns>)', tok, Object.keys(CAP_BY_WORD).join(' | ')); process.exit(2) }
+      pairCaps.push(cap)
     }
     if (service) scope.push('vault:secrets:' + service)
     scope = [...new Set(scope)]
+    pairCaps = [...new Set(pairCaps)]
   }
   // `--new-account [nombre]`: la otra respuesta a «¿a qué cuenta entra?». En vez de
   // meter el dispositivo en una cuenta que ya vive aquí, se ESTRENA una (vacía) y
@@ -340,7 +326,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' } : {}), ...(admin ? { admin: true } : {}), ...(label ? { label } : {}) })
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope?.length ? { scope } : {}), ...(pairCaps?.length ? { caps: pairCaps } : {}), ...(adopt ? { mode: 'adopt' } : {}), ...(admin ? { admin: true } : {}), ...(label ? { label } : {}) })
   sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
@@ -348,6 +334,7 @@ async function cmdPair (args = []) {
     await sleep(100)
     const p = ipcRead(pairFile, null)
     assertOpen(p) // el candado se contesta por el mismo archivo, para no dejar esperando
+    if (p?.error) { console.error('No se abrió el emparejamiento: %s', p.error); process.exit(1) }
     if (p?.expiresAt > Date.now()) { pair = p; break }
   }
   if (!pair) { console.error('No se recibió respuesta del daemon para el emparejamiento.'); process.exit(1) }
@@ -2001,8 +1988,9 @@ function help () {
                       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
                       esperar. Para desplegar (un contenedor no mira un QR en pantalla)
-  pair --scope <lista>  los PERMISOS del cert: sign,read,store,contrasenas,replica,secrets:<ns> (sin esto: sign,read,store;
-                      se combina con --service: --service eco --scope sign = bot que firma y lee su cajón)
+  pair --scope <lista>  los PERMISOS con los que entra, cualquiera de los de caps (firma,lee,guarda,administra,
+                      aprueba,contrasenas,passkeys,sella,desatendido,replica) y secrets:<ns>. Sin esto: firma,lee,guarda.
+                      Entra al acta ya con ellos. Se combina con --service: --service eco --scope firma
   secret set <ns> <CLAVE> <valor>   variable del scope <ns>: la comparten TODOS los
                                     aparatos del perfil que sirven ese namespace
   secret set <ns> CLAVE=valor CLAVE2=valor2 …

package/src/daemon.js

@@ -22,6 +22,8 @@ import { dataDir } from './paths.js'
 // EL CANAL LOCAL VA CIFRADO: por aquí pasan la contraseña, los valores y las invitaciones.
 import { ipcRead, ipcWrite, migrateIpcDir } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
+import { scopeToCaps, scopeToCn } from '../lib/src/enroll.js'
+import { capScope } from '@dotrino/identity/acta'
 import { watchBinary } from './selfupdate.js'
 import { latestRelease, isNewer, CHECK_EVERY_MS, isUserInstall, installUserRelease } from './update.js'
 import { VERSION } from './version.js'
@@ -156,19 +158,6 @@ export async function runDaemon () {
 
   // --- SIGUSR1: iniciar emparejamiento ---
   const pairFile = path.join(dir, 'pair.json')
-  /**
-   * Lo pidió `pair --admin`: el aparato que entre por ESTA invitación podrá administrar.
-   *
-   * Sigue en pie la regla de que **ningún QR concede administración**: el QR no lleva
-   * nada. Lo que hay es una nota LOCAL de esta bóveda, y el permiso se aplica en el
-   * mismo gesto que ya era la puerta —aprobar con el código tecleado aquí—, exactamente
-   * igual que `--approval`. Es el mismo `caps <ID> +administra` que harías a mano un
-   * segundo después, sin tener que ir a buscar el ID.
-   *
-   * Existe por el contenedor: allí cada paso cuesta un `docker exec`, y el primer aparato
-   * de una bóveda recién desplegada es SIEMPRE la consola.
-   */
-  let pendingAdmin = false
   const pairReqFile = path.join(dir, 'pair-request.json')
   async function handlePairingRequest () {
     try {
@@ -217,13 +206,34 @@ export async function runDaemon () {
         ipcWrite(pairFile, { v: 2, at: Date.now(), error: 'scope not allowed: ' + asked.filter((x) => !ALLOWED(x)).join(',') })
         return console.error('[vault] pairing refused: scope not allowed (%s)', asked.join(','))
       }
-      const scope = asked?.length
+      const base = asked?.length
         ? [...new Set(asked)]
         : isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
+      // LOS PERMISOS DEL ACTA se eligen al emparejar (dueño, 2026-09-26: «caso contrario
+      // estoy obligado a hacer dos actas»). Entran TODOS en el acta con la que el aparato
+      // entra —`admin` y `approve` incluidos: los concede quien teclea el código, igual
+      // que `caps` después, y el QR no lleva nada—, y el certificado lleva solo los que
+      // `ALLOWED` deja firmar. Decide el acta, no el papel (0.131.6).
+      //
+      // `pair --admin` es el mismo gesto: antes emparejaba y sellaba OTRA acta para sumar
+      // `admin`; ahora se suma aquí.
+      let caps = Array.isArray(pairReq?.caps) ? pairReq.caps.filter((x) => typeof x === 'string') : null
+      if (pairReq?.admin) caps = [...(caps || scopeToCaps(base)), 'admin']
+      let scope = base
+      if (caps) {
+        caps = [...new Set(caps)]
+        const cn = scopeToCn(base)
+        const fromCaps = caps.map((c) => capScope(c, cn)).filter((x) => x && ALLOWED(x))
+        // Sin `--scope` el papel sale de los permisos; con él, se suman.
+        scope = [...new Set([...(asked?.length || isService ? base : []), ...fromCaps])]
+        if (!scope.length) {
+          ipcWrite(pairFile, { v: 2, at: Date.now(), error: 'pick at least one of: sign, read, store, passwords, replica', code: 'empty-scope' })
+          return console.error('[vault] pairing refused: no permission the certificate can carry (%s)', caps.join(','))
+        }
+      }
       // 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')
-      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
       // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`). El nombre viaja
@@ -237,7 +247,7 @@ export async function runDaemon () {
       //               perfil de esta bóveda tiene que haber nacido para eso (`--adopt`
       //               crea uno vacío), o no habría dónde meterla.
       const mode = pairReq?.mode === 'adopt' ? 'adopt' : 'join'
-      const { qr, expiresInMs } = await vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName })
+      const { qr, expiresInMs } = await vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName, ...(caps ? { caps } : {}) })
       ipcWrite(pairFile, { v: 2, at: Date.now(), qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
       // El token es un secreto efímero: no debe quedar en disco más allá de su
       // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
@@ -248,6 +258,9 @@ export async function runDaemon () {
       }, expiresInMs + 1000).unref?.()
       console.log('[vault] pairing started (valid for %d min)', expiresInMs / 60000)
     } catch (e) {
+      // Se contesta por el archivo que espera quien lo pidió: si no, se queda mirando una
+      // pantalla vacía hasta que se agota el tiempo (p. ej. un permiso que no existe).
+      ipcWrite(pairFile, { v: 2, at: Date.now(), error: e.message, code: e.code || 'PAIR_FAILED' })
       console.error('[vault] could not start pairing:', e.message)
     }
   }
@@ -592,18 +605,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)
-          // `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) {
-            try {
-              const rec = await vault.profileMembers()
-              const m = (rec?.members || []).find((x) => x.id === r.deviceId)
-              if (!m?.pub) throw new Error('the device is not in the record yet')
-              await vault.setCaps(m.pub, [...new Set([...(m.caps || []), 'admin'])])
-              console.log('[vault] the new device can ADMINISTER this account (console)')
-            } catch (e) { console.error('[vault] could not grant admin: %s', e.message) }
-          }
-          pendingAdmin = false
           console.log('[vault] approved %s', r.deviceId)
           answer({ ok: true, deviceId: r.deviceId || null })
         } catch (e) {
@@ -627,7 +628,24 @@ export async function runDaemon () {
         } catch (e) { console.error('[vault] could not rename the device:', e.message) }
       }
       const capsReq = readJsonSafe(path.join(dir, 'caps-request.json'))
-      if (capsReq?.pub && Array.isArray(capsReq.caps)) {
+      // VARIOS APARATOS, UNA ACTA (el borrador de la TUI). Se contesta con el `id` de la
+      // petición, para que quien espera sepa si se firmó de verdad.
+      if (Array.isArray(capsReq?.changes)) {
+        rm(path.join(dir, 'caps-request.json'))
+        const answer = (extra) => ipcWrite(path.join(dir, 'caps.json'), { v: 1, at: Date.now(), req: capsReq.id || null, ...extra })
+        try {
+          const vault = targetOf(capsReq)
+          if (!vault) throw Object.assign(new Error('profile locked'), { code: 'PROFILE_LOCKED' })
+          const changes = capsReq.changes.filter((c) => typeof c?.pub === 'string' && Array.isArray(c.caps))
+          if (changes.length !== capsReq.changes.length) throw Object.assign(new Error('malformed change list'), { code: 'BAD_CHANGES' })
+          await vault.setCapsMany(changes)
+          console.log('[vault] permissions updated for %d device(s) in one record', changes.length)
+          answer({ ok: true, count: changes.length })
+        } catch (e) {
+          console.error('[vault] could not change permissions:', e.message)
+          answer({ ok: false, error: e.message, code: e.code || 'CAPS_FAILED' })
+        }
+      } else if (capsReq?.pub && Array.isArray(capsReq.caps)) {
         rm(path.join(dir, 'caps-request.json'))
         try {
           await targetOf(capsReq)?.setCaps(capsReq.pub, capsReq.caps)

package/src/tui/app.js

@@ -307,6 +307,13 @@ function deviceRows (st, t) {
   if (!devices.length) {
     rows.push({ text: t.muted(i.noDevices), sel: false })
   }
+  // PERMISOS SIN GUARDAR en uno o varios aparatos: se dice ARRIBA y se marca cada uno con
+  // `*`, porque G los firma todos juntos y hay que ver qué entra antes de pulsarlo.
+  const borrador = draftChanges(st)
+  const conCambios = new Set(borrador.map((c) => c.pub))
+  if (borrador.length) {
+    rows.unshift({ text: t.bold(' ' + i.devicesDraft(borrador.length)), sel: false }, { text: '', sel: false })
+  }
   for (const d of devices) {
     const label = d.label || t.muted(i.noLabel)
     const vars = devVarsOf(st, d.sub).length
@@ -339,7 +346,8 @@ function deviceRows (st, t) {
       : d.isMaster
         ? t.muted(i.thisVault)
         : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp))
-    rows.push({ text: ` ${t.bold(d.deviceId)}  ${label}${desde}  ${status}${extra}`, sel: true, meta: d })
+    const marca = conCambios.has(d.sub) ? t.bold('*') : ' '
+    rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${desde}  ${status}${extra}`, sel: true, meta: d })
   }
   const revoked = st.devices?.revoked || []
   if (revoked.length) {
@@ -462,27 +470,23 @@ const CAPS_ORDER = [...ORDEN.filter((c) => DEVICE_CAPS.includes(c)),
  */
 const capsForMember = (member) => (member?.cn ? ['secrets', ...CAPS_ORDER] : CAPS_ORDER)
 
-function capsRows (st, t) {
-  const i = L(st)
-  const target = st.capsFor
-  if (!target) return [{ text: t.muted(i.loading), sel: false }]
-  const member = (st.members || []).find((m) => m.pub === target.pub)
-  if (!member) return [{ text: t.muted(i.capsNoMember), sel: false }]
+/** Con lo que entra un aparato si no eliges otra cosa: lo mismo que `pair` sin `--scope`. */
+const PAIR_DEFAULT_CAPS = ['sign', 'read', 'store']
 
-  // 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 }
-  ]
+/**
+ * La lista de casillas de permisos, la MISMA para editar un aparato y para elegir con qué
+ * entra uno nuevo: una pantalla que dice lo mismo de dos maneras acaba diciendo dos cosas.
+ * `real` es contra qué se marca el `*` (lo que hay en el acta); al emparejar no hay acta
+ * todavía y se pasa `has`, así que no sale ninguna marca.
+ */
+function capChecklist (i, t, { cn = null, has, real = has }) {
+  const rows = []
   let tocados = 0
-  for (const cap of capsForMember(member)) {
+  for (const cap of capsForMember({ cn })) {
     const mark = has.has(cap) ? '[x]' : '[ ]'
     // El nombre de `secrets` lleva el cajón dentro: «las claves de proxy» dice qué abre,
     // «lee sus claves» te deja preguntándote cuáles.
-    const name = typeof i.capName[cap] === 'function' ? i.capName[cap](member.cn) : i.capName[cap]
+    const name = typeof i.capName[cap] === 'function' ? i.capName[cap](cn) : i.capName[cap]
     // 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)
@@ -491,17 +495,119 @@ function capsRows (st, t) {
     // así que no hay que repetirlo al lado. Lo que hace va debajo.
     const line = ` ${mark}${cambia ? t.bold('*') : ' '} ${cap === 'admin' ? t.bold(name) : name}`
     rows.push({ text: line, sel: true, meta: { cap } })
-    const hint = typeof i.capHint[cap] === 'function' ? i.capHint[cap](member.cn) : i.capHint[cap]
+    const hint = typeof i.capHint[cap] === 'function' ? i.capHint[cap](cn) : i.capHint[cap]
     rows.push({ text: t.muted('      ' + hint), sel: false })
   }
-  rows.push({ text: '', sel: false })
-  rows.push({
-    text: tocados ? ' ' + t.bold(i.capsPending(tocados)) : t.muted(' ' + i.capsApplyHint),
-    sel: false
-  })
+  return { rows, tocados }
+}
+
+/**
+ * EL BORRADOR ES DE TODA LA BÓVEDA, no de un aparato (dueño, 2026-09-26: «hay que
+ * extenderlo a guardar después de cambiar permisos de varios dispositivos, con esto me
+ * evito más actas inútiles»). `st.capsDrafts` guarda, por llave, la lista que QUEDARÍA;
+ * un aparato que vuelve a coincidir con el acta sale del borrador.
+ */
+const sameCaps = (a, b) => { const x = new Set(a || []); const y = new Set(b || []); return x.size === y.size && [...x].every((c) => y.has(c)) }
+const draftCapsOf = (st, member) => st.capsDrafts?.[member.pub] || member.caps || []
+function setCapsDraft (st, member, caps) {
+  const drafts = { ...(st.capsDrafts || {}) }
+  if (sameCaps(caps, member.caps)) delete drafts[member.pub]
+  else drafts[member.pub] = [...caps]
+  st.capsDrafts = drafts
+}
+/** Lo que se firmaría ahora: un cambio por aparato que sigue en el acta y difiere de ella. */
+function draftChanges (st) {
+  const out = []
+  for (const [pub, caps] of Object.entries(st.capsDrafts || {})) {
+    const member = (st.members || []).find((m) => m.pub === pub)
+    if (!member || sameCaps(caps, member.caps)) continue
+    const real = new Set(member.caps || []); const has = new Set(caps)
+    const n = [...new Set([...has, ...real])].filter((c) => has.has(c) !== real.has(c)).length
+    out.push({ pub, caps: [...caps], member, n })
+  }
+  return out
+}
+
+/**
+ * CON CAMBIOS SIN GUARDAR, IRSE SE PREGUNTA. Tirarlos callando es perder trabajo sin
+ * decirlo, y es justo lo que un borrador no debe hacer. Sin cambios, se va sin preguntar:
+ * confirmar por nada es ruido.
+ */
+function unlessDrafts (st, fn) {
+  const n = draftChanges(st).length
+  if (!n) return fn()
+  setConfirm(st, { text: L(st).capsDiscardAll(n), onYes: async () => { st.capsDrafts = {}; await fn() } })
+}
+
+/**
+ * GUARDAR: UNA sola acta con todo lo que hayas tocado, en uno o en varios aparatos.
+ * Administrar se PREGUNTA, y se pregunta AL GUARDAR: es cuando pasa a ser verdad.
+ */
+async function saveCapsDrafts (term, st) {
+  const i = L(st)
+  const changes = draftChanges(st)
+  if (!changes.length) { flash(st, i.capsNothing); return }
+  const guardar = async () => {
+    const r = await guard(term, st, i.applyingCaps, () => vc.setDevicesCaps(changes.map(({ pub, caps }) => ({ pub, caps })), activeId(st)))
+    if (!r.ok) return
+    applyDump(st, r.v)
+    st.capsDrafts = {}
+    await refreshMembers(term, st)
+    flash(st, i.capsSavedMany(changes.reduce((a, c) => a + c.n, 0), changes.length))
+  }
+  const nuevosAdmin = changes.filter((c) => c.caps.includes('admin') && !(c.member.caps || []).includes('admin'))
+  if (nuevosAdmin.length) {
+    setConfirm(st, { text: i.confirmAdmin(nuevosAdmin.map((c) => c.member.id || deviceIdOf(st, c.pub)).join(', ')), onYes: guardar })
+    return
+  }
+  await guardar()
+}
+
+function capsRows (st, t) {
+  const i = L(st)
+  const target = st.capsFor
+  if (!target) return [{ text: t.muted(i.loading), sel: false }]
+  const member = (st.members || []).find((m) => m.pub === target.pub)
+  if (!member) return [{ text: t.muted(i.capsNoMember), sel: false }]
+
+  // 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 = new Set(draftCapsOf(st, member))
+  const { rows: lista, tocados } = capChecklist(i, t, { cn: member.cn, has, real })
+  const rows = [
+    { text: ' ' + t.bold(i.capsFor(target.deviceId, member.label || '')), sel: false },
+    { text: '', sel: false },
+    ...lista,
+    { text: '', sel: false }
+  ]
+  // Lo que hay pendiente en OTROS aparatos también se dice aquí: G los guarda juntos.
+  const otros = draftChanges(st).filter((c) => c.pub !== member.pub)
+  if (tocados) rows.push({ text: ' ' + t.bold(i.capsPending(tocados)), sel: false })
+  if (otros.length) rows.push({ text: ' ' + t.bold(i.capsPendingOthers(otros.length)), sel: false })
+  if (!tocados && !otros.length) rows.push({ text: t.muted(' ' + i.capsApplyHint), sel: false })
   return rows
 }
 
+/**
+ * PERMISOS CON LOS QUE ENTRA el aparato que se va a emparejar (dueño, 2026-09-26: «al
+ * emparejar debería escoger los permisos, caso contrario estoy obligado a hacer dos
+ * actas»). Se eligen ANTES del QR y viajan a la bóveda, no al QR: el aparato entra al acta
+ * ya con ellos, en la misma que lo admite.
+ */
+function pairCapsRows (st, t) {
+  const i = L(st)
+  const pc = st.pairCaps
+  if (!pc) return [{ text: t.muted(i.loading), sel: false }]
+  const { rows: lista } = capChecklist(i, t, { cn: pc.service || null, has: new Set(pc.caps) })
+  return [
+    { text: ' ' + t.bold(pc.service ? i.pairCapsService(pc.service) : i.pairCapsFor(pc.label || '')), sel: false },
+    { text: '', sel: false },
+    ...lista,
+    { text: '', sel: false },
+    { text: t.muted(' ' + i.pairCapsHint), sel: false }
+  ]
+}
+
 /** Las variables por SCOPE: las que comparten todos los aparatos que sirven ese ns. */
 function secretRows (st, t) {
   const i = L(st)
@@ -756,7 +862,7 @@ async function refreshAll (term, st, api = vc) {
   // Cerrada: no se pide su contenido, y tampoco se enseña un error por mirarla desde
   // fuera. Lo que hubiera cargado se suelta, para no dejar en pantalla lo de antes.
   if (activeLocked(st)) {
-    st.devices = null; st.secrets = null; st.members = []; st.me = undefined
+    st.devices = null; st.secrets = null; st.members = []; st.me = undefined; st.capsDrafts = {}
     return
   }
   const r = await guard(term, st, L(st).loading, () => api.snapshot(activeId(st)))
@@ -1085,10 +1191,10 @@ 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)
+    // Con cambios a medias NO se recarga el acta: el borrador se compara contra ella y
+    // traer otra por debajo cambiaría qué marca el `*` sin que lo vieras.
+    if (!draftChanges(st).length) await refreshMembers(term, st)
     st.screen = 'caps'
   } else if (ch === 'e' && cur?.sub) {
     // Variables de ESTE aparato. Solo un servicio las lee (es el único que pide su
@@ -1099,8 +1205,11 @@ async function onKeyDevices (term, st, key) {
     st.sel.devvars = 0
     await refreshSecrets(term, st)
     st.screen = 'devvars'
+  } else if (ch === 'g') {
+    // Guarda los permisos que dejaste a medias en uno o varios aparatos, en UNA acta.
+    await saveCapsDrafts(term, st)
   } else if (key.name === 'f5') {
-    await refreshDevices(term, st)
+    unlessDrafts(st, () => refreshDevices(term, st))
   }
   return true
 }
@@ -1235,13 +1344,12 @@ function beginPairingNamed (term, st, profile, service = null, after = null) {
     hint: i.nameDeviceHint,
     onSubmit: async (nombre) => {
       st.input = null
-      const ok = await beginPairing(term, st, profile, service, (nombre || '').trim().slice(0, 60) || null)
-      // `after` es para quien tenga que limpiar si el emparejamiento no llega a abrirse
-      // (la cuenta que nació para él). Va aquí porque con el nombre de por medio ya no se
-      // puede mirar el valor de retorno desde fuera.
-      if (after) await after(ok)
+      // Después del nombre, LOS PERMISOS: el aparato entra al acta ya con ellos. `after` es
+      // para quien tenga que limpiar si el emparejamiento no llega a abrirse (la cuenta
+      // que nació para él); lo llama la pantalla de permisos, al generar o al cancelar.
+      choosePairCaps(st, { profile, service, label: (nombre || '').trim().slice(0, 60) || null, after })
     },
-    onCancel: () => { st.input = null }
+    onCancel: async () => { st.input = null; if (after) await after(false) }
   })
   return true
 }
@@ -1250,8 +1358,8 @@ function beginPairingNamed (term, st, profile, service = null, after = null) {
  * Abre el emparejamiento contra `profile` y salta a la pantalla del QR. Con `service`,
  * el QR es el de un SERVICIO de ese namespace (cert limitado a sus variables).
  */
-async function beginPairing (term, st, profile, service = null, label = null) {
-  const r = await guard(term, st, L(st).startingPairing, () => vc.startPairing({ profile, ...(service ? { service } : {}), ...(label ? { label } : {}) }))
+async function beginPairing (term, st, profile, service = null, label = null, caps = null) {
+  const r = await guard(term, st, L(st).startingPairing, () => vc.startPairing({ profile, ...(service ? { service } : {}), ...(label ? { label } : {}), ...(caps ? { caps } : {}) }))
   // `service` se pega al estado porque el daemon no lo devuelve: la pantalla del QR
   // tiene que poder decir qué se está entregando, que no es lo mismo un aparato tuyo
   // que una máquina que solo va a leer la configuración del proxy.
@@ -1260,81 +1368,96 @@ async function beginPairing (term, st, profile, service = null, label = null) {
 }
 
 /**
- * UN BORRADOR QUE SE GUARDA O SE DESCARTA (dueño, 2026-09-01).
+ * UN BORRADOR QUE SE GUARDA O SE DESCARTA (dueño, 2026-09-01), y que abarca VARIOS
+ * APARATOS (dueño, 2026-09-26).
  *
  * 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.
+ * `admin` pero todavía sin `read`, por ejemplo). Y lo mismo pasaba entre aparatos: cada
+ * uno que tocabas era otra acta.
  *
- * 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é.
+ * Ahora Enter mueve un borrador LOCAL —nada firmado, nada avisado—, Esc vuelve a la lista
+ * SIN tirarlo (para seguir con otro aparato) y `G` lo aplica de golpe, todos los aparatos
+ * en UNA acta. Lo que se cambia va marcado con `*` y contado: 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)
   const rows = capsRows(st, term.t)
   const sels = rows.filter((r) => r.sel).map((r) => r.meta)
   moveSel(st, key, 'caps', sels.length)
   const cur = sels[Math.min(st.sel.caps || 0, sels.length - 1)]
   const ch = key.name === 'char' ? key.ch.toLowerCase() : null
 
+  const volver = () => { st.screen = 'devices'; st.capsFor = null }
   const member = (st.members || []).find((m) => m.pub === st.capsFor?.pub)
   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))
-
-  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()
+    if (key.name === 'escape' || ch === 'b') volver()
     return true
   }
+  // Volver a la lista NO tira el borrador: es como se pasa al siguiente aparato.
+  if (key.name === 'escape' || ch === 'b') { volver(); return true }
   if (key.name === 'f5') {
-    // F5 PREGUNTA IGUAL QUE ESC. Refrescar trae el acta de nuevo y el borrador deja de
-    // tener con qué compararse, así que hay que tirarlo — pero tirarlo callando es perder
-    // trabajo sin decirlo, que es lo mismo que Esc ya no hace.
-    const refrescar = async () => { st.capsDraft = null; await refreshMembers(term, st) }
-    if (sucio) setConfirm(st, { text: i.capsDiscard, onYes: refrescar })
-    else await refrescar()
+    // F5 trae el acta de nuevo y el borrador deja de tener con qué compararse: se pregunta
+    // antes de tirarlo, igual que al salir de la bóveda.
+    unlessDrafts(st, async () => { st.capsDrafts = {}; await refreshMembers(term, st) })
     return true
   }
+  if (ch === 'g') { await saveCapsDrafts(term, st); return true }
+
+  if ((key.name !== 'enter' && ch !== ' ') || !cur) return true
+  // Enter solo mueve el BORRADOR: no firma, no avisa, no se puede equivocar caro.
+  const draft = new Set(draftCapsOf(st, member))
+  if (draft.has(cur.cap)) draft.delete(cur.cap); else draft.add(cur.cap)
+  setCapsDraft(st, member, [...draft])
+  return true
+}
+
+/**
+ * Elegir los permisos del aparato que se va a emparejar. Enter marca, G genera el QR con
+ * ellos, Esc cancela (y quien abrió esto limpia lo suyo con `after(false)`).
+ */
+async function onKeyPairCaps (term, st, key) {
+  const i = L(st)
+  const pc = st.pairCaps
+  const rows = pairCapsRows(st, term.t)
+  const sels = rows.filter((r) => r.sel).map((r) => r.meta)
+  moveSel(st, key, 'paircaps', sels.length)
+  const cur = sels[Math.min(st.sel.paircaps || 0, sels.length - 1)]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+  if (!pc) { st.screen = 'devices'; return true }
 
-  // GUARDAR: UNA sola acta con todo lo que hayas tocado.
+  if (key.name === 'escape' || ch === 'b') {
+    st.pairCaps = null; st.screen = 'devices'
+    if (pc.after) await pc.after(false)
+    return true
+  }
   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
+    if (!pc.caps.length) { flash(st, i.pairCapsNone, 'warn'); return true }
+    const go = async () => {
+      st.pairCaps = null
+      const ok = await beginPairing(term, st, pc.profile, pc.service, pc.label, pc.caps)
+      if (!ok) st.screen = 'devices'
+      if (pc.after) await pc.after(ok)
     }
-    await guardar()
+    // Administrar se pregunta también aquí: es el mismo permiso, dado de otra manera.
+    if (pc.caps.includes('admin')) { setConfirm(st, { text: i.confirmAdmin(i.pairCapsNewDevice), onYes: go }); return true }
+    await go()
     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] }
+  const set = new Set(pc.caps)
+  if (set.has(cur.cap)) set.delete(cur.cap); else set.add(cur.cap)
+  st.pairCaps = { ...pc, caps: [...set] }
+  return true
+}
+
+/** Abre la pantalla de permisos del emparejamiento; el QR sale al pulsar G. */
+function choosePairCaps (st, { profile, service = null, label = null, after = null }) {
+  st.pairCaps = { profile, service, label, after, caps: service ? ['secrets'] : [...PAIR_DEFAULT_CAPS] }
+  st.sel.paircaps = 0
+  st.scroll.paircaps = { value: 0 }
+  st.screen = 'paircaps'
   return true
 }
 
@@ -1363,7 +1486,7 @@ async function onKeyPairMode (term, st, key) {
         st.input = null
         const ns = String(raw || '').trim().toLowerCase()
         if (!/^[a-z0-9-]{1,32}$/.test(ns)) { flash(st, i.serviceNsBad, 'danger'); return }
-        await beginPairing(term, st, activeId(st), ns)
+        choosePairCaps(st, { profile: activeId(st), service: ns })
       },
       onCancel: () => { st.input = null }
     })
@@ -1967,6 +2090,7 @@ const helpSegs = (i, screen, st = {}) => {
     logins: i.helpLogins,
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
+    paircaps: i.helpPairCaps,
     join: i.helpJoin,
     me: i.helpMe,
     caps: i.helpCaps,
@@ -1982,6 +2106,7 @@ const helpSegs = (i, screen, st = {}) => {
   const lg = (st.logins || [])[Math.min(st.sel?.logins || 0, Math.max(0, (st.logins || []).length - 1))]
   return segs({
     pending: !!st.pending,
+    drafts: draftChanges(st).length > 0,
     hasDevices: (st.devices?.issued || []).length > 0,
     isService: !!cur?.cn,
     hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
@@ -1996,6 +2121,7 @@ const title = (i, screen) => ({
   profiles: i.titleProfiles,
   pairing: i.titlePairing,
   pairmode: i.titlePairMode,
+  paircaps: i.titlePairCaps,
   join: i.titleJoin,
   caps: i.titleCaps,
   devvars: i.titleDevVars
@@ -2114,6 +2240,7 @@ function render (term, st) {
   else if (st.screen === 'caps') body = renderList(capsRows(st, t), st.sel.caps || 0, contentH, cols, t, scrollRef)
   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 === '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)
     body = scrollBody(pb, contentH, scrollRef)
@@ -2196,7 +2323,9 @@ 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, devvars: 0, logins: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, paircaps: 0, devvars: 0, logins: 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.
     unlockedHere: new Set(),
     // Su contraseña, SOLO en memoria y SOLO mientras la TUI esté abierta: sirve para
@@ -2254,7 +2383,7 @@ export async function runTui () {
       // input/confirm se AWAITan: serializa las ops contra el daemon (ver onInputKey).
       // Ctrl-C dentro de un modal lo CANCELA (no sale); fuera de un modal, sale.
       if (st.input) { await onInputKey(st, key); continue }
-      if (st.confirm) { await onConfirmKey(st, key); continue }
+      if (st.confirm) { await onConfirmKey(st, key); if (st.quit) running = false; continue }
       if (key.name === 'ctrl-c') { running = false; continue }
 
       // TECLEAR ES USO. El candado se cierra a los 5 min de no usarse, y hasta ahora
@@ -2265,8 +2394,12 @@ export async function runTui () {
       seguirAqui(st)
 
       const ch = key.name === 'char' ? key.ch.toLowerCase() : null
-      // 'q' global sale.
-      if (ch === 'q') { running = false; continue }
+      // 'q' global sale — preguntando antes si hay permisos sin guardar.
+      if (ch === 'q') {
+        if (draftChanges(st).length) unlessDrafts(st, () => { st.quit = true })
+        else running = false
+        continue
+      }
       // 'l' global: idioma es⇄en en cualquier pantalla (por eso el candado es 'c').
       if (ch === 'l') { toggleLang(st); continue }
       // ←→ cambia entre las pestañas de la bóveda entrada (Dispositivos/Scopes).
@@ -2282,7 +2415,9 @@ export async function runTui () {
       // Esc/'b' desde una pestaña vuelve a la lista de bóvedas (salir de la bóveda
       // entrada). La pantalla de emparejamiento maneja su propio Esc (va a Dispositivos).
       if ((key.name === 'escape' || ch === 'b') && INNER_TABS.includes(st.screen)) {
-        st.screen = 'profiles'; continue
+        // El borrador es de ESTA bóveda: al salir de ella se guarda o se tira.
+        unlessDrafts(st, () => { st.capsDrafts = {}; st.screen = 'profiles' })
+        continue
       }
 
       if (st.screen === 'profiles') running = await onKeyProfiles(term, st, key)
@@ -2293,6 +2428,7 @@ export async function runTui () {
       else if (st.screen === 'caps') running = await onKeyCaps(term, st, key)
       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 === '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)
     }
@@ -2309,4 +2445,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, 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, 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

@@ -78,11 +78,21 @@ const es = {
   titleCaps: 'Permisos del dispositivo',
   capsFor: (id, name) => `Permisos de ${id}${name ? ' · ' + name : ''}`,
   capsNoMember: '  (este dispositivo ya no está en el perfil)',
-  capsApplyHint: 'Enter marca o desmarca · G guarda los cambios · Esc sale',
-  capsPending: (n) => `${n} cambio(s) sin guardar (*) · G para guardarlos todos de una vez · Esc para descartarlos`,
-  capsSaved: (n) => `${n} cambio(s) guardados de una vez`,
+  capsApplyHint: 'Enter marca o desmarca · G guarda · Esc vuelve a la lista sin perder lo marcado',
+  capsPending: (n) => `${n} cambio(s) sin guardar en este aparato (*) · G guarda todo en una sola acta`,
+  capsPendingOthers: (n) => `Y hay cambios en ${n} aparato(s) más: G los guarda juntos`,
+  capsSavedMany: (n, d) => `${n} cambio(s) en ${d} aparato(s), guardados en una sola acta`,
   capsNothing: 'No has cambiado nada',
-  capsDiscard: '¿Descartar los cambios sin guardar?',
+  capsDiscardAll: (n) => `¿Descartar los permisos sin guardar de ${n} aparato(s)?`,
+  devicesDraft: (n) => `${n} aparato(s) con permisos sin guardar (*) · G los guarda en una sola acta`,
+  // PERMISOS AL EMPAREJAR: se eligen antes del código y el aparato entra ya con ellos.
+  titlePairCaps: 'Qué podrá hacer',
+  pairCapsFor: (name) => `Permisos con los que entra ${name ? '«' + name + '»' : 'el aparato nuevo'}`,
+  pairCapsService: (ns) => `Permisos con los que entra el servicio «${ns}»`,
+  pairCapsHint: 'Enter marca o desmarca · G genera el código · Esc cancela. Entra ya con estos: no hace falta cambiarlos después.',
+  pairCapsNone: 'Marca al menos un permiso',
+  pairCapsNewDevice: 'el aparato nuevo',
+  helpPairCaps: ['↑↓', 'Enter marcar', 'G generar código', 'Esc cancelar', 'l English', 'q salir'],
   // EL NOMBRE DICE EL ACTO, NO LA CONSECUENCIA (dueño, 2026-09-02: «que digan exactamente
   // lo que hacen y no lo que implican»). «Sellar el acta» y «Administrar el perfil» eran
   // lo segundo: hay que saberse el modelo para traducirlos. Lo que hacen es admitir
@@ -361,8 +371,9 @@ const es = {
   // Anunciar teclas muertas confunde y además las quema para otros usos.
   // `e variables` solo en un SERVICIO: es el único que las lee, así que en un teléfono
   // era una tecla que solo sabía decir que no.
-  helpDevices: ({ pending, hasDevices, isService } = {}) => [
+  helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
     '←→ pestaña', '↑↓', 'p emparejar',
+    ...(drafts ? ['g guardar permisos'] : []),
     ...(pending ? ['a aprobar', 'x rechazar'] : []),
     ...(hasDevices ? ['r renombrar', 'c permisos'] : []),
     ...(isService ? ['e variables'] : []),
@@ -486,11 +497,21 @@ 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 · 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 one go`,
+  capsApplyHint: 'Enter ticks or unticks · G saves · Esc goes back to the list keeping your ticks',
+  capsPending: (n) => `${n} unsaved change(s) on this device (*) · G saves everything in ONE record`,
+  capsPendingOthers: (n) => `And ${n} more device(s) have changes: G saves them together`,
+  capsSavedMany: (n, d) => `${n} change(s) on ${d} device(s), saved in one record`,
   capsNothing: 'You have not changed anything',
-  capsDiscard: 'Discard the unsaved changes?',
+  capsDiscardAll: (n) => `Discard the unsaved permissions of ${n} device(s)?`,
+  devicesDraft: (n) => `${n} device(s) with unsaved permissions (*) · G saves them in one record`,
+  // PERMISSIONS WHEN PAIRING: chosen before the code; the device joins already with them.
+  titlePairCaps: 'What it will be able to do',
+  pairCapsFor: (name) => `Permissions ${name ? '“' + name + '”' : 'the new device'} joins with`,
+  pairCapsService: (ns) => `Permissions the “${ns}” service joins with`,
+  pairCapsHint: 'Enter ticks or unticks · G creates the code · Esc cancels. It joins with these: no need to change them afterwards.',
+  pairCapsNone: 'Tick at least one permission',
+  pairCapsNewDevice: 'the new device',
+  helpPairCaps: ['↑↓', 'Enter tick', 'G create code', 'Esc cancel', 'l Español', 'q quit'],
   // El título es el NOMBRE del permiso, el mismo que se teclea. Ver la nota en el bloque
   // español: describirlo dejaba una lista donde no se sabía qué permiso era cuál.
   capName: {
@@ -725,8 +746,9 @@ const en = {
   helpConfirm: 'y confirm · n/Esc cancel',
 
   helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'u unlock', 'k lock', 'l Español', 'q quit'],
-  helpDevices: ({ pending, hasDevices, isService } = {}) => [
+  helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
     '←→ tab', '↑↓', 'p pair',
+    ...(drafts ? ['g save permissions'] : []),
     ...(pending ? ['a approve', 'x reject'] : []),
     ...(hasDevices ? ['r rename', 'c permissions'] : []),
     ...(isService ? ['e variables'] : []),

package/src/vault.js

@@ -1577,15 +1577,22 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   /**
    * PEDIDOS DE APROBACIÓN (aparatos marcados con `approval on`). Entran por `vault.secrets` con
-   * `op: approvals | approve | deny`, firmados por un aparato con `vault:approve` — que,
-   * como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`). El acta tiene
-   * que decirlo también, para que quitar el permiso surta efecto en el acto.
+   * `op: approvals | approve | deny`, firmados por un aparato al que el ACTA le da `approve`
+   * — que, como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`).
+   *
+   * DECIDE EL ACTA, NO EL PAPEL (dueño, 2026-09-26). El papel solo prueba que el aparato es
+   * de esta bóveda y no está revocado; por eso no se le pide `vault:approve`. Pedírselo
+   * contestaba `unauthorized: scope` a un teléfono SIN el permiso, el teléfono lo tomaba por
+   * un papel atrasado, pedía renovarlo, y renovar firma con la maestra: con la bóveda
+   * cerrada le llegaba «vault locked», que no era la causa. Ahora le llega `acta`, que sí lo
+   * es. Y a uno CON el permiso ya no le hace falta renovar para aprobar: funciona con la
+   * bóveda cerrada, como todos los aparatos.
    */
   async function handleApproval (from, p) {
     const op = p.data?.op
     const chk = await verifyChain({
       data: p.data, signature: p.signature, cert: p.cert,
-      expectedScope: SCOPE.APPROVE, ...(await contextoActa()), revoked: await revocationSet()
+      ...(await contextoActa()), revoked: await revocationSet()
     })
     if (!chk.ok) return denyChain(from, chk, p, 'approval')
     const record = (await identity.profileActa?.().catch(() => null))?.acta
@@ -3494,6 +3501,41 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return secrets.openBundle(ns, devicePub, adminKey)
   }
 
+  /**
+   * CAMBIA LOS PERMISOS DE UNO O VARIOS APARATOS EN UNA SOLA ACTA. `changes`: `[{ pub, caps }]`,
+   * cada `caps` la lista COMPLETA de ese aparato.
+   */
+  async function setCapsMany (changes) {
+    if (!Array.isArray(changes) || !changes.length) throw Object.assign(new Error('no changes to save'), { code: 'NO_CHANGES' })
+    if (typeof identity.setCapsMany !== 'function') {
+      throw Object.assign(new Error('this build\'s @dotrino/identity cannot change several devices at once (needs setCapsMany)'), { code: 'caps-many-unavailable' })
+    }
+    const r = await identity.setCapsMany(changes)
+    // ¿SE QUEDÓ ALGUNO POR EL CAMINO? El acta tiene una lista CERRADA de permisos y
+    // `cleanCaps` descarta los que no conoce — correcto al recibir un acta ajena, y
+    // pésimo aquí: conceder `+sella` con una versión del pilar que no sabe qué es
+    // devolvía «Listo», resellaba el acta y no concedía nada. Costó una tarde en un
+    // contenedor, porque la imagen traía la versión de npm y el árbol local otra.
+    try {
+      const members = (await identity.profileMembers()).members
+      for (const { pub, caps } of changes) {
+        const quedaron = new Set(members.find((m) => m.pub === pub)?.caps || [])
+        const perdidos = caps.filter((c) => !quedaron.has(c))
+        if (perdidos.length) {
+          log(`[vault] WARNING these permissions were DROPPED: ${perdidos.join(', ')} — this build's @dotrino/identity does not know them (record unchanged for those)`)
+        }
+      }
+    } catch (_) { /* comprobar es un extra: si falla, no rompe el cambio */ }
+    const devices = await Promise.all(changes.map(async ({ pub, caps }) => ({ deviceId: await deviceIdOf(pub).catch(() => null), caps })))
+    for (const d of devices) audit('caps', { device: d.deviceId, caps: d.caps })
+    // El acta acaba de cambiar QUIÉN debe tener envoltura de qué: se repasa antes de
+    // avisar, para que el aviso salga con el llavero ya al día.
+    await refreshWraps('caps')
+    // UN aviso: un aparato solo (la forma de siempre) o la lista, si fueron varios.
+    await notifyMembers('caps', devices.length === 1 ? devices[0] : { devices })
+    return r
+  }
+
   /** El miembro del acta con esa llave, o `null` (también si la bóveda todavía no tiene acta). */
   async function memberOf (pub) {
     const record = (await identity.profileActa?.().catch(() => null))?.acta
@@ -3835,27 +3877,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     secretRecipients: (owner) => secrets.recipientsIn(owner),
     // ¿Es ESTA bóveda la que sella el acta? Lo usa el freno de borrado (D12).
     isMaster: () => identity.isMaster(),
-    setCaps: async (pub, caps) => {
-      const r = await identity.setCaps(pub, caps)
-      // ¿SE QUEDÓ ALGUNO POR EL CAMINO? El acta tiene una lista CERRADA de permisos y
-      // `cleanCaps` descarta los que no conoce — correcto al recibir un acta ajena, y
-      // pésimo aquí: conceder `+sella` con una versión del pilar que no sabe qué es
-      // devolvía «Listo», resellaba el acta y no concedía nada. Costó una tarde en un
-      // contenedor, porque la imagen traía la versión de npm y el árbol local otra.
-      try {
-        const quedaron = new Set((await identity.profileMembers()).members.find((m) => m.pub === pub)?.caps || [])
-        const perdidos = caps.filter((c) => !quedaron.has(c))
-        if (perdidos.length) {
-          log(`[vault] WARNING these permissions were DROPPED: ${perdidos.join(', ')} — this build's @dotrino/identity does not know them (record unchanged for those)`)
-        }
-      } catch (_) { /* comprobar es un extra: si falla, no rompe el cambio */ }
-      audit('caps', { device: await deviceIdOf(pub).catch(() => null), caps })
-      // El acta acaba de cambiar QUIÉN debe tener envoltura de qué: se repasa antes de
-      // avisar, para que el aviso salga con el llavero ya al día.
-      await refreshWraps('caps')
-      await notifyMembers('caps', { deviceId: await deviceIdOf(pub).catch(() => null), caps })
-      return r
-    },
+    setCaps: async (pub, caps) => setCapsMany([{ pub, caps }]),
+    // VARIOS APARATOS EN UNA SOLA ACTA (dueño, 2026-09-26): el borrador de la TUI se sella
+    // de golpe, con UN repaso del llavero y UN aviso, en vez de uno por aparato.
+    setCapsMany,
     // Renombrar un dispositivo: es un nombre para el humano (no toca permisos ni llaves),
     // pero pasa por el acta y se avisa, para que el cambio no sea invisible en el resto.
     setLabel: async (pub, label) => {

package/src/vaultControl.js

@@ -46,6 +46,7 @@ const F = {
   revokeReq: 'revoke-request.json',
   labelReq: 'label-request.json',
   capsReq: 'caps-request.json',
+  capsRes: 'caps.json',
   secretReq: 'secret-request.json',
   profileReq: 'profile-request.json',
   meReq: 'me-request.json',
@@ -462,6 +463,26 @@ export async function setDeviceCaps (pub, caps, profile) {
   return listDevices(profile)
 }
 
+/**
+ * Cambia los permisos de VARIOS dispositivos en UNA sola acta: `[{ pub, caps }]`, cada
+ * `caps` la lista completa de ese aparato. Es lo que guarda el borrador de la TUI cuando
+ * tocaste más de uno (dueño, 2026-09-26: «con esto me evito más actas inútiles»).
+ */
+export async function setDevicesCaps (changes, profile) {
+  requireAlive()
+  if (!Array.isArray(changes) || !changes.length) throw coded('no changes to save', 'NO_CHANGES')
+  const since = Date.now()
+  const id = await writeReq(F.capsReq, { changes }, profile)
+  signalOrCleanup('SIGUSR2', [F.capsReq])
+  // SE ESPERA LA RESPUESTA: con varios aparatos a la vez, un «Guardado» que no lo era
+  // deja creer que se firmó lo que no.
+  const r = await waitFor(F.capsRes, { req: id, since, tries: 40 })
+  if (!r) throw coded('the daemon did not reply', 'NO_REPLY')
+  assertOpen(r)
+  if (r.ok === false) throw coded(r.error || 'could not change the permissions', r.code || 'CAPS_FAILED')
+  return listDevices(profile)
+}
+
 /**
  * Quita un dispositivo por su llave `sub` (le ordena autoborrarse) y revuelca.
  * Se acepta un `nonce` suelto por compatibilidad, pero eso retira UN certificado:
@@ -731,15 +752,18 @@ export function pairUrl (qr) {
   return { url: inviteUrl(qr), code, payload: JSON.stringify(qr), b64: code }
 }
 
-export async function startPairing ({ profile, service, label } = {}) {
+export async function startPairing ({ profile, service, label, caps } = {}) {
   requireAlive()
   rm(F.pair); rm(F.pending)
-  await writeReq(F.pairReq, { ...(service ? { service } : {}), ...(label ? { label } : {}) }, profile)
+  // `caps`: los permisos con los que el aparato entra al acta. Van en la MISMA acta que lo
+  // admite, así que no hace falta otra para dárselos después.
+  await writeReq(F.pairReq, { ...(service ? { service } : {}), ...(label ? { label } : {}), ...(Array.isArray(caps) ? { caps } : {}) }, profile)
   signalOrCleanup('SIGUSR1', [F.pairReq])
   for (let i = 0; i < 50; i++) {
     await sleep(100)
     const pr = read(F.pair, null)
     assertOpen(pr)
+    if (pr?.error) throw coded(pr.error, pr.code || 'PAIR_FAILED')
     if (pr?.expiresAt > Date.now()) {
       const { url, payload, code } = pairUrl(pr.qr)
       // `profile`/`profileName`: DE QUÉ CUENTA del vault sale este QR. El vault