@dotrino/vaultd 0.97.0 → 0.105.1

package/src/ctl.js

@@ -208,6 +208,17 @@ async function cmdPair (args = []) {
   // Sin esto el nombre lo ponía el propio aparato, que por defecto usa el apodo del
   // PERFIL: acababas con varios dispositivos llamados igual que tú, y para distinguirlos
   // había que renombrarlos después —cuando ya no sabías cuál era cuál—.
+  // UNA BANDERA QUE NO EXISTE SE DICE, no se ignora. Escribir `--label` en vez de `--name`
+  // emparejaba igual y en silencio, y el aparato entraba llamándose «cli»; el error se
+  // veía media hora después mirando el acta, si es que se miraba. Una opción que tecleas
+  // y no hace nada es un fallo mudo, que es justo lo que aquí no se acepta.
+  const CONOCIDAS = new Set(['--admin', '--adopt', '--kms', '--name', '--new-account', '--quiet', '--scope', '--service', '--save', '--profile'])
+  const rara = args.find((a) => a.startsWith('--') && !CONOCIDAS.has(a))
+  if (rara) {
+    console.error('no existe la opción %s', rara)
+    console.error('las de `pair` son: %s', [...CONOCIDAS].join(' '))
+    process.exit(2)
+  }
   const nIdx = args.indexOf('--name')
   let label = null
   if (nIdx >= 0) {
@@ -254,6 +265,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 }
@@ -548,7 +563,10 @@ async function cmdMembers () {
     // Resaltado como los otros cuatro: dice si esa máquina se lleva tus claves privadas
     // sola o si te lo pregunta. Sin traducción salía el identificador en crudo
     // (`unattended`) en una lista que lee un humano.
-    unattended: `${B}recibe claves sin aprobación${Z}`
+    unattended: `${B}recibe claves sin aprobación${Z}`,
+    // Y el que reparte cuando esta bóveda no está. Se resalta como los demás que cambian
+    // lo que ese aparato puede hacerle a la cuenta.
+    replica: `${B}entrega tus claves con la bóveda apagada${Z}`
   }
   // El nombre del perfil es una pubkey JWK. Recortarla no la hace legible: la deja
   // pareciendo un error (`{"key_ops":["verify"],"e…`). Se muestra su huella corta, la
@@ -578,7 +596,7 @@ async function cmdMembers () {
     // se mira quién es quién — y en la lista de variables ya seria tarde.
     if (m.cn && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
   }
-  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +desatendido')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba | +contrasenas | +sella | +desatendido | +replica')
   console.log('  «Permiso»: ese aparato solo recibe claves privadas cuando lo apruebas desde un aparato con «aprueba» (en cada arranque).')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
   console.log('  No deja cambiar permisos ni traspasar el mando: eso solo se hace en esta máquina.')
@@ -644,6 +662,9 @@ async function cmdCaps (args = []) {
     // podrá admitir aparatos y cambiar permisos si esta se pierde. No es un traspaso:
     // quien manda sigue mandando. Como `administra`, no se empareja: se concede aquí.
     sella: 'sealer', sealer: 'sealer',
+    // `replica`: reparte los sobres que esta bóveda ya firmó, cuando ella no está. No
+    // tiene maestra y no puede abrir nada. A diferencia de `sella`, SÍ se empareja.
+    replica: 'replica', replicador: 'replica',
     // `contraseñas`: el gestor (la extensión, la app del teléfono) puede PEDIR
     // credenciales de a una. Se acepta con y sin tilde: nadie escribe la ñ en una CLI.
     contrasenas: 'passwords', 'contraseñas': 'passwords',
@@ -1606,7 +1627,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 +1667,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 +1722,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 +1823,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(',') })
@@ -555,6 +567,10 @@ export async function runDaemon () {
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
           } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          // Renombrar NO pide la frase: solo hay que volver a firmar el sobre —el nombre va
+          // dentro de lo firmado— y eso lo hace la llave de sellado con la bóveda cerrada.
+          else if (sec.op === 'rename') { await vault.renameSecret(sec.ns, sec.key, sec.to); console.log('[vault] secret renamed: %s/%s → %s', sec.ns, sec.key, sec.to) }
+          else if (sec.op === 'dev-rename') { await vault.renameDeviceSecret(sec.pub, sec.key, sec.to); console.log('[vault] device secret renamed: %s → %s', sec.key, sec.to) }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
           // Saldar lo que quedó a deber: heredarle a un aparato nuevo lo ya guardado y

