@dotrino/vaultd 0.98.0 → 0.105.2

package/lib/src/admin.js

@@ -56,7 +56,12 @@ export const ADMIN_OPS = Object.freeze([
   // aparato que administra no tiene sobres de lo privado (solo el servicio dueño y la
   // recuperación). Eso lo hace la bóveda en su máquina (`secret show/history/revert`).
   // No lo cablees.
-  'vars', 'var.set', 'var.setMany'
+  // `var.recipients` es solo LEER, y hace falta para poder escribir: la consola sella el
+  // valor ella misma (§8.1) y para eso necesita saber a quién envolverle la llave. Estaba
+  // 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'
 ])
 
 /**
@@ -85,7 +90,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', 'var.set', 'var.setMany'])
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['audit', 'vars', 'var.set', 'var.setMany', 'var.recipients'])
 
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
@@ -195,7 +200,7 @@ export function createAdminDesk ({
 
       // VARIABLES DE ENTORNO. El módulo solo enruta y audita: qué valor puede salir y con
       // qué se cifra lo decide la bóveda (`vars`), que es la que tiene la clave y el disco.
-      if (data.op === 'vars' || data.op === 'var.set' || data.op === 'var.setMany') {
+      if (data.op === 'vars' || data.op === 'var.set' || data.op === 'var.setMany' || data.op === 'var.recipients') {
         if (!vars) return { ok: false, error: 'admin: this vault does not serve environment variables' }
         // Un destino y solo uno: o un scope, o un aparato. Sin esto, mandar los dos dejaría
         // que quien llama adivine dónde acabó su variable.
@@ -212,6 +217,27 @@ export function createAdminDesk ({
         }
         if (toScope === toDevice) return { ok: false, error: 'admin: var.set needs exactly one target (ns or pub)' }
 
+        // A QUIÉN HAY QUE ENVOLVERLE. Se pide ANTES de sellar, porque sellar lo hace la
+        // consola: envolver solo necesita públicas, así que puede hacerlo un navegador sin
+        // que ninguna privada ande suelta (§8.1). La lista sale del ACTA y la sabe la
+        // bóveda, no la consola — así conceder un permiso a un aparato nuevo basta, sin que
+        // nadie tenga que acordarse de actualizar una lista en otro sitio.
+        //
+        // Depende de la VISIBILIDAD: una pública se envuelve además para quien administra,
+        // así que quien pregunta dice cuál va a escribir.
+        if (data.op === 'var.recipients') {
+          if (typeof vars.recipients !== 'function') {
+            return { ok: false, error: 'admin: this vault cannot say who to seal for (update it)' }
+          }
+          const result = await vars.recipients({
+            ns: toScope ? data.ns : null,
+            pub: toDevice ? data.pub : null,
+            public: data.public === true
+          })
+          audit('admin.var.recipients', { by, ns: toScope ? data.ns : null })
+          return { ok: true, result }
+        }
+
         // VARIAS DE UNA VEZ. Mismo permiso y misma frontera que una sola: lo que cambia es
         // que la bóveda las guarda juntas y manda UN aviso de cambio en vez de uno por
         // variable — o sea, el servicio se reinicia una vez, con la configuración entera,

package/lib/src/index.js

@@ -84,7 +84,10 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
   const client = injectedClient || await (async () => {
     const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
     const c = new WebSocketProxyClient({
-      url: proxy, enableWebRTC: false, autoReconnect: true,
+  // WEBRTC SOLO DONDE EXISTE (ver `lib/src/service.js`): en Node no hay
+  // `RTCPeerConnection` y encenderlo reventaría al negociar; en un navegador es nativo y es
+  // el camino directo que hay que preferir. Se mira, en vez de apagarlo para siempre.
+      url: proxy, enableWebRTC: typeof globalThis.RTCPeerConnection === 'function', autoReconnect: true,
       maxReconnectAttempts: 100000, reconnectDelay: 4000
     })
     await c.connect()

package/lib/src/localdesk.js

@@ -0,0 +1,96 @@
+/**
+ * localdesk.js — HABLARLE A LA BÓVEDA SIN SALIR DE LA MÁQUINA.
+ *
+ * Un servicio en el mismo equipo que la bóveda daba la vuelta por `proxy.dotrino.com`:
+ * salía a internet, volvía, y si el proxio tenía un mal momento el arranque se retrasaba
+ * cinco segundos por nada. Absurdo cuando los dos procesos comparten disco (dueño,
+ * 2026-09-03: «estando en la misma máquina debería ser inmediato»).
+ *
+ * Es EL MISMO PROTOCOLO. Lo que viaja es idéntico —`{type, data, signature, cert}`— y la
+ * bóveda lo comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket
+ * no autoriza nada**: es la misma puerta por un camino más corto, no una puerta de atrás.
+ *
+ * Se hace pasar por un cliente del proxio (`send`, `sendByPubkey`, `on('message')`,
+ * `close`) para que quien lo use no tenga que saber por dónde va. `sendByPubkey` ignora a
+ * quién se dirige, y es correcto: al otro lado del socket solo hay una bóveda, la de esta
+ * máquina — si hubiera que elegir destinatario, este no sería el camino.
+ */
+import fs from 'node:fs'
+import net from 'node:net'
+import path from 'node:path'
+import os from 'node:os'
+
+/**
+ * DÓNDE ESTÁ EL SOCKET, y por qué se nombra por la LLAVE de la bóveda.
+ *
+ * Una máquina puede tener varias bóvedas (varios perfiles), y un servicio no sabe nada de
+ * perfiles: lo único que conoce de la suya es su llave maestra, que lleva pineada desde
+ * que se enroló. Así que el nombre sale de ahí y los dos lados lo calculan igual, sin
+ * mirar ningún índice ni depender de cómo estén repartidos los datos en el disco.
+ *
+ * Y va en el directorio de EJECUCIÓN del usuario, no entre los datos: un socket es algo
+ * vivo, no algo guardado. Se lo lleva el reinicio, que es lo correcto.
+ */
+export function socketDir () {
+  const base = process.env.XDG_RUNTIME_DIR || os.tmpdir()
+  return path.join(base, 'dotrino-vault')
+}
+
+export function localSocketPath (masterId) {
+  if (process.env.DOTRINO_VAULT_SOCKET) return process.env.DOTRINO_VAULT_SOCKET
+  return path.join(socketDir(), String(masterId) + '.sock')
+}
+
+/** ¿Hay una bóveda escuchando aquí mismo? Mirar el archivo es barato y no conecta nada. */
+export const hasLocalVault = (masterId) => {
+  try { return fs.statSync(localSocketPath(masterId)).isSocket() } catch (_) { return false }
+}
+
+/**
+ * Se conecta al mostrador local y devuelve algo con la forma de un cliente del proxio.
+ * Si no hay socket, o no acepta, LANZA — no se queda callado: quien llama decide si sale
+ * por el proxio, y esa decisión tiene que ser explícita y no un silencio.
+ */
+export async function connectLocal ({ masterId, timeoutMs = 3000 } = {}) {
+  const socketPath = localSocketPath(masterId)
+  const sock = await new Promise((resolve, reject) => {
+    const s = net.createConnection(socketPath)
+    const t = setTimeout(() => { s.destroy(); reject(new Error('the local vault desk did not answer')) }, timeoutMs)
+    s.once('connect', () => { clearTimeout(t); resolve(s) })
+    s.once('error', (e) => { clearTimeout(t); reject(new Error('no local vault desk at ' + socketPath + ': ' + e.message)) })
+  })
+
+  const oyentes = new Set()
+  let buf = ''
+  sock.setEncoding('utf8')
+  sock.on('data', (chunk) => {
+    buf += chunk
+    let i
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const linea = buf.slice(0, i); buf = buf.slice(i + 1)
+      if (!linea.trim()) continue
+      let p = null
+      try { p = JSON.parse(linea) } catch (_) { continue }
+      // `from` es el mismo para todo: al otro lado solo hay una bóveda.
+      for (const fn of oyentes) { try { fn('local', p) } catch (_) {} }
+    }
+  })
+
+  const enviar = (obj) => { sock.write(JSON.stringify(obj) + '\n') }
+  return {
+    local: true,
+    token: 'local',
+    send: (_to, obj) => enviar(obj),
+    sendByPubkey: (_pub, obj) => enviar(obj),
+    // El mostrador local no pide identificarse: la puerta la abre el certificado que va
+    // dentro de cada mensaje, igual que por el proxio. Identificarse ahí sirve para ser
+    // DIRECCIONABLE, y aquí no hay a quién direccionar.
+    identify: async () => ({ ok: true }),
+    on: (ev, fn) => {
+      if (ev !== 'message') return () => {}
+      oyentes.add(fn)
+      return () => oyentes.delete(fn)
+    },
+    close: () => { try { sock.destroy() } catch (_) {} }
+  }
+}

