@dotrino/vaultd 0.108.0 → 0.111.0

package/lib/src/admin.js

@@ -61,7 +61,11 @@ export const ADMIN_OPS = Object.freeze([
   // documentada en `buildSealedVar` y la consola la llamaba, pero no existía — así que
   // crear una variable desde la consola contestaba «admin: invalid operation». No expone
   // nada nuevo: son llaves PÚBLICAS, las mismas que ya viajan en el acta.
-  'vars', 'var.set', 'var.setMany', 'var.recipients'
+  'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // ABRIR LA BÓVEDA A DISTANCIA (`docs/abrir-a-distancia.md`). Dos pasos: `unlock.begin`
+  // pide una llave efímera y los parámetros del molino; `unlock` trae la derivada dentro
+  // de un sobre que solo esta bóveda puede abrir. No hay una tercera.
+  'unlock.begin', 'unlock'
 ])
 
 /**
@@ -90,7 +94,13 @@ 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', 'var.set', 'var.setMany', 'var.recipients'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze([
+  'audit', 'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // Las dos de abrir, obviamente: son las únicas que solo tienen sentido con el candado
+  // echado. Que estén aquí NO las deja pasar sin más — siguen exigiendo cert, acta, nonce
+  // y frescura como todas, y además la contraseña dentro del sobre.
+  'unlock.begin', 'unlock'
+])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -133,6 +143,10 @@ export function authorBody (owner, key, e, ts) {
 export function createAdminDesk ({
   desk, verify, readActivity = () => [], deviceIdOf, vars = null,
   notify = async () => {}, audit = () => {}, isLocked = () => false,
+  // ABRIR A DISTANCIA. Va inyectado —como `vars`— porque abrir necesita cripto y disco, y
+  // este módulo es puro a propósito. `null` en una bóveda que no lo soporte: entonces la
+  // operación existe y contesta que no, en vez de romper con un TypeError.
+  unlockDesk = null,
   now = () => Date.now()
 }) {
   const ops = new Set(ADMIN_OPS)
@@ -193,6 +207,17 @@ export function createAdminDesk ({
 
     try {
 
+      // ABRIR A DISTANCIA. La bóveda hace el trabajo; aquí solo se enruta, porque este
+      // módulo es puro —sin cripto, sin disco— y abrir necesita las dos cosas.
+      if (data.op === 'unlock.begin') {
+        if (!unlockDesk) return { ok: false, error: 'admin: this vault cannot be opened remotely (update it)' }
+        return { ok: true, result: await unlockDesk.begin({ by, device: chk.device }) }
+      }
+      if (data.op === 'unlock') {
+        if (!unlockDesk) return { ok: false, error: 'admin: this vault cannot be opened remotely (update it)' }
+        return await unlockDesk.open({ nonce: data.nonce, enc: data.enc, by, device: chk.device })
+      }
+
       if (data.op === 'audit') {
         const limit = Math.min(Math.max(Number(data.limit) || 100, 1), AUDIT_MAX)
         return { ok: true, result: { entries: readActivity(limit) } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.108.0",
+  "version": "0.111.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,7 +22,7 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.79.0",
+    "@dotrino/identity": "0.81.0",
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.15.0",
     "@dotrino/roadmap": "0.2.0",

package/src/ctl.js

@@ -598,6 +598,11 @@ async function cmdMembers () {
     // QUÉ CORRE, y si cuadra con esta bóveda (CONVENCIONES §14). Sin esto una
     // incompatibilidad de versiones se ve como que ese aparato «no responde», que es el
     // fallo más caro que ha tenido el ecosistema. No bloquea nada: se enseña.
+    // RENUNCIAS SIN SELLAR. Ya no los tiene —la bóveda no se los reconoce— pero el acta
+    // que se lee arriba todavía los nombra, así que hay que decirlo aquí o la lista miente.
+    if (m.renounced?.length) {
+      console.log('      %s↓ renunció a %s (pendiente de sellar: abre la bóveda)%s', R, m.renounced.join(', '), Z)
+    }
     if (m.running) {
       const v = `${m.running.product} ${m.running.version}`
       if (m.running.compatible) console.log('      %scorre %s%s', D, v, Z)
@@ -1577,8 +1582,28 @@ async function cmdProfile (rest) {
       reportProfiles(await profileRequest('password-set', { password: pwd, current: actual || undefined }))
       return
     }
+    // LA CONTRASEÑA DEL ADMIN. Otra, distinta, que solo sirve desde el admin remoto — aquí
+    // no abre nada. Pantalla administrativa: dice qué hace y qué no, y ya (§5.1).
+    case 'admin-password': {
+      const action = args[0]
+      if (action === 'rm') {
+        reportProfiles(await profileRequest('admin-password-rm', {}))
+        return
+      }
+      if (action && action !== 'set') { console.error('uso: dotrino-vault profile admin-password [set|rm]'); process.exit(2) }
+      console.log('Una contraseña APARTE, para abrir la bóveda desde el admin remoto.')
+      console.log('Aquí no abre nada: tecleada en esta máquina no vale. Y para usarla hace')
+      console.log('falta además un aparato tuyo que administre — la contraseña sola no basta.')
+      console.log('\nEl perfil tiene que estar abierto ahora mismo para poder ponerla.')
+      const pwd = await askPassword('\nContraseña del admin: ')
+      if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+      const again = await askPassword('Repítela: ')
+      if (pwd !== again) { console.error('Las contraseñas no coinciden.'); process.exit(1) }
+      reportProfiles(await profileRequest('admin-password-set', { password: pwd }))
+      return
+    }
     default:
-      console.error('uso: dotrino-vault profile {ls|add|rename|use|rm|password}'); process.exit(2)
+      console.error('uso: dotrino-vault profile {ls|add|rename|use|rm|password|admin-password}'); process.exit(2)
   }
 }
 

package/src/daemon.js

@@ -24,6 +24,7 @@ import { ipcRead, ipcWrite, migrateIpcDir } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
 import { watchBinary } from './selfupdate.js'
 import { VERSION } from './version.js'
+import crypto from 'node:crypto'
 
 const readJsonSafe = (f) => ipcRead(f, null)
 const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
@@ -400,6 +401,35 @@ export async function runDaemon () {
         mgr.profiles.removePassword(id)
         return { done: 'contraseña quitada · los secretos ahora se abren con la llave de esta máquina' }
       }
+      // ----- LA CONTRASEÑA DEL ADMIN (`docs/abrir-a-distancia.md`) -----
+      //
+      // Otra contraseña, distinta, que **solo sirve por el camino del admin**. Lo que se
+      // guarda es una copia de la llave del perfil cifrada con lo que sale de ella; por eso
+      // ponerla exige el perfil abierto: esa llave solo está en memoria con el candado
+      // descorrido.
+      //
+      // El molino se hace AQUÍ porque quien la pone está delante de la máquina y ya tecleó
+      // la principal. Cuando se USA a distancia lo hace el navegador, y por eso la bóveda
+      // publica los parámetros (`secondaryParams`).
+      case 'admin-password-set': {
+        const id = ref()
+        if (!req.password) throw new Error('an admin password is required')
+        // El salt se acuña ANTES de derivar (`mint`), para derivar una sola vez con el
+        // definitivo. El molino se hace aquí porque quien la pone está delante de la
+        // máquina y acaba de teclear la principal; cuando se USA a distancia lo hace el
+        // navegador, y por eso la bóveda publica estos mismos parámetros.
+        const params = mgr.profiles.secondaryParams(id, { mint: true })
+        const derivada = new Uint8Array(crypto.scryptSync(
+          String(req.password), Buffer.from(params.salt, 'base64'),
+          params.len, { N: params.N, r: params.r, p: params.p }))
+        try { mgr.profiles.setSecondary(id, derivada) } finally { wipe(derivada) }
+        return { done: 'contraseña del admin guardada · solo sirve desde el admin, no aquí' }
+      }
+      case 'admin-password-rm': {
+        const id = ref()
+        const r = mgr.profiles.clearSecondary(id)
+        return { done: r.had ? 'contraseña del admin quitada' : 'no había ninguna' }
+      }
       default: throw new Error('unknown profile operation: ' + req.op)
     }
   }

package/src/manager.js

@@ -98,6 +98,22 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       // Para la consola remota: la contraseña llega dentro del sobre firmado y hay que
       // convertirla en la llave que abre la copia maestra de los secretos.
       deriveAdminKey: (password) => profiles.adminKey(id, password),
+      // ABRIR A DISTANCIA (`docs/abrir-a-distancia.md`). La bóveda no toca el registro de
+      // perfiles: se le pasan las tres cosas que necesita y nada más — con qué números
+      // deriva el admin, cómo se abre con la derivada, y si hay contraseña de admin puesta.
+      secondaryParams: () => profiles.secondaryParams(id),
+      openWithSecondary: async (derivada) => {
+        const r = await profiles.openWithSecondary(id, derivada)
+        // Igual que `unlock`: abrir el perfil no basta, hay que traer la maestra a memoria.
+        // Sin esto el candado diría «abierto» y todo lo que la necesita fallaría en otro
+        // sitio y por otro motivo, que es el fallo que ya se pagó una vez.
+        try { await running.get(id)?.takeMasterKey?.() } catch (e) {
+          try { profiles.lock(id) } catch (_) {}
+          throw new Error(`opened the profile but could not open it: ${e.message}`)
+        }
+        return r
+      },
+      hasSecondary: () => profiles.hasSecondary(id),
       // La llave del perfil MIENTRAS esté abierto, o null. Con ella, enrolar un servicio
       // con la bóveda abierta le envuelve su cajón en el acto en vez de dejarlo entrar
       // sin poder leer nada (ver `profiles.js`, `llaves`).

package/src/profiles.js

@@ -24,12 +24,22 @@ import fs from 'node:fs'
 import crypto2 from 'node:crypto'
 import path from 'node:path'
 import { dataDir, ensureDir, readJson, writeJson } from './paths.js'
-import { atRestFor, migrateFile, kekFor } from './atrest.js'
+import { atRestFor, migrateFile, kekFor, encryptText, decryptText } from './atrest.js'
 import { probe as probeKek, writeConfig as writeKekConfig, configFromEnv } from './atrest.js'
 import { keyDirName, keyOwnerOf } from './keyowner.js'
 
 const REGISTRY = 'profiles.json'
 const PWD_ITER = 300000 // PBKDF2 del verificador v1 (heredado); v2 usa scrypt
+
+/**
+ * EL MOLINO, en un solo sitio. Estaba escrito a mano en cada llamada, y con la contraseña
+ * del admin eso deja de ser cosmética: **el navegador tiene que derivar con exactamente
+ * estos números**. Si aquí se cambia uno y allá no, la contraseña «deja de funcionar» sin
+ * que nada diga por qué, que es la clase de fallo que este proyecto viene evitando.
+ *
+ * Por eso también se le mandan al admin (`secondaryParams`) en vez de que los copie.
+ */
+export const SCRYPT = Object.freeze({ N: 16384, r: 8, p: 1, len: 32 })
 const MAX_NAME = 40
 /**
  * Lo MÍNIMO que se acepta al poner una contraseña.
@@ -98,7 +108,7 @@ const b64 = (buf) => Buffer.from(new Uint8Array(buf)).toString('base64')
  */
 function deriveScryptPwd (password, saltB64) {
   const salt = Buffer.from(saltB64, 'base64')
-  return b64(crypto2.scryptSync(String(password || ''), salt, 32, { N: 16384, r: 8, p: 1 }))
+  return b64(crypto2.scryptSync(String(password || ''), salt, SCRYPT.len, { N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p }))
 }
 
 /** PBKDF2-SHA256 → verificador base64 (v1, heredado). */
