@dotrino/vaultd 0.77.0 → 0.79.0

package/lib/src/admin.js

@@ -60,7 +60,20 @@ export const ADMIN_OPS = Object.freeze([
 ])
 
 /**
- * LO ÚNICO QUE SE ATIENDE CON EL CANDADO ECHADO: mirar. Ni una operación que cambie algo.
+ * QUÉ SE ATIENDE CON EL CANDADO ECHADO.
+ *
+ * No es «solo mirar», y confundirlo fue un error: **guardar una variable NO necesita la
+ * maestra**. Sellar un valor usa las llaves PÚBLICAS de quien va a leerlo, así que la
+ * bóveda puede hacerlo sin ningún secreto suyo (`docs/secretos-sellados.md` §8.1) — es
+ * justo lo que hace barata la rotación. Meterlo en el mismo saco que revocar dejaba la
+ * consola sin poder configurar nada con el perfil cerrado, que es su trabajo diario.
+ *
+ * Lo que SÍ se queda fuera es `revoke`: reescribe el acta, y sellar el acta es de la
+ * maestra. Cerrada no hay con qué.
+ *
+ * (Si el cajón tiene su llave sellada con la frase, repartirla a los miembros puede quedar
+ * a deber hasta que alguien abra: eso ya lo dice la bóveda y se salda solo. Guardar el
+ * valor, que es lo que se pidió, se hace igual.)
  *
  * El candado ES de la consola —los aparatos ya emparejados siguen leyendo, guardando y
  * firmando con SU llave— así que cerrar el perfil tiene que cerrar exactamente esto. No
@@ -72,7 +85,7 @@ export const ADMIN_OPS = Object.freeze([
  * Se dejan las de LEER a propósito: si se cortaran todas, la consola no podría ni
  * enterarse de por qué no funciona y parecería rota. Así puede decir «está cerrada».
  */
-export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars', 'var.set', 'var.setMany'])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -136,7 +149,7 @@ export function createAdminDesk ({
     }
     const by = await deviceIdOf(chk.device).catch(() => null)
 
-    // CERRADA NO SE ADMINISTRA. Va después de autorizar (el candado es estado del perfil,
+    // CERRADA NO SE SELLA EL ACTA. Va después de autorizar (el candado es estado del perfil,
     // y a un desconocido no se le cuenta) y ANTES de quemar el nonce: quien reintente
     // tras abrir la bóveda no tiene por qué generar otro.
     //

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.77.0",
+  "version": "0.79.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.75.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
@@ -575,7 +576,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 +618,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 +645,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 +1499,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/transport.js

@@ -66,7 +66,16 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
     if (comm && esMiembro) {
       const data = { op: 'identify', publickey: comm, token: client.token, ts: Date.now() }
       const signature = await commKey.sign(data)
-      if (signature) return client.identify({ data, signature, acta: record })
+      if (signature) {
+        await client.identify({ data, signature, acta: record })
+        // SE DICE QUE SE IDENTIFICÓ, y con qué llave. Este camino era MUDO: al pasar de la
+        // maestra a la llave de comunicación, el único rastro de «estoy alcanzable» que
+        // quedaba en el log era el del repliegue. Así que cuando la consola decía «no
+        // contesta», no había forma de saber desde aquí si la bóveda estaba atada al proxio
+        // o no. Una línea por reconexión es barata; no tenerla cuesta una hora de sondeos.
+        log('[vault] identified on the proxy with the communication key · record #%s', record?.seq ?? '?')
+        return
+      }
     }
 
     // REPLIEGUE, y solo para migrar: una bóveda que todavía no ha metido su llave de

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)

package/src/tui/i18n.js

@@ -48,7 +48,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,7 +62,8 @@ 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}`,
@@ -358,7 +360,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,7 +370,8 @@ 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}`,

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
@@ -285,8 +292,26 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return new Set(revoked.map((r) => r.nonce))
   }
 
+  /**
+   * CONTESTAR SIN MATAR LA CONEXIÓN.
+   *
+   * El proxio corta los frames a 1 MB (`maxPayload`), y `ws` no «descarta» el que se pasa:
+   * CIERRA EL SOCKET con un 1009. La bóveda se queda muda, sin un solo error en su log, y
+   * desde fuera se ve igual que si estuviera apagada. Eso ya pasó y duró tres días.
+   *
+   * Así que una respuesta que no quepa no se manda: se sustituye por un error, que sí cabe.
+   * Una bóveda que dice «no cabe» se arregla; una muda no se puede ni diagnosticar.
+   */
   const reply = (to, obj) => {
-    try { client.send(to, obj) } catch (e) { log('[vault] could not reply:', e.message) }
+    try {
+      const bytes = Buffer.byteLength(JSON.stringify(obj))
+      if (bytes > MAX_REPLY_BYTES) {
+        log(`[vault] the reply to ${obj?.type} does not fit (${bytes} bytes > ${MAX_REPLY_BYTES}): sending an error instead of killing the connection`)
+        audit('reply-too-big', { type: obj?.type || null, bytes })
+        return client.send(to, { type: MSG.ERROR, error: `reply too big (${bytes} bytes): ask for less at a time` })
+      }
+      client.send(to, obj)
+    } catch (e) { log('[vault] could not reply:', e.message) }
   }
 
   // FRESCURA anti-replay: toda petición firmada debe traer `data.ts` dentro de una
@@ -680,7 +705,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!msg.chain?.length) msg.chain = null
     const left = msg.chain?.length || 0
     log(`[vault] record chain trimmed to fit the transport: ${left}/${full} link(s), ${size(msg)} bytes`)
-    if (size(msg) > MAX_REPLY_BYTES) log(`[vault] ⚠ the reply STILL does not fit (${size(msg)} bytes): the proxy will drop it`)
+    // Si tras podar la cadena SIGUE sin caber, no se avisa y se manda igual —eso mataba la
+    // conexión—: se devuelve tal cual y `reply` lo sustituye por un error. El aviso de aquí
+    // sobra porque el de `reply` dice lo mismo y además dice qué hizo.
     return msg
   }
 
@@ -815,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 })
@@ -1037,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 }) => {
@@ -2031,6 +2062,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   return {
     identity, client, store, threads, secrets, master, fingerprint: fp, dir,
+    // Se expone para poder PROBAR que una respuesta que no cabe no mata la conexión: es el
+    // único punto por el que sale todo, y el fallo que cierra vive justo ahí.
+    reply,
     /**
      * SOLTAR LA MAESTRA. Cerrar el perfil tiene que sacarla de la memoria, no solo dejar de
      * cargarla en el siguiente arranque: si no, el candado seguiría siendo una bandera al
@@ -2053,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,