package/lib/src/service.js

@@ -30,6 +30,7 @@ import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
 import { atRestFor } from './atrest.js'
+import { connectLocal, hasLocalVault } from './localdesk.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
@@ -126,10 +127,33 @@ async function resolveAppointment (client, code) {
   return r.instance
 }
 
-async function freshClient (proxyUrl, connectTimeoutMs = 20000) {
+/**
+ * EL MÁS CORTO PRIMERO: si la bóveda está en ESTA máquina, se le habla por su socket y no
+ * se sale a internet (dueño, 2026-09-03: «estando en la misma máquina debería ser
+ * inmediato»). Es el mismo protocolo y las mismas comprobaciones; lo único que cambia es
+ * por dónde van los bytes.
+ *
+ * No es un repliegue que tape nada: el socket o está o no está, y no estar es el caso
+ * normal —la bóveda suele vivir en otra máquina—. Lo que sí sería un repliegue es callar
+ * un fallo del socket y salir por el proxio como si nada, así que se dice.
+ */
+async function freshClient (proxyUrl, connectTimeoutMs = 20000, master = null) {
   installNodeGlobals()
+  // El id sale de la LLAVE de la bóveda, que es lo único que quien llama sabe seguro de
+  // ella. Sin llave no se busca socket: no habría forma de saber cuál es el suyo.
+  const masterId = master ? (await pubkeyId(master)).slice(0, 16) : null
+  if (masterId && hasLocalVault(masterId)) {
+    try { return await connectLocal({ masterId }) } catch (e) {
+      console.error('[vault] the local desk is there but did not answer (%s): going out through the proxy', e.message)
+    }
+  }
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: false, autoReconnect: false })
+  // WEBRTC SOLO DONDE EXISTE. En Node no hay `RTCPeerConnection`, así que encenderlo
+  // reventaría al negociar; en un navegador es nativo y es el camino directo que hay que
+  // preferir. Se mira si está, en vez de apagarlo a mano para siempre: el día que este
+  // código corra en un navegador —o que Node lo traiga— se enciende solo.
+  const hayWebRTC = typeof globalThis.RTCPeerConnection === 'function'
+  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: hayWebRTC, autoReconnect: false })
   // connect() del cliente solo se resuelve con 'connected' y solo rechaza en el
   // evento 'error' de transporte: si el socket cierra LIMPIO antes de 'connected'
   // (p.ej. el proxy banea la IP y envía close 1008), la promesa quedaría colgada