@@ -228,6 +238,35 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
     return p
   }
 
+  /**
+   * EL FRENO DE FUERZA BRUTA, en un solo sitio porque ahora hay DOS puertas.
+   *
+   * Tras 5 fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro. Los
+   * fallos VIEJOS se olvidan (`TRIES_FORGET_MS`): sigue frenando una ráfaga, pero no
+   * convierte un despiste de ayer en un vault que ya no se abre.
+   *
+   * **Las dos contraseñas cuentan en el MISMO contador**, y no es un detalle: si cada una
+   * llevara el suyo, probar por un camino no frenaría el otro y el freno valdría la mitad.
+   *
+   * Lanza con CÓDIGO: la TUI es bilingüe y lo traduce, y la CLI lo dice con sus palabras.
+   * Sin código, el rechazo llegaba como un texto suelto del daemon, indistinguible de
+   * «se volvió a pedir la contraseña porque sí».
+   */
+  function frenar (p) {
+    let tries = p.tries || { n: 0, at: 0 }
+    if (tries.at && Date.now() - tries.at > TRIES_FORGET_MS) {
+      tries = { n: 0, at: 0 }
+      if (p.tries) { delete p.tries; save() }
+    }
+    const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
+    const left = tries.at + waitMs - Date.now()
+    if (left > 0) {
+      throw Object.assign(new Error(`too many tries: wait ${Math.ceil(left / 1000)} s`),
+        { code: 'TOO_MANY_TRIES', waitSec: Math.ceil(left / 1000) })
+    }
+    return tries
+  }
+
   const api = {
     get root () { return root },
     dirOf,
@@ -497,32 +536,13 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
         save()
       }
       const salt = Buffer.from(p.kdf.salt, 'base64')
