@dotrino/vaultd 0.97.0 → 0.105.1

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/enroll.js

@@ -52,7 +52,18 @@ export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
 /** Los scopes del cert se corresponden 1:1 con las capacidades del acta (§D7). */
-const SCOPE_TO_CAP = { 'vault:sign': 'sign', 'vault:store': 'store', 'vault:read': 'read', 'vault:admin': 'admin', 'vault:passwords': 'passwords' }
+const SCOPE_TO_CAP = {
+  'vault:sign': 'sign',
+  'vault:store': 'store',
+  'vault:read': 'read',
+  'vault:admin': 'admin',
+  'vault:passwords': 'passwords',
+  // `replica` SÍ se empareja, al revés que `sealer` y `admin`. La razón es la misma que
+  // hace estrecho al permiso: un replicador reparte sobres que no puede abrir y no cambia
+  // nada. Y se despliega sin teclado —un contenedor, una máquina ajena—, que es justo
+  // donde obligar a un segundo paso a mano es el paso que nadie da.
+  'vault:replica': 'replica'
+}
 export const scopeToCaps = (scope) =>
   (Array.isArray(scope) ? scope : [scope]).map((s) => SCOPE_TO_CAP[s]).filter(Boolean)
 

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

@@ -25,11 +25,12 @@ import {
   makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
   verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
-import { verifyActa, sealKeyAt, sealersOf } from '@dotrino/identity/acta'
+import { verifyActa, sealKeyAt, sealersOf, memberCan } from '@dotrino/identity/acta'
 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
@@ -241,7 +265,54 @@ function writeServiceIdentity (dir, obj) {
  * @param {number} [opts.approveTimeoutMs]
  * @returns {Promise<{device, enc:{publickey:string, privateJwk:object}, cert, iss:string, proxy:string}>}
  */
-export async function enrollWithVault ({ qr, label = 'agent', expectedScope = null, onCode, approveTimeoutMs = 180000 } = {}) {
+/**
+ * @param {boolean} [opts.withEncKey] Estrenar llave de CIFRADO y registrarla en el acta.
+ *   Por defecto sí: sin ella el aparato entra pero no le llega ningún secreto.
+ *
+ *   Un REPLICADOR entra con `false`, y no es una optimización: es su garantía. Regla del
+ *   dueño (2026-09-02), *«recibirá todos los sobres que se generen, ningún sobre firmado
+ *   para él»*. Sin `encPub` en el acta no hay a dónde envolverle nada, así que repartir no
+ *   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 } : {}) }
+}
+
+/**
+ * Cómo se llama la cuenta de esa invitación, sin enrolar nada. Una conexión y una pregunta.
+ */
+export async function vaultAccountName (qr) {
+  if (typeof qr === 'string') qr = parseInvite(qr)
+  if (!qr?.sn) throw new Error('that does not look like a vault invitation')
+  if (qr.acct) return qr.acct
+  const client = await freshClient(qr.proxy || 'wss://proxy.dotrino.com')
+  try { return (await sayHello(client, qr)).acct || '' } finally { try { client.close() } catch (_) {} }
+}
+
+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
   // invite.js); `parseInvite` acepta todas las formas, incluida la vieja.
@@ -254,31 +325,19 @@ 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
-    // aparato entra al acta pero no le llega ningún secreto, y no da error.
-    const enc = await makeDeviceEncKey()
+    // aparato entra al acta pero no le llega ningún secreto, y no da error. Un replicador
+    // entra así A PROPÓSITO (ver `withEncKey`): reparte sobres cerrados y no abre ninguno.
+    const enc = withEncKey ? await makeDeviceEncKey() : null
     const deviceId = (await pubkeyId(device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
     // Código de emparejamiento ALEATORIO: se muestra y NO se envía. La bóveda lo
     // aprende solo cuando un humano lo tipea → aprobar exige TENER esta máquina.
     const code = makePairingCode()
     const commit = await commitCode({ code, dpub: device.publickey, sn: qr.sn })
-    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, encPub: enc.encPublickey, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
+    const data = { op: 'enroll', intent: 'join', dpub: device.publickey, encPub: enc?.encPublickey || null, token: qr.token || qr.sn, sn: qr.sn, commit, label, ts: Date.now() }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
 
     const enrolled = new Promise((resolve, reject) => {
@@ -313,7 +372,7 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
 
-    return { device, enc: { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk }, cert: res.cert, iss: qr.iss, proxy: qr.proxy || 'wss://proxy.dotrino.com' }
+    return { device, enc: enc ? { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk } : null, cert: res.cert, iss: qr.iss, proxy: qr.proxy || 'wss://proxy.dotrino.com' }
   } finally { client.close() }
 }
 
@@ -402,7 +461,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() }
@@ -438,7 +497,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)
 
@@ -459,10 +518,23 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     saved = { ...saved, ...patch }
     if (dir) { try { writeServiceIdentity(dir, saved) } catch (_) {} }
   }
-  /** Hasta qué acta hemos visto: es lo que dispara la renovación la próxima vez. */
+  /**
+   * Hasta qué acta hemos visto. Dispara la renovación la próxima vez, y desde que hay
+   * replicadores es además el freno anti-rollback (`verifyResponder`).
+   *
+   * SOLO SUBE. Antes escribía cualquier `seq` que llegara, también uno MENOR: bastaba que
+   * alguien contestara con un acta vieja para que el pin bajara y dejara de proteger de
+   * ahí en adelante. Un pin que retrocede no es un pin — se llama `maxSeq` en el diseño
+   * justo por esto (`acta-de-perfil.md` §2.3).
+   */
   const anotarActa = (acta) => {
-    if (typeof acta?.seq !== 'number' || saved?.actaSeq === acta.seq) return
-    recordar({ actaSeq: acta.seq })
+    if (typeof acta?.seq !== 'number') return
+    if (typeof saved?.actaSeq === 'number' && acta.seq <= saved.actaSeq) return
+    // Y QUIÉNES REPARTEN. Sale del acta, que llega firmada en cada respuesta, así que no
+    // hay una lista que mantener a mano ni un `.env` que se olvide: darle `replica` a un
+    // aparato basta para que sus servicios sepan preguntarle cuando la bóveda no esté.
+    const replicas = (acta.members || []).filter((m) => memberCan(acta, m.pub, 'replica')).map((m) => m.pub)
+    recordar({ actaSeq: acta.seq, replicas })
   }
 
     // DOS MOTIVOS PARA PEDIR PAPEL NUEVO:
@@ -503,16 +575,35 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // poner por el camino. Quien decide qué se manda es la bóveda; esto solo es la petición.
     const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), ...(publicOnly ? { publicOnly: true } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
-    const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
-    client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
-    let res = await pending
+    // A QUIÉN SE LE PREGUNTA: primero a la bóveda, y si no contesta, a los REPLICADORES
+    // que el acta nombraba la última vez que la vimos (`docs/replicas.md` §8: «el servicio
+    // lleva una lista de bóvedas y las prueba en orden»).
+    //
+    // Sin esto, un replicador no servía absolutamente para nada: el mensaje se mandaba a
+    // la llave de la bóveda y, con la bóveda apagada, no llegaba a ninguna parte. Lo
+    // destapó el smoke con las dos máquinas encendidas y la bóveda muerta, que es
+    // exactamente el caso que un replicador existe para cubrir.
+    //
+    // La bóveda va PRIMERO siempre: un replicador solo puede estar igual de al día o menos.
+    const destinos = [masterPubkey, ...(saved?.replicas || []).filter((k) => k !== masterPubkey)]
+    // El plazo se reparte: no tiene sentido esperar el timeout entero a una bóveda apagada
+    // y quedarse sin tiempo para preguntarle a quien sí está.
+    const porDestino = Math.max(4000, Math.round(timeoutMs / destinos.length))
+    let res = null
+    let ultimo = null
+    for (const destino of destinos) {
+      const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, porDestino)
+      client.sendByPubkey(destino, { type: MSG.SECRETS, data, signature, cert })
+      try { res = await pending; break } catch (e) { ultimo = e }
+    }
+    if (!res) throw ultimo || new Error('nobody answered: neither the vault nor any replica')
     if (res.type === MSG.ERROR) throw new Error(res.error)
 
     // CAJÓN CON APROBACIÓN: la bóveda contesta «pendiente» (firmado) y la respuesta de
     // verdad llega cuando el aparato que aprueba firme — por esta misma conexión, que
     // sigue identificada. Se espera lo que dura el pedido; denegado o vencido es error.
     if (res.body?.op === 'secrets.pending' && res.body.ns === ns) {
-      await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey })
+      await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
       anotarActa(res.acta)
       try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