@@ -251,6 +275,63 @@ function writeServiceIdentity (dir, obj) {
  *   puede convertirse en leer ni por descuido ni por un cambio futuro. Es el mismo cerrojo
  *   que tiene la llave de comunicación.
  */
+/**
+ * QR CORTO: se le pregunta a la bóveda QUIÉN ES, punto a punto, presentando el `sn`.
+ *
+ * Sale de dentro de `enrollWithVault` para poder preguntarlo ANTES de enrolar: quien
+ * enrola necesita el nombre de la cuenta para saber dónde guardar (la etiqueta de bóveda
+ * es una carpeta con ese nombre), y pedírselo al usuario cuando la bóveda ya lo sabe es
+ * fricción sin nada a cambio.
+ *
+ * Devuelve el mismo `qr` con `iss`, `proxy` y `acct` puestos. Con un QR largo no pregunta
+ * nada: ya los trae.
+ */
+export async function sayHello (client, qr) {
+  if (qr.iss) return qr
+  const target = await resolveAppointment(client, qr.conn)
+  const hello = await new Promise((resolve, reject) => {
+    const off = client.on('message', (_f, p) => {
+      if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
+      else if (p?.type === MSG.ERROR) { finish(); reject(new Error(p.error)) }
+    })
+    const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
+    const finish = () => { off(); clearTimeout(t) }
+    try { client.send(target, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { finish(); reject(e) }
+  })
+  return { ...qr, iss: hello.iss, proxy: hello.proxy || qr.proxy, ...(hello.acct ? { acct: hello.acct } : {}) }
+}
+
+/**
+ * El hello de esa invitación, sin enrolar nada: devuelve el `qr` ENRIQUECIDO con
+ * `iss`, `proxy` y `acct`.
+ *
+ * Devuelve el qr y no solo el nombre PORQUE LA CITA SE QUEMA AL CANJEARLA. Quien
+ * pregunta el nombre de la cuenta y después enrola estaría canjeando dos veces la
+ * misma cita, y el segundo canje falla con «código no válido o ya usado» — un error
+ * que señala a la invitación cuando el problema es haberla gastado uno mismo.
+ * Con el qr enriquecido, `sayHello` corta por su `if (qr.iss) return qr` y el
+ * enrolamiento no vuelve a salir a preguntar.
+ */
+export async function vaultHello (qr) {
+  if (typeof qr === 'string') qr = parseInvite(qr)
+  if (!qr?.sn) throw new Error('that does not look like a vault invitation')
+  if (qr.iss) return qr
+  const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
+  try { return await sayHello(client, qr) } finally { try { client.close() } catch (_) {} }
+}
+
+/**
+ * Cómo se llama la cuenta de esa invitación, sin enrolar nada.
+ *
+ * OJO: gasta la cita. Si además vas a enrolar, usá `vaultHello` y pasale al enroll el
+ * qr que devuelve; si no, el enrolamiento se encuentra la cita quemada.
+ */
+export async function vaultAccountName (qr) {
+  if (typeof qr === 'string') qr = parseInvite(qr)
+  if (qr?.acct) return qr.acct
+  return (await vaultHello(qr)).acct || ''
+}
+
 export async function enrollWithVault ({ qr, label = 'agent', expectedScope = null, onCode, approveTimeoutMs = 180000, withEncKey = true } = {}) {
   // `parseInvite` y NO `JSON.parse`: el vault no imprime JSON desde hace rato.
   // `dotrino-vault pair` emite la URL del QR y el código compacto (`c…`/`t…`, ver
@@ -264,20 +345,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
   rejectAdoption(qr.m)
 
   const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
-  // QR CORTO: se le pregunta a la bóveda quién es, punto a punto, presentando el `sn`.
-  if (!qr.iss) {
-    const target = await resolveAppointment(client, qr.conn)
-    const hello = await new Promise((resolve, reject) => {
-      const off = client.on('message', (_f, p) => {
-        if (p?.type === MSG.HELLO_OK) { finish(); verifyHello(p, qr.sn).then(resolve, reject) }
-        else if (p?.type === MSG.ERROR) { finish(); reject(new Error(p.error)) }
-      })
-      const t = setTimeout(() => { finish(); reject(new Error('the vault did not answer: that code may have expired')) }, 15000)
-      const finish = () => { off(); clearTimeout(t) }
-      try { client.send(target, { type: MSG.HELLO, sn: qr.sn }) } catch (e) { finish(); reject(e) }
-    })
-    qr = { ...qr, iss: hello.iss, proxy: hello.proxy || qr.proxy }
-  }
+  qr = await sayHello(client, qr)
   try {
     const device = await makeDeviceKey({ label })
     // La llave de CIFRADO: es a la que la bóveda sella cada variable. Sin ella el
@@ -413,7 +481,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
   cert = cert || saved?.cert
   if (!proxyUrl || !masterPubkey || !device || !cert) throw new Error('service not enrolled')
 
-  const client = await freshClient(proxyUrl)
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
   try {
     await identifyAsService(client, device)
     const data = { op: 'enckey', ns, encPub, publickey: device.publickey, ts: Date.now() }
@@ -449,7 +517,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     throw new Error('service not enrolled: run enrollService() first (service-identity.json missing)')
   }
 
-  const client = await freshClient(proxyUrl)
+  const client = await freshClient(proxyUrl, 20000, masterPubkey)
   try {
     await identifyAsService(client, device)
 
@@ -1062,6 +1130,15 @@ export async function watchSecretsChanges ({
   const connect = async () => {
     if (stopped) return
     try {
+      // POR EL PROXIO, A PROPÓSITO, aunque la bóveda esté en esta misma máquina.
+      //
+      // El mostrador local es pregunta y respuesta. Los avisos que la bóveda manda POR SU
+      // CUENTA —«tu configuración cambió», una revocación— salen por el proxio, así que un
+      // oyente conectado solo en local no se enteraría de nada y se quedaría corriendo con
+      // la configuración vieja para siempre. Lo cazaron los E2E de avisos.
+      //
+      // El atajo local es para el ARRANQUE, que es donde se nota la latencia: pedir las
+      // claves una vez. Escuchar es otra cosa y necesita que la bóveda pueda alcanzarte.
       client = await freshClient(saved.proxy)
       await identifyAsService(client, saved.device)
       client.on('message', (_from, p) => { handleMessage(p).catch(() => {}) })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.98.0",
+  "version": "0.105.2",
   "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": {
@@ -14,7 +14,8 @@
     "pair": "node bin/dotrino-vaultd.js --pair",
     "tui": "node bin/dotrino-vault-tui.js",
     "test": "node --test test/*.test.mjs",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "release:env": "node packaging/release-env.mjs"
   },
   "engines": {
     "node": ">=20"
@@ -22,7 +23,7 @@
   "dependencies": {
     "@dotrino/identity": "0.79.0",
     "@dotrino/passmanager": "^0.10.1",
-    "@dotrino/proxy-client": "^0.13.1",
+    "@dotrino/proxy-client": "0.15.0",
     "ws": "^8.18.0"
   },
   "license": "MIT",
@@ -47,5 +48,8 @@
     "@dotrino/remote-agent": "0.6.1",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
+  },
+  "optionalDependencies": {
+    "@dotrino/webrtc": "0.1.0"
   }
 }

package/src/approvals.js

@@ -21,10 +21,15 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
 
   return {
     /** Apunta un pedido. Uno por cajón y aparato: pedir otra vez reemplaza al anterior. */
-    request ({ ns, device, deviceId, label = '', ek }) {
+    /**
+     * `from` es POR DÓNDE ENTRÓ la pregunta. La respuesta llega más tarde —cuando alguien
+     * apruebe— y tiene que volver por el mismo sitio: desde que la bóveda atiende también
+     * por un socket local, mandarla siempre por el proxio la dejaba en el vacío.
+     */
+    request ({ ns, device, deviceId, label = '', ek, from = null }) {
       for (const [id, p] of pending) if (p.ns === ns && p.device === device) pending.delete(id)
       const ts = now()
-      const p = { id: rnd(), ns, device, deviceId, label, ek, ts, exp: ts + pendingTtlMs }
+      const p = { id: rnd(), ns, device, deviceId, label, ek, ts, exp: ts + pendingTtlMs, from }
       pending.set(p.id, p)
       return publicOf(p)
     },

package/src/client.js

@@ -29,7 +29,10 @@ import { MSG } from './protocol.js'
 async function freshClient ({ proxyUrl, dir = '.dotrino-vault-device' }) {
   installNodeGlobals(dir)
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
-  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: false, autoReconnect: false })
+  // WEBRTC SOLO DONDE EXISTE (ver `lib/src/service.js`): en Node no hay
+  // `RTCPeerConnection` y encenderlo reventaría al negociar; en un navegador es nativo y es
+  // el camino directo que hay que preferir. Se mira, en vez de apagarlo para siempre.
+  const client = new WebSocketProxyClient({ url: proxyUrl, enableWebRTC: typeof globalThis.RTCPeerConnection === 'function', autoReconnect: false })
   await client.connect()
   return client
 }

package/src/ctl.js

@@ -208,6 +208,17 @@ async function cmdPair (args = []) {
   // 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
   // había que renombrarlos después —cuando ya no sabías cuál era cuál—.
+  // UNA BANDERA QUE NO EXISTE SE DICE, no se ignora. Escribir `--label` en vez de `--name`
+  // emparejaba igual y en silencio, y el aparato entraba llamándose «cli»; el error se
+  // veía media hora después mirando el acta, si es que se miraba. Una opción que tecleas
+  // y no hace nada es un fallo mudo, que es justo lo que aquí no se acepta.
+  const CONOCIDAS = new Set(['--admin', '--adopt', '--kms', '--name', '--new-account', '--quiet', '--scope', '--service', '--save', '--profile'])
+  const rara = args.find((a) => a.startsWith('--') && !CONOCIDAS.has(a))
+  if (rara) {
+    console.error('no existe la opción %s', rara)
+    console.error('las de `pair` son: %s', [...CONOCIDAS].join(' '))
+    process.exit(2)
+  }
   const nIdx = args.indexOf('--name')
   let label = null
   if (nIdx >= 0) {
@@ -552,7 +563,10 @@ async function cmdMembers () {
     // Resaltado como los otros cuatro: dice si esa máquina se lleva tus claves privadas
     // sola o si te lo pregunta. Sin traducción salía el identificador en crudo
     // (`unattended`) en una lista que lee un humano.
-    unattended: `${B}recibe claves sin aprobación${Z}`
+    unattended: `${B}recibe claves sin aprobación${Z}`,
+    // Y el que reparte cuando esta bóveda no está. Se resalta como los demás que cambian
+    // lo que ese aparato puede hacerle a la cuenta.
+    replica: `${B}entrega tus claves con la bóveda apagada${Z}`
   }
   // El nombre del perfil es una pubkey JWK. Recortarla no la hace legible: la deja
   // pareciendo un error (`{"key_ops":["verify"],"e…`). Se muestra su huella corta, la
@@ -582,7 +596,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 | +desatendido')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +desatendido | +replica')
   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.')
@@ -648,6 +662,9 @@ async function cmdCaps (args = []) {
     // podrá admitir aparatos y cambiar permisos si esta se pierde. No es un traspaso:
     // quien manda sigue mandando. Como `administra`, no se empareja: se concede aquí.
     sella: 'sealer', sealer: 'sealer',
+    // `replica`: reparte los sobres que esta bóveda ya firmó, cuando ella no está. No
+    // tiene maestra y no puede abrir nada. A diferencia de `sella`, SÍ se empareja.
+    replica: 'replica', replicador: 'replica',
     // `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',

package/src/daemon.js

@@ -567,6 +567,10 @@ 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) }
+          // Renombrar NO pide la frase: solo hay que volver a firmar el sobre —el nombre va
+          // dentro de lo firmado— y eso lo hace la llave de sellado con la bóveda cerrada.
+          else if (sec.op === 'rename') { await vault.renameSecret(sec.ns, sec.key, sec.to); console.log('[vault] secret renamed: %s/%s → %s', sec.ns, sec.key, sec.to) }
+          else if (sec.op === 'dev-rename') { await vault.renameDeviceSecret(sec.pub, sec.key, sec.to); console.log('[vault] device secret renamed: %s → %s', sec.key, sec.to) }
           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/replica.js

@@ -39,6 +39,37 @@ export const replicaDir = () =>
 const LINK = 'link.json'
 const STATE = 'state.json'
 
+/**
+ * MEZCLAR DOS VERSIONES DEL MISMO PAQUETE, DATO A DATO.
+ *
+ * Antes se reemplazaba el paquete entero, y eso pierde datos en un caso concreto: una
+ * bóveda restaurada de un respaldo empuja un paquete donde un dato está más atrasado que
+ * el que ya tenemos. El `seq` del acta no lo caza —el acta puede ir por delante mientras
+ * un dato va por detrás—, así que la comparación tiene que ser POR DATO.
+ *
+ * Gana la GENERACIÓN más alta, que es la que sube en cada escritura. Un empate se rompe
+ * igual en todas partes —gana el `ct` menor— y no es justicia, es determinismo: dos
+ * replicadores que reciban lo mismo en distinto orden acaban idénticos.
+ *
+ * Las envolturas se SUMAN: son de aparatos distintos y ninguna estorba a otra.
+ */
+export function mergeBundle (viejo, nuevo) {
+  if (!viejo) return nuevo
+  if (!nuevo) return viejo
+  const entries = { ...(viejo.entries || {}) }
+  for (const [k, e] of Object.entries(nuevo.entries || {})) {
+    const a = entries[k]
+    if (!a) { entries[k] = e; continue }
+    const ga = a.gen || 0
+    const gb = e.gen || 0
+    if (gb > ga) entries[k] = e
+    else if (gb === ga && String(e.e?.ct ?? e.pubv ?? '') < String(a.e?.ct ?? a.pubv ?? '')) entries[k] = e
+  }
+  const porGen = new Map()
+  for (const w of [...(viejo.wraps || []), ...(nuevo.wraps || [])]) porGen.set(w.gen, w)
+  return { ...viejo, ...nuevo, entries, wraps: [...porGen.values()].sort((x, y) => x.gen - y.gen) }
+}
+
 /** La clave de un sobre: es POR (cajón, aparato), porque va tallado a quien lo pide. */
 export const bundleKey = (ns, devicePub) => `${ns} ${devicePub}`
 
@@ -67,7 +98,9 @@ export function openReplicaStore (dir) {
      */
     apply ({ seq, acta, bundles }) {
       if (typeof seq !== 'number' || seq < state.seq) return false
-      state = { seq, acta: acta || state.acta, bundles: { ...state.bundles, ...(bundles || {}) } }
+      const mezclados = { ...state.bundles }
+      for (const [k, nuevo] of Object.entries(bundles || {})) mezclados[k] = mergeBundle(mezclados[k], nuevo)
+      state = { seq, acta: acta || state.acta, bundles: mezclados }
       escribir(STATE, state)
       return true
     }