-      return new Uint8Array(crypto2.scryptSync(String(password || ''), salt, 32, { N: 16384, r: 8, p: 1 }))
+      return new Uint8Array(crypto2.scryptSync(String(password || ''), salt, SCRYPT.len, { N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p }))
     },
 
     async unlock (id, password) {
       const p = assertExists(id)
       if (!p.pwd) { open(id); return { ok: true, locked: false } }
-      // Freno de fuerza bruta (una contraseña corta se adivina probando): tras 5
-      // fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro.
-      // Los fallos VIEJOS se olvidan (ver TRIES_FORGET_MS): si desde el último ha pasado
-      // el rato, se empieza de cero. Así el freno sigue frenando una ráfaga —los intentos
-      // seguidos se cuentan igual— pero no convierte un despiste de ayer en un vault que
-      // ya no se abre.
-      let tries = p.tries || { n: 0, at: 0 }
-      if (tries.at && Date.now() - tries.at > TRIES_FORGET_MS) {
-        tries = { n: 0, at: 0 }
-        if (p.tries) { delete p.tries; save() }
-      }
-      const waitMs = tries.n >= 5 ? Math.min(2 ** (tries.n - 4) * 1000, 5 * 60 * 1000) : 0
-      const left = tries.at + waitMs - Date.now()
-      // Con CÓDIGO: la TUI es bilingüe y lo traduce, y la CLI puede decirlo con sus
-      // palabras. Sin código, el rechazo llegaba como un texto suelto del daemon y era
-      // indistinguible de «se volvió a pedir la contraseña porque sí».
-      if (left > 0) {
-        throw Object.assign(new Error(`too many tries: wait ${Math.ceil(left / 1000)} s`),
-          { code: 'TOO_MANY_TRIES', waitSec: Math.ceil(left / 1000) })
-      }
+      const tries = frenar(p)
       const proof = p.pwd.v === 2
         ? deriveScryptPwd(password, p.pwd.salt)
         : await derivePwd(password, p.pwd.salt, p.pwd.iter)
@@ -547,6 +567,99 @@ export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onA
       return { ok: true, locked: false }
     },
 