package/src/replica.js

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

@@ -72,6 +72,32 @@ const KEY_RE = /^[A-Z0-9_]{1,64}$/
  */
 export const RECOVERY = '#recovery'
 
+/**
+ * EL CAJÓN DEL PERFIL. Los datos de tu identidad se guardan como cualquier variable —
+ * mismo sobre, mismo llavero, mismo histórico— porque son lo mismo: un valor que solo
+ * pueden leer tus aparatos. Diseño: `docs/datos-del-perfil.md`.
+ *
+ * SE LLAMA `@me` A PROPÓSITO, y es la garantía entera: un nombre de cajón válido es
+ * `[a-z0-9-]{1,32}`, así que **ningún servicio puede llamarse `@me`**. Por lo tanto
+ * `memberCanReadSecrets(acta, quien, '@me')` no puede ser cierto nunca y no hay forma de
+ * pedir el perfil por el camino de los secretos. No es una comprobación que alguien pueda
+ * olvidarse de hacer: es un nombre que el validador no deja existir.
+ */
+export const PROFILE_NS = '@me'
+export const PROFILE_OWNER = 'ns:' + PROFILE_NS
+
+/**
+ * El nombre de un dato del perfil. NO vale `assertVar`: aquélla exige MAYÚSCULAS porque
+ * describe una variable de entorno, y aquí los campos son `nickname`, `telefono`,
+ * `apellidos`. Mismo espíritu —un nombre corto y previsible, sin sorpresas al serializar—
+ * y distinto alfabeto.
+ */
+export function assertProfileKey (key) {
+  if (typeof key !== 'string' || !/^[a-z][a-z0-9_]{0,31}$/.test(key)) {
+    throw new Error('invalid profile field (use lowercase_with_underscores, e.g. "nickname")')
+  }
+}
+
 /** Cuántas versiones anteriores se conservan, en total. Ver «EL HISTÓRICO» arriba. */
 const MAX_HISTORY = 500
 
@@ -818,6 +844,75 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
     owners () {
       return [...Object.keys(data.ns).map((k) => `ns:${k}`), ...Object.keys(data.dev).map((k) => `dev:${k}`)]
     },
