@dotrino/vaultd 0.96.0 → 0.98.0

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

@@ -25,7 +25,7 @@ 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'
@@ -241,7 +241,17 @@ 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.
+ */
+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.
@@ -271,14 +281,15 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
   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 +324,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() }
 }
 
@@ -459,10 +470,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 +527,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 +577,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 +621,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 +654,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 }))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.96.0",
+  "version": "0.98.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "0.76.0",
+    "@dotrino/identity": "0.79.0",
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"

package/src/ctl.js

@@ -254,6 +254,10 @@ async function cmdPair (args = []) {
       if (t === 'approve' || t === 'aprueba') { console.error('`approve` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +aprueba'); process.exit(2) }
       if (t === 'sealer' || t === 'sella') { console.error('`sella` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +sella'); process.exit(2) }
       if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
+      // Un REPLICADOR nace acotado: solo esto, ni firma ni lee ni guarda. Se empareja
+      // —al contrario que `sella`— porque se despliega en una máquina sin teclado y el
+      // permiso no concede nada que haya que pensarse dos veces: reparte sobres cerrados.
+      if (t === 'replica' || t === 'replicador') { scope.push('vault:replica'); continue }
       // El gestor de contraseñas SÍ se empareja con su permiso puesto: es lo único que
       // va a hacer ese aparato, y pedirlo en dos pasos era el paso que nadie daba.
       if (t === 'passwords') { scope.push('vault:passwords'); continue }
@@ -1606,7 +1610,7 @@ function help () {
                       El QR no lleva nada: el permiso se aplica al aprobar el código aquí
   pair --quiet          escupe SOLO la invitación (una línea) y termina: sin QR y sin
                       esperar. Para desplegar (un contenedor no mira un QR en pantalla)
-  pair --scope <lista>  los PERMISOS del cert: sign,read,store,contrasenas,secrets:<ns> (sin esto: sign,read,store;
+  pair --scope <lista>  los PERMISOS del cert: sign,read,store,contrasenas,replica,secrets:<ns> (sin esto: sign,read,store;
                       se combina con --service: --service eco --scope sign = bot que firma y lee su cajón)
   secret set <ns> <CLAVE> <valor>   variable del scope <ns>: la comparten TODOS los
                                     aparatos del perfil que sirven ese namespace
@@ -1646,6 +1650,10 @@ function help () {
                       KMS, y solo vale ahora: el perfil se está creando)
                       Al desplegar, esto mismo va por el entorno y sin entrar a nada:
                       DOTRINO_JOIN (o DOTRINO_JOIN_FILE) + DOTRINO_JOIN_NAME
+  replica enroll <invitación>
+                      esta máquina entra como REPLICADOR: reparte los sobres que la
+                      bóveda ya firmó cuando ella no está, y no puede abrir ninguno ni
+                      cambiar nada. No tiene maestra. Arráncalo con: replica run
   pending             muestra el dispositivo pendiente + su código a comparar
   approve <código>    aprueba el dispositivo tipeando el código que MUESTRA (el vault no lo sabe)
   reject <deviceId>   rechaza un dispositivo pendiente
@@ -1697,6 +1705,82 @@ Arrancar y parar, según dónde corra:
                     (el CLI, dentro:  docker exec -it dotrino-vault dotrino-vault status)`)
 }
 
+/**
+ * `replica` — LA OTRA PIEZA, la que reparte sin decidir (`docs/replicas.md` §8.bis).
+ *
+ *   dotrino-vault replica enroll <invitación>   entra en la cuenta, UNA vez
+ *   dotrino-vault replica run                  se queda repartiendo
+ *   dotrino-vault replica status               qué acta tiene y cuántos sobres
+ *
+ * No corre dentro del daemon del vault y no es un perfil: un replicador NO TIENE MAESTRA,
+ * y meterlo en el gestor de perfiles sería fabricarle una. Vive en su propio directorio
+ * (`DOTRINO_REPLICA_DIR`, por defecto `~/.dotrino/replica`).
+ */
+async function cmdReplica (args) {
+  const { replicaDir, openReplicaStore, runReplica, REPLICA_SCOPE } = await import('./replica.js')
+  const sub = args[0]
+  const dir = process.env.DOTRINO_REPLICA_DIR || replicaDir()
+
+  if (sub === 'enroll') {
+    const invitacion = args.slice(1).filter((a) => !a.startsWith('-')).join(' ')
+    if (!invitacion) {
+      console.error('uso: dotrino-vault replica enroll "<invitación>"')
+      console.error('     la invitación sale de la bóveda:  dotrino-vault pair --scope replica --quiet')
+      process.exit(2)
+    }
+    const { enrollWithVault } = await import('../lib/src/service.js')
+    // `withEncKey: false` NO es una optimización: es la garantía. Sin llave de cifrado en
+    // el acta no hay a dónde envolverle un sobre, así que repartir no puede convertirse en
+    // leer. Regla del dueño: «recibirá todos los sobres que se generen, ningún sobre
+    // firmado para él».
+    const r = await enrollWithVault({
+      qr: invitacion,
+      label: args.includes('--label') ? args[args.indexOf('--label') + 1] : 'replicador',
+      expectedScope: REPLICA_SCOPE,
+      withEncKey: false,
+      onCode: ({ deviceId, code }) => {
+        console.log('\n  Tipea ESTE código en la bóveda para aprobarlo:')
+        console.log(`    código:  ${code}`)
+        console.log(`    máquina: ${deviceId}`)
+        console.log(`    (en la bóveda:  dotrino-vault approve ${code})\n`)
+        console.log('  Esperando…')
+      }
+    })
+    openReplicaStore(dir).setLink({ device: r.device, cert: r.cert, iss: r.iss, proxy: r.proxy })
+    console.log('\n  Listo: este replicador ya está en la cuenta.')
+    console.log('  Arráncalo con:  dotrino-vault replica run\n')
+    return
+  }
+
+  if (sub === 'status') {
+    const st = openReplicaStore(dir)
+    if (!st.link) { console.log('Sin enrolar. Empieza por:  dotrino-vault replica enroll "<invitación>"'); return }
+    console.log('Replicador · datos en %s', dir)
+    console.log('  acta   : #%s%s', st.seq || 0, st.acta ? '' : '  (todavía ninguna: la manda la bóveda)')
+    console.log('  sobres : %d', st.bundles)
+    console.log('  bóveda : %s…', String(st.link.iss).slice(0, 32))
+    return
+  }
+
+  if (sub === 'run' || sub === undefined) {
+    try {
+      await runReplica({ dir })
+    } catch (e) {
+      if (e?.code === 'replica-not-enrolled') {
+        console.error('\n  Este replicador todavía no está en ninguna cuenta.\n')
+        console.error('  En la bóveda:      dotrino-vault pair --scope replica --quiet')
+        console.error('  Y aquí, con eso:   dotrino-vault replica enroll "<invitación>"\n')
+        process.exit(2)
+      }
+      throw e
+    }
+    await new Promise(() => {})
+    return
+  }
+  console.error('uso: dotrino-vault replica [enroll <invitación>|run|status]')
+  process.exit(2)
+}
+
 export async function runCtl (argv) {
   const [cmd, ...rest] = takeProfileFlag(argv)
   switch (cmd) {
@@ -1722,6 +1806,7 @@ export async function runCtl (argv) {
     case 'activity': return cmdActivity(Number(rest.find((a) => /^\d+$/.test(a))) || 30, {
       verify: rest.includes('--verify'), exportar: rest.includes('--export')
     })
+    case 'replica': return cmdReplica(rest)
     case 'logs': return cmdLogs()
     case 'version':
     case '--version':

package/src/daemon.js

@@ -191,7 +191,19 @@ export async function runDaemon () {
       // `vault:secrets:<ns>`. Se valida aquí porque es la maestra la que firma: nada
       // que no esté en esta lista entra en un cert, y `vault:admin` / `vault:approve` nunca
       // por este camino (se conceden a mano con `caps`).
-      const ALLOWED = (x) => x === 'vault:sign' || x === 'vault:read' || x === 'vault:store' || /^vault:secrets:[a-z0-9-]{1,32}$/.test(x)
+      //
+      // LA LISTA VA EXPLÍCITA A PROPÓSITO, y es la única del ecosistema que debe estarlo:
+      // aquí no se dibuja una pantalla, se decide qué firma la maestra. Derivarla del
+      // pilar significaría que un permiso nuevo se pudiera emparejar el día que alguien lo
+      // añade, sin que nadie lo haya pensado. `vault:admin` y `vault:approve` no están, y
+      // esa ausencia ES la regla.
+      //
+      // `vault:passwords` faltaba y el CLI sí lo ofrecía: emparejar el gestor de
+      // contraseñas con su permiso se rechazaba aquí. `vault:replica` entra el 2026-09-02:
+      // un replicador reparte sobres que no puede abrir, así que se puede emparejar —al
+      // revés que sellar o administrar— y se despliega donde no hay teclado.
+      const ALLOWED = (x) => x === 'vault:sign' || x === 'vault:read' || x === 'vault:store' ||
+        x === 'vault:passwords' || x === 'vault:replica' || /^vault:secrets:[a-z0-9-]{1,32}$/.test(x)
       const asked = Array.isArray(pairReq?.scope) ? pairReq.scope.filter((x) => typeof x === 'string') : null
       if (asked && asked.some((x) => !ALLOWED(x))) {
         ipcWrite(pairFile, { v: 2, at: Date.now(), error: 'scope not allowed: ' + asked.filter((x) => !ALLOWED(x)).join(',') })
@@ -333,10 +345,13 @@ export async function runDaemon () {
           // cajón envuelto para exactamente quien dice el acta — creando lo que falta,
           // reemplazando lo que alguien metiera mal y quitando lo que sobre.
           const r = await mgr.get(id)?.resealAll?.(ak)
-          if (r?.wrapped) console.log('[vault] keyring rebuilt on unlock: %d wrap(s) in %d drawer(s)%s',
-            r.wrapped, r.drawers, r.dropped ? `, ${r.dropped} stale one(s) dropped` : '')
+          if (r?.wrapped) console.log('[vault] keyring rebuilt on unlock: %d wrap(s) in %d drawer(s)%s%s',
+            r.wrapped, r.drawers, r.dropped ? `, ${r.dropped} stale one(s) dropped` : '',
+            r.sealed ? `, ${r.sealed} value(s) left in the clear now sealed` : '')
           if (r?.dropped) note = ` · llavero al día (${r.dropped} envoltura(s) de más retirada(s))`
           else if (r?.wrapped) note = ' · llavero al día'
+          // Se SUMA, no pisa: es lo que el dueño necesita ver de esta apertura en concreto.
+          if (r?.sealed) note += ` · ${r.sealed} valor(es) que estaban sin cifrar ya están sellados`
           // ABIERTA PERO SIN LLAVERO NO ES «ABIERTA». Si un cajón no se pudo reenvolver, sus
           // aparatos no van a poder leer nada y hay que decirlo AQUÍ: contestar
           // «desbloqueado» a secas dejaba la bóveda pareciendo sana, y el fallo aparecía

package/src/replica.js

@@ -0,0 +1,199 @@
+/**
+ * replica.js — UNA BÓVEDA QUE REPARTE Y NO DECIDE.
+ *
+ * Diseño: `docs/replicas.md` §8.bis. Es la otra pieza del par, y NO sustituye al
+ * multivault: una segunda bóveda tiene maestra y sella; un replicador no tiene maestra y
+ * no sella nunca. Las dos se conservan.
+ *
+ * Qué guarda, y no hay una cuarta cosa:
+ *
+ *   · su LLAVE DE APARATO y su papel — para ser alcanzable y para firmar lo que contesta;
+ *   · el ACTA vigente — pública y firmada, la verifica quien la recibe;
+ *   · los SOBRES — que ya vienen cerrados a su destinatario.
+ *
+ * Por qué se puede poner en una máquina ajena, que es el punto entero: **no puede abrir
+ * nada de lo que reparte**. Entra al acta SIN llave de cifrado (`withEncKey: false`), así
+ * que no existe camino por el que le llegue un sobre dirigido a él — regla del dueño:
+ * «recibirá todos los sobres que se generen, ningún sobre firmado para él». Que lo
+ * comprometan cuesta disponibilidad, no confidencialidad.
+ *
+ * Y lo que NO hace, comprobado y no prometido: no sella actas, no emite certificados, no
+ * admite aparatos, no cambia permisos. Si algo de eso le llega, contesta que no.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { WebSocketProxyClient } from '@dotrino/proxy-client'
+import { signWithDevice, verifyDeviceSig, pubkeyId } from '@dotrino/identity/capabilities'
+import { verifyActa, memberCan, sealKeyAt } from '@dotrino/identity/acta'
+import { MSG } from '../lib/src/protocol.js'
+import { seal } from '../lib/src/sealed.js'
+import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './paths.js'
+
+export const REPLICA_SCOPE = 'vault:replica'
+
+export const replicaDir = () =>
+  process.env.DOTRINO_REPLICA_DIR || path.join(os.homedir(), '.dotrino', 'replica')
+
+const LINK = 'link.json'
+const STATE = 'state.json'
+
+/** La clave de un sobre: es POR (cajón, aparato), porque va tallado a quien lo pide. */
+export const bundleKey = (ns, devicePub) => `${ns} ${devicePub}`
+
+/** Lo que este replicador sabe de la cuenta: su papel, el acta y los sobres. */
+export function openReplicaStore (dir) {
+  fs.mkdirSync(dir, { recursive: true })
+  const atRest = atRestFor(dir)
+  const leer = (f, d) => readJson(path.join(dir, f), d, atRest)
+  const escribir = (f, v) => writeJson(path.join(dir, f), v, atRest)
+
+  let link = leer(LINK, null)
+  let state = leer(STATE, null) || { seq: 0, acta: null, bundles: {} }
+
+  return {
+    get link () { return link },
+    get acta () { return state.acta },
+    get seq () { return state.seq },
+    setLink (v) { link = v; escribir(LINK, v) },
+    bundleFor (ns, devicePub) { return state.bundles[bundleKey(ns, devicePub)] || null },
+    get bundles () { return Object.keys(state.bundles).length },
+    /**
+     * SOLO HACIA ADELANTE. Es el mismo freno que el pin del cliente: un empujón con un
+     * acta más vieja de la que ya tenemos es un rollback, y aceptarlo convertiría al
+     * replicador en el camino para servir un acta donde un aparato revocado sigue dentro.
+     * @returns {boolean} si se aplicó (false = venía atrasado y se descartó)
+     */
+    apply ({ seq, acta, bundles }) {
+      if (typeof seq !== 'number' || seq < state.seq) return false
+      state = { seq, acta: acta || state.acta, bundles: { ...state.bundles, ...(bundles || {}) } }
+      escribir(STATE, state)
+      return true
+    }
+  }
+}
+
+/**
+ * Arranca el replicador. No crea ninguna maestra ni ningún perfil: si no está enrolado,
+ * lo dice y se para. Estrenar una identidad aquí sería justo lo que no debe existir.
+ */
+export async function runReplica ({ dir = replicaDir(), proxyUrl, log = console.log } = {}) {
+  const store = openReplicaStore(dir)
+  const link = store.link
+  if (!link?.device?.privateJwk || !link?.cert || !link?.iss) {
+    throw Object.assign(
+      new Error('this replica is not enrolled yet: run `dotrino-vault replica enroll <invitation>` here first'),
+      { code: 'replica-not-enrolled' })
+  }
+  const url = proxyUrl || link.proxy || process.env.PROXY_URL || 'wss://proxy.dotrino.com'
+  const id = (await pubkeyId(link.device.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+
+  const firmar = (data) => signWithDevice({ privateJwk: link.device.privateJwk, data })
+  // CONTESTAR es por la CONEXIÓN (`send`) y no por la llave (`sendByPubkey`): `from` es el
+  // identificador de quien escribe en el proxio, no su pubkey. Mandar por llave a un `from`
+  // no falla — se va a la nada, y quien preguntó se queda esperando el plazo entero.
+  // Por llave solo se habla con la BÓVEDA (`link.iss`), que es a quien queremos alcanzar
+  // aunque no esté conectada ahora mismo.
+
+  const client = new WebSocketProxyClient({ url })
+  await client.connect()
+  const data = { op: 'identify', publickey: link.device.publickey, token: client.token, ts: Date.now() }
+  await client.identify({ data, signature: (await firmar(data)).signature })
+  log(`[replica] ${id} · connected to ${url}`)
+  log(`[replica] record #${store.seq}${store.acta ? '' : ' · no record yet: waiting for the vault'}`)
+
+  /**
+   * UN EMPUJÓN DE LA BÓVEDA. Va firmado con la llave de sellado que el acta nombra, así
+   * que se comprueba de dónde viene antes de guardar nada. Y se comprueba contra el acta
+   * QUE VIENE, después de verificar que la selló la maestra que este replicador conoce:
+   * fiarse de la que ya tiene impediría para siempre recibir una nueva.
+   */
+  async function onPush (from, p) {
+    const body = p?.body
+    if (!body || body.op !== 'replica.push') return
+    const acta = body.acta || store.acta
+    if (!acta) return log('[replica] a push arrived with no record and none is stored: ignored')
+    if (acta.sealedBy !== link.iss) return log('[replica] the pushed record was sealed by another master: ignored')
+    if (!(await verifyActa({ acta })).ok) return log('[replica] the pushed record does not verify: ignored')
+    const pub = sealKeyAt(acta, p.seal?.seq)
+    if (!pub || !(await verifyDeviceSig({ publickey: pub, data: body, signature: p.seal?.sig }))) {
+      return log('[replica] the push is not signed by the key the record names: ignored')
+    }
+    if (!memberCan(acta, link.device.publickey, 'replica')) {
+      return log('[replica] the record no longer lets this device serve as a replica: ignored')
+    }
+    if (!store.apply({ seq: body.seq, acta, bundles: body.bundles })) {
+      return log(`[replica] a push arrived with an older record (#${body.seq} < #${store.seq}): refused`)
+    }
+    log(`[replica] record #${store.seq} · ${Object.keys(body.bundles || {}).length} bundle(s) stored`)
+    const ack = { op: 'replica.ack', publickey: link.device.publickey, seq: store.seq, ts: Date.now() }
+    client.send(from, { type: MSG.REPLICA_ACK, body: ack, signature: (await firmar(ack)).signature })
+  }
+
+  /**
+   * UNA PETICIÓN DE CLAVES. Se contesta con lo que hay guardado, cerrado a la efímera de
+   * quien pregunta y firmado con NUESTRA llave — que es lo que el cliente acepta cuando el
+   * acta nos reconoce `replica` (`verifyResponder` de `@dotrino/vault`).
+   *
+   * Lo que NO se decide aquí, y es a propósito: si quien pide tiene derecho a ese cajón.
+   * Lo dice el sobre, no nosotros — va cerrado a su llave, así que a quien no le toque le
+   * llega algo que no puede abrir. Un replicador que decidiera quién lee sería un
+   * replicador del que hay que fiarse, y la gracia es que no haga falta.
+   */
+  async function onSecrets (from, p) {
+    const ns = p?.data?.ns
+    const ek = p?.data?.ek
+    const quien = p?.data?.publickey
+    if (typeof ns !== 'string' || !ek || !quien) return
+    if (!store.acta) return client.send(from, { type: MSG.ERROR, error: 'replica: no record yet' })
+    const b = store.bundleFor(ns, quien)
+    if (!b) {
+      log(`[replica] asked for "${ns}" and has nothing stored for that device`)
+      return client.send(from, {
+        type: MSG.ERROR,
+        error: `replica: nothing stored for "${ns}" and this device — ask the vault once while it is up`
+      })
+    }
+    const enc = await seal({ ek, payload: { sealed: b, acta: store.acta } })
+    const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
+    // `by` y no `seq`: no tenemos la llave de sellado y no debemos tenerla. Quien recibe
+    // mira el acta, ve que a esta llave le reconoce `replica`, y acepta.
+    const { signature } = await firmar(body)
+    client.send(from, { type: MSG.SECRETS_RESULT, body, seal: { by: link.device.publickey, sig: signature } })
+    log(`[replica] served "${ns}" from record #${store.seq}`)
+  }
+
+  /** Todo lo que DECIDE algo se contesta que no, y se dice por qué. */
+  const NO_DECIDE = new Set([MSG.ENROLL, MSG.ADMIN, MSG.RENEW, MSG.RENOUNCE, MSG.SIGN, MSG.ACTA_SEALED])
+
+  client.on('message', (from, p) => {
+    const t = p?.type
+    if (t === MSG.REPLICA_PUSH) return onPush(from, p).catch((e) => log('[replica] push: ' + e.message))
+    if (t === MSG.SECRETS) return onSecrets(from, p).catch((e) => log('[replica] secrets: ' + e.message))
+    if (NO_DECIDE.has(t)) {
+      log(`[replica] refused "${t}": a replica hands things out, it does not decide`)
+      return client.send(from, {
+        type: MSG.ERROR,
+        error: 'replica: this is a replica — it has no master and decides nothing'
+      })
+    }
+  })
+
+  // EL ARRASTRE AL ARRANCAR (`docs/replicas.md` §6). Se dice por dónde vamos en cuanto hay
+  // conexión: si la bóveda va por delante, contesta con un empujón. Sin esto, un
+  // replicador recién encendido se queda vacío hasta que alguien cambie algo — y el
+  // empujón del propio enrolamiento se manda cuando este proceso todavía no existe.
+  const saludo = { op: 'replica.ack', publickey: link.device.publickey, seq: store.seq, ts: Date.now() }
+  try {
+    client.sendByPubkey(link.iss, { type: MSG.REPLICA_ACK, body: saludo, signature: (await firmar(saludo)).signature })
+  } catch (e) { log('[replica] could not say hello to the vault: ' + e.message) }
+
+  log('[replica] ready · it hands out what the vault already signed, and nothing else')
+  return {
+    id,
+    publickey: link.device.publickey,
+    seq: () => store.seq,
+    stop: () => { try { client.close() } catch (_) {} }
+  }
+}

package/src/secretsStore.js

@@ -834,11 +834,44 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       if (!bag[k]) return { wrapped: 0, sinLlave: [] }
       const priv = await openRecovery(adminKey)
       let wrapped = 0
+      let sealed = 0
       const sinLlave = new Set()
+      const vars = varsOf(bag, k)
+      const paraVisibilidad = async (esPublica) => (typeof members === 'function' ? members(esPublica) : members)
+
+      // UN VALOR QUE SE QUEDÓ EN CLARO SE SELLA AQUÍ, que es el único sitio donde se puede.
+      //
+      // Una pública escrita antes del 2026-09-02 se guardó legible y SIN sobre, así que no
+      // tiene generación ni entrada en el llavero. Y el llavero es lo único que este
+      // método reenvuelve: por muchas veces que se abra la bóveda, a esa variable no se le
+      // crea una envoltura nunca. Sus aparatos la reclaman para siempre («no key yet») y la
+      // consola invita a abrir la bóveda, que es justo lo que no lo arregla. Peor: desde
+      // 2026-09-02 el agente rechaza el cajón ENTERO por ella, así que una variable de
+      // prueba deja sin leer el token que está al lado.
+      //
+      // Con la bóveda abierta el valor está delante, así que se cifra como si se acabara
+      // de escribir. No es un repliegue ni una migración a medias: es la conversión que
+      // faltaba, y ocurre en el único momento en que hay con qué hacerla.
+      for (const [key, e] of Object.entries(vars)) {
+        if (typeof e.v !== 'string' || e.e) continue
+        const cek = await sealer.newKey()
+        const gen = (topGen(bag, k)?.gen || 0) + 1
+        const r = await sealer.wrapFor(cek, await paraVisibilidad(!!e.pub))
+        r.wraps[RECOVERY] = await sealer.wrapForKey(cek, data.recovery.pub)
+        const sobre = await sealer.encrypt(cek, e.v, gen)
+        const seal = signer ? await signer({ owner, key, gen, iv: sobre.iv, ct: sobre.ct }) : null
+        // `pub` y `at` se conservan: no es un valor nuevo, es el mismo mejor guardado.
+        vars[key] = { pub: !!e.pub, owner, gen, e: sobre, seal, at: e.at || Date.now(), by: e.by || null }
+        bag[k].keyring = [...(bag[k].keyring || []), { gen, createdAt: Date.now(), wraps: r.wraps }]
+        for (const x of r.sinLlave) sinLlave.add(x)
+        sealed++
+      }
+
       // De qué variable es cada generación: es lo que dice si esa CEK es de una pública.
+      // Se calcula DESPUÉS de sellar, para que las generaciones recién creadas entren.
       const visibilidad = new Map()
-      for (const e of Object.values(varsOf(bag, k))) if (e.gen != null) visibilidad.set(e.gen, !!e.pub)
-      const paraGen = async (gen) => (typeof members === 'function' ? members(visibilidad.get(gen) === true) : members)
+      for (const e of Object.values(vars)) if (e.gen != null) visibilidad.set(e.gen, !!e.pub)
+      const paraGen = async (gen) => paraVisibilidad(visibilidad.get(gen) === true)
       for (const g of bag[k].keyring || []) {
         const w = g.wraps?.[RECOVERY]
         if (!w) continue
@@ -859,7 +892,7 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
         wrapped += Object.keys(r.wraps).length
       }
       save()
-      return { wrapped, sinLlave: [...sinLlave] }
+      return { wrapped, sealed, sinLlave: [...sinLlave] }
     },
 
     /**

package/src/tui/app.js

@@ -37,6 +37,7 @@ import { qrToString } from '../qr.js'
 import { dict, otherLang, loadLang, saveLang } from './i18n.js'
 import * as vc from '../vaultControl.js'
 import { VERSION } from '../version.js'
+import { DEVICE_CAPS } from '@dotrino/identity/acta'
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
@@ -338,7 +339,18 @@ function pairModeRows (st, t) {
  * permiso que hay que entender para un servidor: dice si esa máquina se lleva tus claves
  * privadas sola o si te lo pregunta. Verlo apagado es la mitad del mensaje.
  */
-const CAPS_ORDER = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended']
+/**
+ * EL ORDEN LO ELIGE ESTA PANTALLA; LA LISTA LA MANDA EL ACTA.
+ *
+ * Antes esto era una lista suelta escrita a mano, y por eso cada permiso nuevo se quedó
+ * invisible aquí durante semanas —`sealer`, `unattended` y `secrets`, tres veces el mismo
+ * fallo—. Ahora el orden se cura a mano, que es una decisión de diseño, pero lo que no
+ * esté nombrado se añade al final: un permiso puede salir en mal sitio, nunca desaparecer.
+ * `test/tui-permisos.test.mjs` exige además que todos tengan nombre en los dos idiomas.
+ */
+const ORDEN = ['sign', 'store', 'read', 'admin', 'approve', 'passwords', 'sealer', 'unattended', 'replica']
+const CAPS_ORDER = [...ORDEN.filter((c) => DEVICE_CAPS.includes(c)),
+  ...DEVICE_CAPS.filter((c) => !ORDEN.includes(c))]
 
 /**
  * Los permisos que se le pueden dar A ESTE miembro, en orden.
@@ -1349,6 +1361,8 @@ async function toggleVisibility (term, st, wasPublic, apply) {
     if (r.ok) { flash(st, wasPublic ? i.nowPrivate : i.nowPublic); st.secrets = r.v }
   }
   if (wasPublic) return run()
+  // Solo se pregunta al ABRIRLA. Volverla privada es la dirección segura y se hace sin
+  // confirmar: pedir permiso para cerrar algo solo entrena a decir que sí.
   setConfirm(st, { text: i.makePublicConfirm, onYes: run, onNo: () => { st.confirm = null } })
 }
 
@@ -1394,17 +1408,23 @@ async function onKeyDevVars (term, st, key) {
 }
 
 /**
- * Al crear una variable se PREGUNTA si su valor puede salir de esta máquina. Se pregunta
- * al crearla, y no después, porque es cuando quien la escribe sabe qué es: un puerto se
- * puede enseñar, una llave de producción no. La respuesta por defecto —Enter, o `n`— es
- * la privada.
+ * Al crear una variable se pregunta SI ES PRIVADA. Se pregunta al crearla, y no después,
+ * porque es cuando quien la escribe sabe qué es: un puerto se puede enseñar, una llave de
+ * producción no.
+ *
+ * OJO AL SENTIDO. Antes se preguntaba lo contrario («¿que se pueda ver?») y el defecto
+ * —Enter o Esc— caía en `onNo`, que era la privada, o sea la segura. Al dar la vuelta a la
+ * pregunta, ese mismo defecto pasaría a ser la PÚBLICA sin que nadie lo notara: cada
+ * variable nueva se entregaría sin pedir permiso. Por eso el defecto se declara aquí
+ * (`defaultYes`) en vez de heredarse del manejador de teclas.
  */
 function askVisibility (term, st, done) {
   const i = L(st)
   setConfirm(st, {
-    text: i.newVarPublicAsk,
-    onYes: () => { st.confirm = null; done(true) },
-    onNo: () => { st.confirm = null; done(false) }
+    text: i.newVarPrivateAsk,
+    defaultYes: true,
+    onYes: () => { st.confirm = null; done(false) },   // privada
+    onNo: () => { st.confirm = null; done(true) }      // pública
   })
 }
 
@@ -1554,7 +1574,14 @@ async function onConfirmKey (st, key) {
   // La tecla es `y` (yes) en los dos idiomas —como el resto, mnemónico inglés—;
   // `s` (sí) se sigue aceptando por costumbre, pero no se anuncia en la ayuda.
   if (ch === 's' || ch === 'y') { const f = cf.onYes; st.confirm = null; await f?.() }
-  else if (ch === 'n' || key.name === 'escape' || key.name === 'enter' || key.name === 'ctrl-c') { const f = cf.onNo; st.confirm = null; await f?.() }
+  else if (ch === 'n') { const f = cf.onNo; st.confirm = null; await f?.() }
+  // Enter y Esc toman el CAMINO SEGURO, y cuál es lo dice quien pregunta. Sin esto el
+  // defecto era siempre «no», y una pregunta formulada al revés lo volvía el peligroso.
+  else if (key.name === 'escape' || key.name === 'enter' || key.name === 'ctrl-c') {
+    const f = cf.defaultYes ? cf.onYes : cf.onNo
+    st.confirm = null
+    await f?.()
+  }
 }
 
 // --------------------------------- render ----------------------------------

package/src/tui/i18n.js

@@ -39,45 +39,52 @@ const es = {
   // PERMISOS de un dispositivo (§9.1: se dice el beneficio, no el scope del cert).
   titleCaps: 'Permisos del dispositivo',
   capsFor: (id, name) => `Permisos de ${id}${name ? ' · ' + name : ''}`,
-  capsNoMember: '  (este dispositivo ya no está en el acta)',
+  capsNoMember: '  (este dispositivo ya no está en el perfil)',
   capsApplyHint: 'Enter marca o desmarca · G guarda los cambios · Esc sale',
-  capsPending: (n) => `${n} cambio(s) sin guardar (*) · G para guardarlos en UNA sola acta · Esc para descartarlos`,
-  capsSaved: (n) => `${n} cambio(s) guardados en una sola acta`,
+  capsPending: (n) => `${n} cambio(s) sin guardar (*) · G para guardarlos todos de una vez · Esc para descartarlos`,
+  capsSaved: (n) => `${n} cambio(s) guardados de una vez`,
   capsNothing: 'No has cambiado nada',
   capsDiscard: '¿Descartar los cambios sin guardar?',
+  // EL NOMBRE DICE EL ACTO, NO LA CONSECUENCIA (dueño, 2026-09-02: «que digan exactamente
+  // lo que hacen y no lo que implican»). «Sellar el acta» y «Administrar el perfil» eran
+  // lo segundo: hay que saberse el modelo para traducirlos. Lo que hacen es admitir
+  // aparatos y conectar o quitar dispositivos, y eso es lo que se lee ahora.
   capName: {
     // Lleva el cajón dentro: «las claves de proxy» dice QUÉ abre; «lee sus claves» te deja
     // preguntándote cuáles. Solo se le ofrece a un servicio (los que tienen `cn`).
     secrets: (cn) => `Leer las claves de «${cn}»`,
-    sign: 'Firmar como tú',
+    sign: 'Entrar a las apps como tú',
     store: 'Guardar tus datos',
     read: 'Leer tus datos',
-    admin: 'Administrar el perfil',
+    admin: 'Conectar y quitar dispositivos',
     passwords: 'Pedir tus contraseñas',
-    approve: 'Aprobar pedidos',
-    sealer: 'Sellar el acta',
-    unattended: 'Recibir claves sin aprobación'
+    approve: 'Autorizar a otros aparatos',
+    sealer: 'Admitir aparatos sin esta bóveda',
+    unattended: 'Llevarse claves sin pedirte permiso',
+    replica: 'Entregar tus claves con la bóveda apagada'
   },
   capHint: {
     secrets: (cn) => `abrir SU cajón y ninguno más: las variables de «${cn}»`,
     sign: 'usar tu identidad en las apps del ecosistema',
     store: 'escribir en tu bóveda (perfil, contenido, datos sensibles)',
     read: 'ver lo que guardaste',
-    admin: 'conectar y quitar dispositivos desde ese aparato, sin venir aquí',
+    admin: 'hacerlo desde ese aparato, sin venir aquí. No puede cambiar permisos',
     passwords: 'el gestor: pedir una credencial por sitio, nunca la lista entera',
     approve: 'dar el visto bueno cuando otro aparato pide claves privadas',
     // Sellar solo significa algo en un aparato que HAGA de bóveda (otra máquina con el
     // daemon, o un navegador que se puso de bóveda). En un teléfono normal se concede y no
     // lo usa nadie. Se enseña igual, y se dice: verlo desactivado explica el modelo;
     // esconderlo hacía creer que no existe (dueño, 2026-08-31).
-    sealer: 'admitir aparatos y cambiar permisos él solo, si esta bóveda no está. Solo sirve en otra BÓVEDA',
-    unattended: 'llevarse claves privadas SIN preguntarte. Apagado, cada vez que arranque tienes que aprobarlo desde un aparato con «Aprobar»'
+    sealer: 'admitir aparatos y cambiar permisos él solo cuando esta bóveda no está. Solo sirve en otra BÓVEDA',
+    unattended: 'llevarse claves privadas SIN preguntarte. Apagado, cada vez que arranque tienes que aprobarlo desde un aparato con «Aprobar»',
+    // El replicador reparte y no puede nada más: no abre lo que entrega ni cambia nada.
+    replica: 'las entrega cerradas, tal como salieron de aquí: no puede abrirlas ni cambiar nada. Solo sirve en otra máquina'
   },
   confirmAdmin: (id) => `¿Dejar que ${id} conecte y quite dispositivos sin venir aquí?`,
   capGiven: (n) => `Concedido: ${n}`,
   capTaken: (n) => `Quitado: ${n}`,
   applyingCaps: 'Aplicando…',
-  loadingMembers: 'Cargando el acta…',
+  loadingMembers: 'Cargando los dispositivos…',
   helpCaps: ['↑↓', 'Enter marcar', 'G guardar', 'F5 refrescar', 'Esc dispositivos', 'l English', 'q salir'],
   // Perfil del usuario (lo que sincronizan los dispositivos). Solo lectura: se edita en
   // el aparato, no en la máquina donde vive la bóveda.
@@ -152,7 +159,7 @@ const es = {
   noDevices: '  (sin dispositivos enrolados — pulsa P para emparejar uno)',
   noLabel: '(sin etiqueta)',
   // Está en el acta y no puede entrar: o le retiraron el certificado, o se le venció.
-  deviceNoAccess: 'SIN ACCESO — está en el acta pero no puede entrar',
+  deviceNoAccess: 'SIN ACCESO — está en el perfil pero no puede entrar',
   deviceDebt: (n) => `no abre ${n}`,
   thisVault: 'esta bóveda (manda ella)',
   cantRemoveMaster: 'Esta bóveda es la que manda: no se quita a sí misma.',
@@ -165,7 +172,7 @@ const es = {
   noPendingToReject: 'No hay ningún dispositivo pendiente para rechazar',
   rejecting: 'Rechazando…',
   deviceRejected: 'Dispositivo rechazado',
-  revokeConfirm: (id) => `¿Quitar ${id} del perfil? Sale del acta y se le retiran los certificados ya. Lo que tenga guardado se le borra cuando se conecte: si está apagado, sigue ahí hasta entonces.`,
+  revokeConfirm: (id) => `¿Quitar ${id} del perfil? Pierde el acceso ahora mismo. Lo que tenga guardado se le borra cuando se conecte: si está apagado, sigue ahí hasta entonces.`,
   revoking: 'Revocando…',
   deviceRevoked: (id) => `Revocado ${id}`,
   approveLabel: (id) => `Código que MUESTRA el dispositivo ${id}`,
@@ -213,11 +220,15 @@ const es = {
   },
   loadNothing: 'No se cargó nada:',
   varPublic: 'pública',
-  newVarPublicAsk: '¿Que su valor se pueda VER desde la consola remota? (las demás no salen de esta máquina)',
-  makePublicConfirm: '¿Dejar que su valor se vea desde la consola remota?',
-  changingVisibility: 'Cambiando visibilidad…',
-  nowPublic: 'Ahora su valor se puede ver desde la consola remota',
-  nowPrivate: 'Ahora su valor no sale de esta máquina',
+  // LA PREGUNTA ES LA PREGUNTA, sin explicar la consecuencia (dueño, 2026-09-02:
+  // «debe decir: ¿la variable es privada? y punto»). Antes decía «¿que su valor se pueda
+  // VER desde la consola remota?», que además ya era FALSO: desde el 2026-09-02 las dos se
+  // guardan cifradas igual y `pública` solo dice que se entrega sin pedirte permiso.
+  newVarPrivateAsk: '¿Es privada?',
+  makePublicConfirm: '¿Hacerla pública?',
+  changingVisibility: 'Cambiando…',
+  nowPublic: 'Pública: se entrega sin pedirte permiso',
+  nowPrivate: 'Privada: para entregarla te pide permiso',
 
   // variables de UN aparato (Dispositivos → tecla e). Las del scope las comparten todos
   // los aparatos que sirven ese namespace; estas las lee solo él, y le ganan.
@@ -332,11 +343,11 @@ const es = {
   // El código NO es la contraseña de la bóveda: son los seis dígitos que el aparato
   // enseña en su pantalla. Si no coincide, la bóveda no firma nada y el aparato sigue
   // esperando ahí, así que se puede volver a intentar con A.
-  errWrongCode: 'El código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Míralo otra vez y pulsa A.',
+  errWrongCode: 'El código no coincide con el que muestra el dispositivo: no ha entrado nadie. Míralo otra vez y pulsa A.',
   errProfileLocked: 'Bóveda bloqueada: ábrela con su contraseña',
   errWrongPassword: (n) => `Contraseña incorrecta${n ? ` — van ${n} intentos fallidos` : ''}`,
   errTooManyTries: (s) => `Demasiados intentos: espera ${s || '?'} s antes de volver a probar`,
-  errMasterWithMembers: 'Esta bóveda es el Master de esta cuenta y hay otros dispositivos: pásale primero el Master a uno que esté conectado. Si la borras así, se quedan con su llave y sin nadie que pueda volver a firmar el acta.'
+  errMasterWithMembers: 'Esta bóveda es la que manda en esta cuenta y hay otros dispositivos: pásale primero el mando a uno que esté conectado. Si la borras así, se quedan con su llave y sin nadie que pueda volver a darles permisos.'
 }
 
 // ---------------------------------- inglés ----------------------------------
@@ -362,35 +373,37 @@ const en = {
   capsNoMember: '  (this device is no longer in the record)',
   capsApplyHint: 'Enter ticks or unticks · G saves · Esc leaves',
   capsPending: (n) => `${n} unsaved change(s) (*) · G to save them in ONE record · Esc to discard`,
-  capsSaved: (n) => `${n} change(s) saved in a single record`,
+  capsSaved: (n) => `${n} change(s) saved in one go`,
   capsNothing: 'You have not changed anything',
   capsDiscard: 'Discard the unsaved changes?',
   capName: {
     secrets: (cn) => `Read the «${cn}» keys`,
-    sign: 'Sign as you',
+    sign: 'Sign in to apps as you',
     store: 'Save your data',
     read: 'Read your data',
-    admin: 'Manage the profile',
+    admin: 'Connect and remove devices',
     passwords: 'Ask for your passwords',
-    approve: 'Approve requests',
-    sealer: 'Seal the record',
-    unattended: 'Take keys without approval'
+    approve: 'Authorise other devices',
+    sealer: 'Admit devices without this vault',
+    unattended: 'Take keys without asking you',
+    replica: 'Hand out your keys while the vault is off'
   },
   capHint: {
     sign: 'use your identity across the ecosystem apps',
     store: 'write to your vault (profile, content, sensitive data)',
     read: 'see what you saved',
-    admin: 'connect and remove devices from that device, without coming here',
+    admin: 'do it from that device, without coming here. It cannot change permissions',
     passwords: 'the manager: ask for one credential per site, never the whole list',
     approve: 'give the go-ahead when another device asks for private keys',
-    sealer: 'admit devices and change permissions on its own if this vault is gone. Only useful on another VAULT',
-    unattended: 'take private keys WITHOUT asking you. Off, you must approve it from a device with «Approve» every time it starts'
+    sealer: 'admit devices and change permissions on its own when this vault is away. Only useful on another VAULT',
+    unattended: 'take private keys WITHOUT asking you. Off, you must approve it from a device with «Approve» every time it starts',
+    replica: 'it hands them over sealed, exactly as they left here: it cannot open them or change anything. Only useful on another machine'
   },
   confirmAdmin: (id) => `Let ${id} connect and remove devices without coming here?`,
   capGiven: (n) => `Granted: ${n}`,
   capTaken: (n) => `Removed: ${n}`,
   applyingCaps: 'Applying…',
-  loadingMembers: 'Loading the record…',
+  loadingMembers: 'Loading the devices…',
   helpCaps: ['↑↓', 'Enter tick', 'G save', 'F5 refresh', 'Esc devices', 'l Español', 'q quit'],
   loadingProfile: 'Loading profile…',
   noProfile: '  (this vault has no profile yet)',
@@ -474,7 +487,7 @@ const en = {
   noPendingToReject: 'No device is waiting to be rejected',
   rejecting: 'Rejecting…',
   deviceRejected: 'Device rejected',
-  revokeConfirm: (id) => `Remove ${id} from the profile? It leaves the record and its certificates are withdrawn right away. What it has stored is erased when it connects: if it is switched off, it stays there until then.`,
+  revokeConfirm: (id) => `Remove ${id} from the profile? It loses access right away. What it has stored is erased when it connects: if it is switched off, it stays there until then.`,
   revoking: 'Revoking…',
   deviceRevoked: (id) => `Revoked ${id}`,
   approveLabel: (id) => `Code SHOWN by device ${id}`,
@@ -519,11 +532,11 @@ const en = {
   },
   loadNothing: 'Nothing was loaded:',
   varPublic: 'public',
-  newVarPublicAsk: 'Let its value be SEEN from the remote console? (the rest never leave this machine)',
-  makePublicConfirm: 'Let its value be seen from the remote console?',
-  changingVisibility: 'Changing visibility…',
-  nowPublic: 'Its value can now be seen from the remote console',
-  nowPrivate: 'Its value no longer leaves this machine',
+  newVarPrivateAsk: 'Is it private?',
+  makePublicConfirm: 'Make it public?',
+  changingVisibility: 'Changing…',
+  nowPublic: 'Public: handed over without asking you',
+  nowPrivate: 'Private: handing it over asks you first',
 
   // variables de UN aparato (Dispositivos → tecla e)
   titleDevVars: 'Device variables',
@@ -618,7 +631,7 @@ const en = {
   errNotApplied: 'The daemon did not apply the change (check the service logs).',
   errNotDeleted: 'The daemon did not delete the variable (check the service logs).',
   errPairFailed: 'The daemon did not start the pairing.',
-  errWrongCode: 'The code does not match the one shown by the device: no certificate was issued. Check it and press A again.',
+  errWrongCode: 'The code does not match the one shown by the device: nobody got in. Check it and press A again.',
   errProfileLocked: 'Vault locked: open it with its password',
   errWrongPassword: (n) => `Wrong password${n ? ` — ${n} failed attempts so far` : ''}`,
   errTooManyTries: (s) => `Too many attempts: wait ${s || '?'} s before trying again`,

package/src/vault.js

@@ -1161,6 +1161,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
       if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
       if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
+      if (payload.type === MSG.REPLICA_ACK) return await handleReplicaAck(from, payload)
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
@@ -1355,7 +1356,15 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * ventana. La CLAVE distingue los dos cajones (`<ns>` y `dev:<pub>`) para que tocar
    * lo de un aparato no cancele el aviso pendiente de todo su namespace.
    */
-  function scheduleNotice (ns) { schedule(ns, () => notifyNsChange(ns)) }
+  function scheduleNotice (ns) {
+    schedule(ns, async () => {
+      await notifyNsChange(ns)
+      // Y a los replicadores el sobre nuevo. Sin esto repartirían el valor de ayer: el
+      // aviso de cambio le dice al servicio que se reinicie, y al reiniciar volvería a
+      // pedir — y si la bóveda está apagada, el replicador le daría lo viejo.
+      await pushToReplicas(`secret:${ns}`)
+    })
+  }
   function scheduleDeviceNotice (pub) { schedule('dev:' + pub, () => notifyDeviceChange(pub)) }
 
   function schedule (key, fn) {
@@ -1432,6 +1441,80 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       for (const d of issued || []) avisar(d.sub)
       log(`[vault] notified ${seen.size} member(s) of "${ev}" (record #${acta?.seq ?? '?'})`)
     } catch (e) { log('[vault] could not notify members of the change:', e.message) }
+    // Y a los replicadores, que no quieren un aviso sino el CONTENIDO: sin esto se
+    // quedarían con el acta de ayer y repartiendo sobres de un aparato ya revocado.
+    await pushToReplicas(ev)
+  }
+
+  /**
+   * EL ARRASTRE AL ARRANCAR (`docs/replicas.md` §6). Un replicador dice por dónde va en
+   * cuanto se conecta, y si va por detrás se le empuja.
+   *
+   * Sin esto, la bóveda solo empujaba al cambiar algo: un replicador que se enciende
+   * después se quedaba vacío hasta el siguiente cambio, que puede no llegar en semanas.
+   * Y el empujón de un enrolamiento se manda a un aparato que todavía no está conectado.
+   * Lo destapó el smoke y era un hueco del diseño, no del código.
+   *
+   * El acuse va FIRMADO por el replicador y se comprueba contra el acta: sin eso, cualquiera
+   * podría pedirle a la bóveda que reparta el acta y los sobres mandando un acuse inventado.
+   */
+  async function handleReplicaAck (from, p) {
+    const body = p?.body
+    if (!body || body.op !== 'replica.ack') return
+    const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!record) return
+    // LA LLAVE VA DENTRO DEL MENSAJE FIRMADO, no se saca de `from`: `from` es el
+    // identificador de la conexión en el proxio, no la llave del miembro. Compararlo con
+    // el acta rechazaba a todo el mundo, y en el caso contrario habría sido peor.
+    const quien = body.publickey
+    if (typeof quien !== 'string' || !Acta.memberCan(record, quien, 'replica')) {
+      return log('[vault] a replica ack arrived from someone the record does not allow to serve: ignored')
+    }
+    if (!(await verifyDeviceSig({ publickey: quien, data: body, signature: p.signature }))) {
+      return log('[vault] a replica ack does not check out against its own key: ignored')
+    }
+    if (typeof body.seq === 'number' && body.seq >= record.seq) return
+    log(`[vault] a replica is at #${body.seq} and we are at #${record.seq}: catching it up`)
+    await pushToReplicas('catch-up')
+  }
+
+  /**
+   * EMPUJAR A LOS REPLICADORES lo que tienen que poder repartir: el acta y los sobres.
+   *
+   * Se manda TODO firmado de antes —el acta la selló la maestra, cada sobre lo firmó la
+   * llave de sellado— así que un replicador no puede falsificar nada de lo que le damos.
+   * Y va cerrado a su destinatario, no a él: reparte sobres que no puede abrir. Es lo que
+   * permite ponerlo en una máquina en la que no confías (`docs/replicas.md` §8.bis).
+   *
+   * Se empuja después de cada cambio, y no se espera acuse: si un replicador está apagado
+   * se queda atrás y lo alcanza el siguiente empujón. Un replicador atrasado no es un
+   * peligro —el cliente rechaza un acta con `seq` menor del que ya vio— sino menos
+   * disponibilidad, que es exactamente lo que un replicador arriesga.
+   */
+  async function pushToReplicas (motivo = 'change') {
+    try {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      if (!record) return
+      const replicas = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'replica'))
+      if (!replicas.length) return
+
+      // UN SOBRE POR (CAJÓN, APARATO), porque `bundleFor` lo talla a quien lo pide: lleva
+      // solo las envolturas de ESE aparato. Mandar uno genérico no serviría de nada.
+      const bundles = {}
+      for (const m of record.members || []) {
+        if (!m.cn) continue
+        try { bundles[`${m.cn} ${m.pub}`] = secrets.bundleFor(m.cn, m.pub) } catch (_) {}
+      }
+      const body = { op: 'replica.push', seq: record.seq, acta: record, bundles, ts: Date.now() }
+      const seal = await signSeal(body)
+      if (!seal) return log('[vault] cannot push to the replicas: the record names no sealing key of ours')
+      let n = 0
+      for (const r of replicas) {
+        try { client.sendByPubkey(r.pub, { type: MSG.REPLICA_PUSH, body, seal }); n++ }
+        catch (e) { log(`[vault] could not push to a replica: ${e.message}`) }
+      }
+      log(`[vault] pushed record #${record.seq} and ${Object.keys(bundles).length} bundle(s) to ${n} replica(s) on ${motivo}`)
+    } catch (e) { log('[vault] could not push to the replicas: ' + e.message) }
   }
 
   /**
@@ -2291,7 +2374,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // ANTES de reenvolver nada: si la copia de recuperación se quedó bajo la llave de la
     // máquina, se pasa a la frase. Sin esto, todo lo de abajo falla con «wrong password».
     if (adminKey) await migrarRecuperacionALaFrase(adminKey)
-    const out = { drawers: 0, wrapped: 0, dropped: 0, sinLlave: [], failed: [] }
+    const out = { drawers: 0, wrapped: 0, sealed: 0, dropped: 0, sinLlave: [], failed: [] }
     for (const owner of secrets.owners?.() || []) {
       const before = new Set(secrets.recipientsIn(owner))
       // POR VISIBILIDAD, no una lista fija: una pública lleva además la envoltura de quien
@@ -2303,6 +2386,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         const after = new Set(secrets.recipientsIn(owner))
         out.drawers++
         out.wrapped += r?.wrapped || 0
+        out.sealed += r?.sealed || 0
         out.dropped += [...before].filter((p) => !after.has(p)).length
         for (const p of r?.sinLlave || []) out.sinLlave.push(p)
       } catch (e) {
@@ -2310,7 +2394,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         out.failed.push({ owner, error: e.message })
       }
     }
-    if (out.dropped) audit('secret.reseal', { drawers: out.drawers, dropped: out.dropped })
+    if (out.dropped || out.sealed) audit('secret.reseal', { drawers: out.drawers, dropped: out.dropped, sealed: out.sealed })
     if (out.failed.length) audit('secret.reseal-failed', { drawers: out.failed.map((f) => f.owner) })
     return out
   }
@@ -2603,6 +2687,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (r?.locked === false) { try { await ensureCommKeyInActa() } catch (_) {} }
       return { locked: r?.locked !== false }
     },
+    // Forzar un empujón: lo usa `replica push` de la CLI y el smoke, para no depender
+    // de que justo acabe de cambiar algo.
+    pushToReplicas,
     startPairing: desk.startPairing,
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,