+    // ----- LA SEGUNDA CONTRASEÑA: la del admin (`docs/abrir-a-distancia.md`) -----
+    //
+    // DOS PUERTAS AL MISMO SITIO. La llave del perfil sale de `scrypt(principal, p.kdf.salt)`
+    // y es lo que destapa la maestra. Una segunda contraseña NO puede derivar una llave
+    // distinta —tiene que llegar a la misma—, así que lo que se guarda es **una copia de esa
+    // llave, cifrada con lo que sale de la secundaria**. Es el mismo patrón que los cajones:
+    // varios sobres, un destinatario cada uno.
+    //
+    // EL MOLINO LO HACE QUIEN LLAMA, no esto. Aquí entra `derivada` ya calculada, y hay dos
+    // motivos: la bóveda nunca llega a ver la contraseña del admin, y adivinar le cuesta el
+    // scrypt AL QUE PRUEBA en vez de costarle CPU a la bóveda (que además sería una forma de
+    // ahogarla). El freno sigue contando los fallos igual — ver `frenar`.
+    //
+    // Y por eso `derivada` VALE TANTO COMO LA CONTRASEÑA: quien la capture abre igual. Viaja
+    // cifrada a una llave efímera de la bóveda y la petición va firmada por un aparato del
+    // acta; esas dos cosas son las que la protegen, no el hecho de estar derivada.
+
+    /**
+     * Los parámetros para que el admin derive EXACTAMENTE igual. Son públicos: un salt no es
+     * un secreto y ya vive en el disco junto a los datos. `null` si este perfil no tiene
+     * segunda contraseña — entonces abrir a distancia sencillamente no está disponible.
+     */
+    secondaryParams (id, { mint = false } = {}) {
+      const p = find(id)
+      if (!p) return null
+      // `mint`: acuña el salt si todavía no hay ninguno. Lo pide QUIEN LA PONE, para poder
+      // derivar una sola vez con el salt definitivo — si no, habría que derivar, guardar, y
+      // volver a derivar con el salt que salió, que es como lo escribí primero y era torpe.
+      if (!p.kdf2) {
+        if (!mint) return null
+        p.kdf2 = { v: 1, salt: b64(crypto.getRandomValues(new Uint8Array(32))), wrapped: null }
+        save()
+      }
+      return { salt: p.kdf2.salt, ...SCRYPT }
+    },
+
+    /** ¿Tiene puesta la del admin? Es estado, y se enseña donde se administra. */
+    hasSecondary: (id) => !!find(id)?.kdf2?.wrapped,
+
+    /**
+     * Pone o cambia la contraseña del admin. **Exige el perfil ABIERTO**, porque lo que se
+     * guarda es la llave del perfil y esa solo está en memoria con el candado descorrido.
+     * Es lo correcto además de lo posible: ponerla es una decisión del dueño, y el dueño
+     * acaba de teclear la principal.
+     */
+    setSecondary (id, derivada) {
+      const p = assertExists(id)
+      if (!p.pwd) throw Object.assign(new Error('this profile has no password: there is nothing to open remotely'), { code: 'NO_PASSWORD' })
+      const llave = api.openKey(id)
+      if (!llave) throw Object.assign(new Error('open the profile first (dotrino-vault unlock)'), { code: 'PROFILE_LOCKED' })
+      if (!(derivada instanceof Uint8Array) || derivada.length !== 32) throw new Error('the admin key must be 32 bytes')
+      const salt = p.kdf2?.salt || b64(crypto.getRandomValues(new Uint8Array(32)))
+      p.kdf2 = { v: 1, salt, wrapped: encryptText(b64(llave), Buffer.from(derivada)) }
+      save()
+      return { ok: true }
+    },
+
+    /** La quita. Revocar es borrar el sobre: al instante y sin tocar la principal. */
+    clearSecondary (id) {
+      const p = assertExists(id)
+      if (!p.kdf2?.wrapped) { if (p.kdf2) { delete p.kdf2; save() } ; return { ok: true, had: false } }
+      delete p.kdf2
+      save()
+      return { ok: true, had: true }
+    },
+
+    /**
+     * ABRE CON LA DEL ADMIN. Recibe la derivada, descifra el sobre y saca la llave del
+     * perfil: de ahí para abajo el estado es idéntico a `unlock`, porque es la misma llave.
+     *
+     * No hay verificador aparte y no hace falta: AES-GCM autentica, así que una derivada
+     * equivocada **no descifra**, y eso ES la comprobación.
+     *
+     * Comparte el contador de `unlock` (`frenar`): probar por aquí frena allá y al revés.
+     */
+    async openWithSecondary (id, derivada) {
+      const p = assertExists(id)
+      if (!p.kdf2?.wrapped) throw Object.assign(new Error('this profile has no admin password'), { code: 'NO_SECONDARY' })
+      const tries = frenar(p)
+      let llave = null
+      try { llave = Buffer.from(decryptText(p.kdf2.wrapped, Buffer.from(derivada)), 'base64') } catch (_) { llave = null }
+      if (!llave || llave.length !== 32) {
+        p.tries = { n: tries.n + 1, at: Date.now() }
+        save()
+        throw Object.assign(new Error('wrong admin password'), { code: 'WRONG_PASSWORD', tries: p.tries.n })
+      }
+      delete p.tries
+      save()
+      open(id)
+      llaves.set(id, new Uint8Array(llave))
+      return { ok: true, locked: false }
+    },
+
     lock (id) { assertExists(id); unlocked.delete(id); olvidar(id); return { ok: true, locked: api.isLocked(id) } },
 
     /**

package/src/subacta.js

@@ -0,0 +1,102 @@
+/**
+ * subacta.js — LO DECIDIDO QUE TODAVÍA NO SELLÓ EL ACTA.
+ *
+ * Idea del dueño (2026-09-04): *«una subacta efímera que se comparte entre todos los
+ * dispositivos y puede tener decisiones a futuro que se aceptan cuando el acta se abre»*.
+ *
+ * EL AGUJERO QUE TAPA. Sellar el acta es de la maestra, y con el perfil cerrado la maestra
+ * no está. Así que una renuncia —«me quito estos permisos»— no surtía NINGÚN efecto hasta
+ * que alguien iba a la máquina y tecleaba la contraseña. Justo el caso que la renuncia
+ * existe para cubrir: te roban el teléfono, renuncias desde él, y el ladrón sigue siendo
+ * admin hasta que llegues. El pilar ya tenía la pieza (`extraRenounces`) y no la pasaba
+ * nadie.
+ *
+ * LA REGLA DURA, y es la que sostiene todo lo demás:
+ *
+ *     LA SUBACTA SOLO PUEDE QUITAR, NUNCA DAR.
+ *
+ * De ahí salen las tres propiedades que la hacen segura sin maestra:
+ *
+ *   · **Se autentica sola.** Cada entrada la firma EL MIEMBRO AL QUE AFECTA. No hace falta
+ *     sellador, así que no hay una segunda autoridad al lado del acta.
+ *   · **Una entrada falsa o repetida cuesta disponibilidad, no autoridad.** Lo peor que
+ *     consigue quien cuele una es quitarle permisos a alguien: molesto y reversible.
+ *   · **Nadie puede quitarle nada a otro.** Si valiera la firma de cualquiera, un servicio
+ *     con `secrets` en un VPS alquilado podría dejar sin `admin` a tu teléfono.
+ *
+ * Y por eso el catálogo de operaciones es una LISTA BLANCA de una sola: `renounce`. La
+ * lista es la regla — si algún día entra otra, tiene que quitar y venir firmada por su
+ * sujeto, y se escribe aquí a propósito, no se cuela.
+ *
+ * JUNTAR DOS ES UNIR. Dos entradas nunca se contradicen porque las dos quitan, así que no
+ * hay conflictos ni hace falta un `seq`. Y **solo salen al absorberse** en el acta: nunca
+ * por reloj, o un aparato apagado perdería justo la que lo protege.
+ */
+import path from 'node:path'
+import { verifyRenounce } from '@dotrino/identity/acta'
+import { readJson, writeJson } from './paths.js'
+
+/** Las operaciones que caben. La lista ES la regla: todas quitan, todas las firma su sujeto. */
+export const OPS = Object.freeze(['renounce'])
+
+/** Identidad de una entrada, para no guardar dos veces la misma. */
+const idOf = (e) => `${e.op}|${e.member}|${[...(e.caps || [])].sort().join(',')}|${e.ts}`
+
+/**
+ * ¿Es una entrada que se puede aceptar? Comprueba la FORMA y la FIRMA; que quite es
+ * estructural (el catálogo) y no una comprobación aparte.
+ */
+export async function isAcceptable (e) {
+  if (!e || !OPS.includes(e.op)) return false
+  if (e.op === 'renounce') return verifyRenounce(e).catch(() => false)
+  return false
+}
+
+/**
+ * La subacta de un perfil. Vive en su directorio y va cifrada en reposo como todo lo
+ * demás: sus entradas dicen qué aparatos se quedaron sin qué, y eso es material de la
+ * cuenta aunque no sea un secreto.
+ */
+export function openSubacta (dir, atRest) {
+  const file = path.join(dir, 'subacta.json')
+  let data = readJson(file, null, atRest) || { v: 1, entries: [] }
+  const guardar = () => writeJson(file, data, atRest)
+
+  return {
+    /** Las entradas vigentes, tal cual se le pasan a `memberCan` y compañía. */
+    entries () { return [...data.entries] },
+    get count () { return data.entries.length },
+
+    /** Las de UN miembro. Es lo que se mira al decidir sobre él. */
+    forMember (pub) { return data.entries.filter((e) => e.member === pub) },
+
+    /**
+     * Acepta una entrada. Devuelve `{ok, reason}` — y un `false` aquí no es un fallo del
+     * que la manda: puede ser que ya la tuviéramos, que es el caso normal cuando dos
+     * aparatos se cuentan lo mismo.
+     */
+    async add (e) {
+      if (!(await isAcceptable(e))) return { ok: false, reason: 'no-aceptable' }
+      const id = idOf(e)
+      if (data.entries.some((x) => idOf(x) === id)) return { ok: false, reason: 'ya-estaba' }
+      data.entries = [...data.entries, e]
+      guardar()
+      return { ok: true, reason: 'nueva' }
+    },
+
+    /**
+     * SACA TODO para absorberlo en el acta, y vacía. Se llama con la bóveda ABIERTA, que es
+     * la única que puede sellar. Vaciar aquí y fallar el sellado perdería la entrada, así
+     * que quien llama tiene que absorber primero y vaciar después (`clear`).
+     */
+    drain () { return [...data.entries] },
+
+    /** Vacía lo ya absorbido. Se le pasa lo que se absorbió, no «todo»: mientras se sella
+     *  puede haber entrado una nueva, y tirarla sería perder una renuncia sin aplicar. */
+    clear (absorbidas) {
+      const ids = new Set(absorbidas.map(idOf))
+      data.entries = data.entries.filter((e) => !ids.has(idOf(e)))
+      guardar()
+    }
+  }
+}