+    // ---------------- EL PERFIL (`docs/datos-del-perfil.md`) ----------------
+    //
+    // Escribir un dato PRIVADO no necesita nada de aquí: es `putSealed(PROFILE_OWNER, …)`,
+    // que ya guarda un sobre hecho sin abrirlo y funciona con la bóveda cerrada. Lo que
+    // falta es leerlo, y el camino de lo PÚBLICO, que no se parece a ninguna variable.
+
+    /**
+     * Los sobres del perfil TALLADOS a un aparato: sus entradas y las envolturas suyas.
+     * Igual que `bundleFor`, sin `assertNs` — `@me` no es un nombre de cajón válido, y esa
+     * es justamente su garantía.
+     *
+     * El PAQUETE LO ARMA EL APARATO (dueño, 2026-09-03): aquí solo se entrega lo que hay.
+     */
+    profileBundleFor (devicePub) {
+      const bag = data.ns
+      const k = PROFILE_NS
+      if (isLegacy() || !bag[k]) return { entries: {}, wraps: [] }
+      const wraps = (bag[k].keyring || [])
+        .filter((g) => g.wraps?.[devicePub])
+        .map((g) => ({ gen: g.gen, wrap: g.wraps[devicePub] }))
+      return { entries: { ...varsOf(bag, k) }, wraps }
+    },
+
+    /**
+     * LO PÚBLICO DE VERDAD: en claro, y firmado. Es lo que recibe quien pregunta desde
+     * fuera y no tiene ninguna llave tuya — no hay a quién sellárselo (dueño, 2026-09-03).
+     *
+     * Va firmado igual que lo demás: un dato público sin firma es un dato que cualquiera
+     * puede inventar en tu nombre, que es peor que no tenerlo.
+     */
+    profilePublic () {
+      const bag = data.ns[PROFILE_NS]
+      if (!bag?.vars) return {}
+      const out = {}
+      for (const [key, e] of Object.entries(bag.vars)) {
+        if (e?.cls !== 'public' || typeof e.pubv !== 'string') continue
+        out[key] = { v: e.pubv, gen: e.gen, seal: e.seal || null, at: e.at || null, by: e.by || null }
+      }
+      return out
+    },
+
+    /**
+     * Guarda un dato PÚBLICO del perfil: en claro y con su firma. No lleva sobre ni
+     * envoltura porque no se le sella a nadie.
+     *
+     * `pubv` y no `v`: un `v` suelto dentro de un paquete de variables es un error duro
+     * desde el 2026-09-02 (`plaintext-var`), y con razón. Aquí es lo correcto, así que se
+     * escribe con otro nombre — el paquete del perfil lo arma otro código y esa invariante
+     * de los secretos se queda intacta.
+     */
+    async profilePutPublic (key, value, { by = null } = {}) {
+      return enFila(async () => {
+        if (isLegacy()) throw new Error('profile: this store is still v3 (run `migrate` first)')
+        if (needsMigration()) throw new NeedsMigration()
+        assertProfileKey(key)
+        if (typeof value !== 'string' || value.length > 200000) {
+          throw new Error('a public profile field must be a string of at most 200 kB')
+        }
+        const vars = ensureBag(data.ns, PROFILE_NS)
+        const before = vars[key]
+        const gen = (topGen(data.ns, PROFILE_NS)?.gen || 0) + 1
+        const seal = signer ? await signer({ owner: PROFILE_OWNER, key, gen, iv: '', ct: value }) : null
+        pushHistory(PROFILE_OWNER, key, before, by)
+        vars[key] = { cls: 'public', pub: true, owner: PROFILE_OWNER, gen, pubv: value, seal, at: Date.now(), by: by || null }
+        save()
+        return { gen }
+      })
+    },
+
     /** @private */
     /**
      * @param {Array|((isPublic:boolean)=>Promise<Array>)} members A quién envolver. Puede ser
@@ -895,6 +990,47 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       return { wrapped, sealed, sinLlave: [...sinLlave] }
     },
 
+    /**
+     * RENOMBRAR UNA VARIABLE. Cambia el nombre y NADA MÁS: el mismo sobre, la misma
+     * generación, las mismas envolturas. El valor no se toca ni se mira.
+     *
+     * Lo único que hay que rehacer es la FIRMA, porque el nombre va dentro de lo firmado
+     * (§8.8: `{owner, key, gen, iv, ct}`). Sin eso el sobre quedaría diciendo que se llama
+     * de otra manera y el agente lo rechazaría al abrirlo — un fallo que aparecería lejos
+     * de aquí y sin pista.
+     *
+     * Y firmar de nuevo NO pide la frase: la llave de sellado existe justo para esto, no
+     * abre nada. Así que renombrar funciona con la bóveda cerrada, como escribir.
+     *
+     * El HISTÓRICO se muda con ella: es la misma variable, y dejarlo bajo el nombre viejo
+     * lo volvería inalcanzable — se vería como un hueco, no como una decisión.
+     */
+    async rename (owner, from, to) { return enFila(() => this._renameRaw(owner, from, to)) },
+    /** @private */
+    async _renameRaw (owner, from, to) {
+      if (needsMigration()) throw new NeedsMigration()
+      assertKeyValue(to, 'x')
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      const vars = varsOf(bag, k)
+      const e = vars[from]
+      if (!e) throw new Error(`there is no variable called "${from}" in ${owner}`)
+      if (from === to) return { renamed: false }
+      if (vars[to]) throw new Error(`"${to}" already exists in ${owner}: pick another name or remove it first`)
+
+      // La firma lleva el nombre dentro, así que se rehace. Si esta bóveda no puede firmar,
+      // se para: dejar el sobre con la firma vieja es dejarlo roto para quien lo abra.
+      if (e.e) {
+        if (!signer) throw new Error('this vault cannot sign right now: renaming would leave the envelope signed with the old name')
+        e.seal = await signer({ owner, key: to, gen: e.gen, iv: e.e.iv, ct: e.e.ct })
+      }
+      delete vars[from]
+      vars[to] = e
+      for (const h of data.history) if (h.owner === owner && h.key === from) h.key = to
+      save()
+      return { renamed: true }
+    },
+
     /**
      * ROTA de verdad: vuelve a cifrar las variables privadas del cajón con llaves nuevas
      * y solo para los miembros dados. Es lo que corta el acceso de quien salió —

package/src/threadStore.js

@@ -103,6 +103,16 @@ export function openThreadStore (dir) {
     },
     profileGet () { return { me: data.profile || null } },
 
+    // LOS DATOS DEL PERFIL EN SOBRES (`docs/datos-del-perfil.md`). Están aquí solo para
+    // que el filtro de métodos los reconozca: los atiende `handleProfile` en `vault.js`,
+    // antes de llegar a este store, porque su puerta es otra —`firma` y sin candado—.
+    // Si alguna vez alguien los llamara por este camino, contestan que no en vez de
+    // hacer algo a medias.
+    profilePut () { throw new Error('profilePut is handled before the store: see handleProfile') },
+    profileBundle () { throw new Error('profileBundle is handled before the store: see handleProfile') },
+    profilePublic () { throw new Error('profilePublic is handled before the store: see handleProfile') },
+    profileRecipients () { throw new Error('profileRecipients is handled before the store: see handleProfile') },
+
     // ----- DATOS SENSIBLES del usuario (F4, docs/consola-remota.md §6) -----
     //
     // Contraseñas, notas, documentos: van al contenido del perfil, cifrados con la

package/src/transport.js

@@ -46,11 +46,33 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
   // su `identify` pisaba al anterior. Sigue siendo el cliente oficial del paquete.
   const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
 
-  // WebRTC off: el vault usa el proxy como transporte (RTCPeerConnection no existe
-  // en Node). Reconexión prácticamente ilimitada: un daemon de larga duración no
-  // debe rendirse tras unos intentos.
+  /**
+   * EL CANAL DIRECTO, ENCENDIDO Y CON LA PUERTA CERRADA.
+   *
+   * Encendido porque es el escalón 2 de la regla del transporte (`CLAUDE.md`) y en Node ya
+   * hay con qué (`werift`, que el pilar carga solo). Si no lo hubiera, negociar falla y se
+   * sigue por el proxio — el escalón 4 siempre está.
+   *
+   * Y con la puerta cerrada desde el primer día, que es lo que hace defendible encenderlo:
+   * **solo se le negocia a quien está en el acta.** Aceptar una señal arranca DTLS, ICE y
+   * SCTP, o sea código que parsea red no confiable, dentro del proceso que guarda la
+   * maestra. Quien decide si eso corre no puede ser el que llama a la puerta.
+   *
+   * Reconexión prácticamente ilimitada: un daemon de larga duración no debe rendirse tras
+   * unos intentos.
+   */
+  // La puerta tiene que decidir AL INSTANTE (la señal llega y o se atiende o no), y pedir
+  // el acta es asíncrono. Así que se guarda una copia y se refresca donde ya se refresca
+  // todo: en `identify`, que es lo que corre cada vez que el acta cambia o se reconecta.
+  let actaVista = null
+  const enElActa = (token) => {
+    // SIN ACTA NO SE NEGOCIA. No se sabe quién es nadie, y en la duda no se arranca a
+    // parsear red no confiable. Se sigue por el proxio, que es el escalón que siempre está.
+    if (!actaVista) return false
+    return (actaVista.members || []).some((m) => m?.pub === token)
+  }
   const client = new WebSocketProxyClient({
-    url, enableWebRTC: false, autoReconnect: true,
+    url, enableWebRTC: true, acceptDirectFrom: enElActa, autoReconnect: true,
     maxReconnectAttempts: 100000, reconnectDelay: 4000
   })
 
@@ -59,6 +81,7 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
   const identify = async () => {
     if (!client.token) return
     const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+    actaVista = record   // la copia que mira la puerta del canal directo
     const comm = commKey?.pub?.() || null
     // ¿Nos nombra el acta? Con `cn` o sin él, lo que el proxio mira es la pertenencia.
     const esMiembro = comm && (record?.members || []).some((m) => m?.pub === comm)