@@ -534,7 +625,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // confía en nadie — solo saca el acta con la que SÍ se comprueba. Nada de lo que hay
     // dentro se usa hasta después de verificar.
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
-    await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey })
+    await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey, knownSeq: saved?.actaSeq ?? null })
     anotarActa(payload?.acta)
 
     // DOS CAPAS DE SOBRE, y hacen cosas distintas:
@@ -578,8 +669,32 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
  * Sin el paso 1 el paso 2 no vale nada: un acta cualquiera nombraría la llave que
  * quisiera.
  */
-export async function verifyResponder ({ body, seal, acta, masterPubkey }) {
-  if (!seal?.sig || typeof seal.seq !== 'number') {
+/**
+ * ¿QUIÉN PUEDE HABERME CONTESTADO ESTO? Hay dos respuestas legítimas y una condición.
+ *
+ *   · **La bóveda.** Firma con la llave de sellado que el acta nombra para ese `seq`. Es
+ *     el camino de siempre y no cambia.
+ *   · **Un REPLICADOR** (`seal.by`). No tiene esa llave —no tiene maestra— así que firma
+ *     con la suya de aparato, y lo que la autoriza es que el acta le reconozca `replica`.
+ *     Reparte lo que la bóveda ya selló: los sobres de dentro se siguen comprobando contra
+ *     la llave de sellado (`makeSealCheck`), así que un replicador no puede inventarse
+ *     contenido, solo entregarlo.
+ *
+ * LA CONDICIÓN, y es la que cierra el agujero que `replicas.md` §6.1 llama «construir el
+ * ataque»: **un replicador solo le contesta a quien YA conoce la cuenta.** Un replicador
+ * atrasado presenta un acta donde un aparato revocado sigue siendo miembro; contra eso, a
+ * quien tiene `maxSeq` pineado lo protege el pin, pero a un aparato que llega nuevo no hay
+ * con qué compararlo. Así que sin pin no se le cree: que conteste la bóveda.
+ *
+ * El precio, dicho en voz alta: un aparato nuevo necesita la bóveda encendida una vez. El
+ * oráculo de frescura (§2.4.2 del acta) es lo que quitaría ese precio; mientras no exista,
+ * esto es el freno, y es un freno de verdad y no un aviso.
+ *
+ * @param {number|null} [knownSeq] El `seq` más alto que este agente ya vio de esta cuenta.
+ *   `null`/ausente = no conoce la cuenta, y entonces un replicador no vale.
+ */
+export async function verifyResponder ({ body, seal, acta, masterPubkey, knownSeq = null }) {
+  if (!seal?.sig) {
     throw new Error('the reply carries no sealing signature: this vault is too old to serve (update it)')
   }
   if (!acta) throw new Error('the reply carries no record: cannot tell which key was allowed to sign it')
@@ -587,6 +702,33 @@ export async function verifyResponder ({ body, seal, acta, masterPubkey }) {
     throw new Error('the record was not sealed by the master this agent knows: refusing the reply')
   }
   if (!(await verifyActa({ acta })).ok) throw new Error('the record does not verify')
+
+  // NUNCA HACIA ATRÁS. Vale para los dos caminos: un acta con `seq` menor del que ya
+  // vimos es un rollback, venga de donde venga.
+  if (typeof knownSeq === 'number' && typeof acta.seq === 'number' && acta.seq < knownSeq) {
+    throw Object.assign(
+      new Error(`the record went backwards (#${acta.seq} after #${knownSeq}): refusing the reply`),
+      { code: 'stale-record' })
+  }
+
+  if (seal.by) {
+    if (typeof knownSeq !== 'number') {
+      throw Object.assign(
+        new Error('a replica answered, and this device has never seen the account: ask the vault itself the first time'),
+        { code: 'replica-unknown-account' })
+    }
+    if (!memberCan(acta, seal.by, 'replica')) {
+      throw new Error('the reply comes from a device the record does not allow to serve as a replica')
+    }
+    if (!(await verifyDeviceSig({ publickey: seal.by, data: body, signature: seal.sig }))) {
+      throw new Error('the replica signature does not check out')
+    }
+    return
+  }
+
+  if (typeof seal.seq !== 'number') {
+    throw new Error('the reply carries no sealing signature: this vault is too old to serve (update it)')
+  }
   const pub = sealKeyAt(acta, seal.seq)
   if (!pub) throw new Error(`the record names no sealing key for #${seal.seq}`)
   if (!(await verifyDeviceSig({ publickey: pub, data: body, signature: seal.sig }))) {
@@ -968,6 +1110,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.97.0",
+  "version": "0.105.1",
   "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,9 +20,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "0.76.0",
+    "@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 +47,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
 }