package/src/vault.js

@@ -15,7 +15,7 @@ import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain as verifyChainRaw, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
-import * as Acta from '@dotrino/identity/acta'
+import * as ActaPilar from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
 import { createAdminDesk, authorBody } from '../lib/src/admin.js'
 import { shouldNotifyRevoked } from '../lib/src/revocation.js'
@@ -27,6 +27,8 @@ import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
+import { openSubacta } from './subacta.js'
+import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.js'
 import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
 import { loadManifest, brokenOf } from '@dotrino/roadmap'
@@ -62,7 +64,7 @@ const MAX_REPLY_BYTES = 768 * 1024
  *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
  *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
  */
-export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, hasPassword = () => true, deriveAdminKey = null, openKey = null, forAdoption = false, onAdopted } = {}) {
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, hasPassword = () => true, deriveAdminKey = null, openKey = null, secondaryParams = null, openWithSecondary = null, hasSecondary = () => false, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
   // CIFRADO EN REPOSO ligado a esta máquina: ningún archivo del dir queda en claro, así
   // que copiarlos a otro equipo no sirve de nada. La identidad se migra AQUÍ (verificando
@@ -372,6 +374,55 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   /** El dictamen de un aparato, para enseñarlo o para pegárselo a un error. */
   const versionDe = (pub) => versiones.get(pub) || null
 
+  // ----- LA SUBACTA: lo decidido que todavía no selló el acta (`src/subacta.js`) -----
+  //
+  // Sellar es de la maestra, así que con el perfil CERRADO una renuncia no surtía ningún
+  // efecto: el aparato conservaba todos sus permisos hasta que alguien fuera a la máquina
+  // a teclear la contraseña. Justo el caso que la renuncia existe para cubrir.
+  //
+  // Se honra ya, sin sellar, y es seguro porque una entrada de la subacta SOLO PUEDE
+  // QUITAR: no concede nada a nadie, y va firmada por el miembro al que afecta.
+  const subacta = openSubacta(dir, atRestFor(dir))
+
+  /**
+   * EL ACTA, LEÍDA CON LA SUBACTA EN LA MANO.
+   *
+   * Envuelve al pilar en UN sitio en vez de pasar la lista en los diecisiete mostradores:
+   * una comprobación repetida diecisiete veces son dieciséis sitios donde olvidarla, y
+   * olvidarla aquí significa atender a un aparato que ya renunció.
+   *
+   * Solo se tocan las cinco que DECIDEN. El resto del pilar pasa tal cual.
+   */
+  const Acta = {
+    ...ActaPilar,
+    memberCan: (acta, pub, cap) => ActaPilar.memberCan(acta, pub, cap, subacta.forMember(pub)),
+    memberCanScope: (acta, pub, scope) => ActaPilar.memberCanScope(acta, pub, scope, subacta.forMember(pub)),
+    memberCanReadSecrets: (acta, pub, ns) => ActaPilar.memberCanReadSecrets(acta, pub, ns, subacta.forMember(pub)),
+    memberCanSign: (acta, pub, ns = null) => ActaPilar.memberCanSign(acta, pub, ns, subacta.forMember(pub)),
+    memberScopes: (acta, pub) => ActaPilar.memberScopes(acta, pub, subacta.forMember(pub)),
+    effectiveCaps: (acta, pub) => ActaPilar.effectiveCaps(acta, pub, subacta.forMember(pub))
+  }
+
+  /**
+   * ABSORBER lo pendiente en el acta. Solo con la bóveda abierta, que es la única que
+   * sella. Se vacía DESPUÉS y solo lo absorbido: mientras se sella puede entrar una nueva,
+   * y tirarla sería perder una renuncia sin aplicar.
+   */
+  async function absorberSubacta (motivo = 'unlock') {
+    const pendientes = subacta.drain()
+    if (!pendientes.length) return 0
+    const hechas = []
+    for (const e of pendientes) {
+      try { await identity.absorbRenounce(e); hechas.push(e) }
+      catch (err) { log(`[vault] ${motivo}: could not absorb a pending renounce: ${err.message}`) }
+    }
+    if (hechas.length) {
+      subacta.clear(hechas)
+      log(`[vault] ${motivo}: ${hechas.length} pending renounce(s) absorbed into the record`)
+    }
+    return hechas.length
+  }
+
   /**
    * LA VERSIÓN SE APUNTA DONDE YA SE COMPRUEBA LA FIRMA, y por eso esto envuelve a
    * `verifyChain` en vez de mirar el envoltorio del mensaje: `data` va firmado, así que
@@ -696,6 +747,74 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * el motivo real por el que editar el perfil exigía abrirla, y es el síntoma que abrió
    * todo esto: se cerraba sola a los cinco minutos y editar dejaba de funcionar.
    */
+  /**
+   * ABRIR LA BÓVEDA DESDE EL ADMIN (`docs/abrir-a-distancia.md`).
+   *
+   * Dos pasos, y el segundo no se puede reproducir por DOS candados distintos:
+   *
+   *   · el **nonce** hace que se NIEGUE a atenderlo dos veces (memoria, 10 min);
+   *   · la **efímera** hace que no se PUEDA abrir dos veces — se tira al usarla, así que
+   *     ese sobre queda inabrible hasta para nosotros, incluso con el disco en la mano.
+   *
+   * Por qué una efímera y no la llave de cifrado fija de la bóveda: esa cede a la llave de
+   * la máquina (modelo de amenazas §4.2), o sea que cae con el disco. La contraseña es
+   * justo lo único que un ladrón de disco NO tiene — cifrarla con algo que el disco
+   * entrega sería regalársela a quien grabe el tráfico hoy y robe el disco mañana.
+   *
+   * Y el molino lo hace el ADMIN: aquí llega la derivada, nunca la contraseña.
+   */
+  const EPHEMERAL_TTL_MS = 60 * 1000
+  const aperturas = new Map()   // nonce -> { privateKey, exp }
+
+  const unlockDesk = (typeof openWithSecondary === 'function' && typeof secondaryParams === 'function')
+    ? {
+        async begin ({ by }) {
+          const params = secondaryParams()
+          if (!params) {
+            throw new Error('this profile has no admin password: set one with `dotrino-vault profile admin-password`')
+          }
+          // Se barre lo vencido aquí y no con un temporizador: es barato, y un temporizador
+          // más es una cosa más que puede quedarse corriendo cuando el perfil ya no existe.
+          const t = Date.now()
+          for (const [n, v] of aperturas) if (v.exp <= t) aperturas.delete(n)
+          const eph = await makeEphemeralKey()
+          aperturas.set('pendiente', { privateKey: eph.privateKey, exp: t + EPHEMERAL_TTL_MS })
+          audit('unlock.begin', { by })
+          return { ...params, ek: eph.ek }
+        },
+
+        async open ({ nonce, enc, by }) {
+          const guardada = aperturas.get('pendiente')
+          aperturas.delete('pendiente')
+          if (!guardada || guardada.exp <= Date.now()) {
+            return { ok: false, error: 'unlock: ask for a key first, and use it within a minute' }
+          }
+          let payload = null
+          try { payload = await openSealed({ privateKey: guardada.privateKey, enc }) } catch (_) { payload = null }
+          // EL NONCE VA DENTRO DEL SOBRE. Si fuera solo por fuera, un sobre capturado se
+          // reenvía con un nonce nuevo y el candado del nonce no sirve de nada.
+          if (!payload || payload.nonce !== nonce || typeof payload.key !== 'string') {
+            audit('rejected', { what: 'unlock', by, reason: 'sobre' })
+            return { ok: false, error: 'unlock: the envelope does not check out' }
+          }
+          const derivada = new Uint8Array(Buffer.from(payload.key, 'base64'))
+          try {
+            const r = await openWithSecondary(derivada)
+            audit('unlock', { by })
+            log(`[vault] opened from the admin by ${by || '????-????'}`)
+            return { ok: true, result: { ok: true, locked: false } }
+          } catch (e) {
+            audit('rejected', { what: 'unlock', by, reason: e.code || 'error' })
+            // El freno viaja con el rechazo: sin él, el admin reintenta contra una puerta
+            // que ya no responde y no sabe por qué.
+            return { ok: false, code: e.code || null, error: e.message, tries: e.tries ?? null, waitSec: e.waitSec ?? null }
+          } finally {
+            derivada.fill(0)
+          }
+        }
+      }
+    : null
+
   const PROFILE_METHODS = new Set(['profilePut', 'profileBundle', 'profilePublic', 'profileRecipients'])
 
   async function handleProfile (from, p, d) {
@@ -958,7 +1077,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce,
       running: x.sub ? versionDe(x.sub) : null
     })))
-    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain, vault: MI_VERSION }))
+    // LA SUBACTA VIAJA CON EL ACTA. Es la mitad de «se comparte entre todos los
+    // dispositivos»: sin esto, una renuncia sin sellar solo la respeta esta máquina.
+    // Cada entrada va firmada por su sujeto, así que quien la recibe la verifica sola.
+    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain, vault: MI_VERSION, subacta: subacta.entries() }))
   }
 
   /**
@@ -1844,7 +1966,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
           // llave de la máquina de la bóveda, cuyo material vive en ese mismo disco.
           // El comentario de aquí decía «la consola lo dice en voz alta» y la consola
           // no decía nada — el mismo error que el comentario mentiroso de `atrest.js`.
-          hasPassword: (() => { try { return !!hasPassword() } catch (_) { return true } })()
+          hasPassword: (() => { try { return !!hasPassword() } catch (_) { return true } })(),
+          // SI ESTÁ CERRADA, Y SI SE PUEDE ABRIR DESDE AQUÍ. La consola no tenía forma de
+          // saberlo: se enteraba solo al chocar con un `vault-locked` intentando algo. Y
+          // `remoteUnlock` distingue las dos razones por las que el formulario no aparece —
+          // «no está cerrada» y «no hay contraseña de admin puesta»— que son cosas
+          // distintas y llevan a acciones distintas.
+          locked: (() => { try { return !!isLocked() } catch (_) { return true } })(),
+          remoteUnlock: (() => { try { return !!hasSecondary() } catch (_) { return false } })()
         }))
       }
     },
@@ -1945,6 +2074,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     desk,
     deviceIdOf,
     audit,
+    // Abrir a distancia. Va inyectado porque `admin.js` es puro y esto necesita cripto y
+    // disco; `null` si este perfil no lo soporta, y entonces la operación contesta que no.
+    unlockDesk,
     // El MISMO candado que frena firmar y editar el perfil: revocar reescribe el acta y
     // configurar toca los secretos, y ninguna de las dos se hace con la bóveda cerrada.
     isLocked,
@@ -2013,12 +2145,32 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return reply(from, { type: MSG.ERROR, error: 'renounce: that member no longer holds any of those capabilities' })
     }
     try {
-      const r = await identity.absorbRenounce(record)
+      // A LA SUBACTA PRIMERO, y aquí está el arreglo: desde este momento surte efecto,
+      // esté la bóveda abierta o cerrada. Antes se intentaba sellar directamente, sellar es
+      // de la maestra, y con el perfil cerrado la renuncia se perdía con un error — en el
+      // único momento en que de verdad hace falta.
+      const guardada = await subacta.add(record)
+      if (!guardada.ok && guardada.reason === 'no-aceptable') {
+        audit('rejected', { what: 'renounce', reason: 'no-aceptable' })
+        return reply(from, { type: MSG.ERROR, error: 'renounce: the entry is not one this vault accepts' })
+      }
       const device = await deviceIdOf(record.member).catch(() => null)
       audit('renounce', { device, caps: record.caps })
-      log(`[vault] ${device} renounced: ${(record.caps || []).join(', ')}`)
+      log(`[vault] ${device} renounced: ${(record.caps || []).join(', ')} — in effect now`)
+
+      // Y SE SELLA SI SE PUEDE. Con la bóveda abierta entra en el acta y lo respeta toda la
+      // cuenta; cerrada se queda pendiente y lo absorbe el `unlock`. Las dos ramas son
+      // correctas, así que el fallo al sellar NO es un error para quien renunció.
+      let seq = null
+      try {
+        const r = await identity.absorbRenounce(record)
+        subacta.clear([record])
+        seq = r?.seq ?? null
+      } catch (e) {
+        log(`[vault] the renounce stays pending until the vault is opened (${e.message})`)
+      }
       await notifyMembers('renounce', { deviceId: device, caps: record.caps })
-      reply(from, { type: MSG.RENOUNCE_RESULT, ok: true, seq: r?.seq ?? null })
+      reply(from, { type: MSG.RENOUNCE_RESULT, ok: true, seq, pending: seq === null })
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: 'renounce: ' + e.message })
     }
@@ -2031,7 +2183,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const r = await admin.handle(p.data, { signature: p.signature, cert: p.cert })
     // El `code` viaja aparte del texto: el texto está en inglés y puede cambiar, el código
     // es lo que empareja quien llama (`vault-locked` ≠ «no autorizado»).
-    if (!r.ok) return reply(from, { type: MSG.ERROR, error: r.error, ...(r.code ? { code: r.code } : {}) })
+    // EL FRENO VIAJA CON EL RECHAZO. `tries` y `waitSec` solo los trae abrir a distancia, y
+    // sin ellos el admin reintenta contra una puerta que ya no responde y no sabe por qué —
+    // el mismo silencio que se arregló en el resto del ecosistema.
+    if (!r.ok) {
+      return reply(from, {
+        type: MSG.ERROR,
+        error: r.error,
+        ...(r.code ? { code: r.code } : {}),
+        ...(r.tries != null ? { tries: r.tries } : {}),
+        ...(r.waitSec != null ? { waitSec: r.waitSec } : {})
+      })
+    }
     reply(from, { type: MSG.ADMIN_RESULT, op: p.data.op, result: r.result })
   }
 
@@ -3019,6 +3182,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // aquí donde puede estrenar su llave de comunicación (ver `ensureCommKeyInActa`).
       // Si falla, no se arrastra: abrir el perfil no puede depender de esto.
       if (r?.locked === false) { try { await ensureCommKeyInActa() } catch (_) {} }
+      // Y ABSORBER LO PENDIENTE. La subacta ya lo estaba honrando con el perfil cerrado —de
+      // eso vive—, pero mientras siga ahí solo lo sabe esta máquina: al sellarlo, entra en
+      // el acta y lo respeta toda la cuenta. Si falla no se arrastra: abrir el perfil no
+      // puede depender de esto, y lo pendiente sigue surtiendo efecto igual.
+      if (r?.locked === false) { try { await absorberSubacta('unlock') } catch (_) {} }
       return { locked: r?.locked !== false }
     },
     // Forzar un empujón: lo usa `replica push` de la CLI y el smoke, para no depender
@@ -3117,7 +3285,14 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return {
         ...r,
         vault: MI_VERSION,
-        members: (r?.members || []).map((m) => ({ ...m, running: versionDe(m.pub) }))
+        // Y LO QUE RENUNCIÓ Y NO SE HA SELLADO. Ya surte efecto —de eso vive la subacta—
+        // pero si no se ve, el dueño mira la lista, lee los permisos del acta y cree que
+        // ese aparato los tiene. Un freno que no se explica es otro silencio.
+        members: (r?.members || []).map((m) => ({
+          ...m,
+          running: versionDe(m.pub),
+          renounced: subacta.forMember(m.pub).flatMap((e) => e.caps || [])
+        }))
       }
     },
     // Los namespaces que quedaron a deber una rotación (se fue un miembro y no se pudo