@dotrino/vaultd 0.98.0 → 0.105.1

package/lib/src/admin.js

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

package/lib/src/index.js

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

package/lib/src/localdesk.js

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

package/lib/src/service.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.98.0",
+  "version": "0.105.1",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {
@@ -22,7 +22,7 @@
   "dependencies": {
     "@dotrino/identity": "0.79.0",
     "@dotrino/passmanager": "^0.10.1",
-    "@dotrino/proxy-client": "^0.13.1",
+    "@dotrino/proxy-client": "0.15.0",
     "ws": "^8.18.0"
   },
   "license": "MIT",
@@ -47,5 +47,8 @@
     "@dotrino/remote-agent": "0.6.1",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
+  },
+  "optionalDependencies": {
+    "@dotrino/webrtc": "0.1.0"
   }
 }

package/src/approvals.js

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

package/src/client.js

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

package/src/ctl.js

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

package/src/daemon.js

@@ -567,6 +567,10 @@ export async function runDaemon () {
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
           } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          // Renombrar NO pide la frase: solo hay que volver a firmar el sobre —el nombre va
+          // dentro de lo firmado— y eso lo hace la llave de sellado con la bóveda cerrada.
+          else if (sec.op === 'rename') { await vault.renameSecret(sec.ns, sec.key, sec.to); console.log('[vault] secret renamed: %s/%s → %s', sec.ns, sec.key, sec.to) }
+          else if (sec.op === 'dev-rename') { await vault.renameDeviceSecret(sec.pub, sec.key, sec.to); console.log('[vault] device secret renamed: %s → %s', sec.key, sec.to) }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
           // Saldar lo que quedó a deber: heredarle a un aparato nuevo lo ya guardado y

package/src/replica.js

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

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)

package/src/tui/app.js

@@ -390,6 +390,8 @@ function capsRows (st, t) {
     // qué vas a firmar — que es justo lo que hace peligroso acumular cambios.
     const cambia = has.has(cap) !== real.has(cap)
     if (cambia) tocados++
+    // El título ES el nombre del permiso —el mismo que se teclea en `caps <ID> +administra`—
+    // así que no hay que repetirlo al lado. Lo que hace va debajo.
     const line = ` ${mark}${cambia ? t.bold('*') : ' '} ${cap === 'admin' ? t.bold(name) : name}`
     rows.push({ text: line, sel: true, meta: { cap } })
     const hint = typeof i.capHint[cap] === 'function' ? i.capHint[cap](member.cn) : i.capHint[cap]
@@ -1312,12 +1314,44 @@ async function onKeySecrets (term, st, key) {
     await revealValue(term, st, `ns:${cur.ns}`, cur.key, cur.public)
   } else if (ch === 't' && cur?.key) {
     await toggleVisibility(term, st, cur.public, () => vc.setSecretVisibility(cur.ns, cur.key, !cur.public, activeId(st), activePwd(st)))
+  } else if (ch === 'r' && cur?.key) {
+    await promptRenameVariable(term, st, cur)
   } else if (key.name === 'f5') {
     await refreshSecrets(term, st)
   }
   return true
 }
 
+/**
+ * RENOMBRAR: el mismo sobre con otro nombre. No pide la frase, porque lo único que hay que
+ * rehacer es la firma —el nombre va DENTRO de lo firmado— y de eso se encarga la llave de
+ * sellado, que trabaja con la bóveda cerrada.
+ *
+ * Se avisa de lo que de verdad importa y no se ve: para el servicio que la lee esto es un
+ * cambio de configuración, así que se va a reiniciar. Si su código busca el nombre viejo,
+ * dejará de encontrarlo — y eso no lo puede saber la bóveda.
+ */
+function promptRenameVariable (term, st, cur) {
+  const i = L(st)
+  return new Promise((listo) => {
+    setInput(st, {
+      label: i.renameLabel(cur.key),
+      hint: i.renameHint,
+      value: cur.key,
+      onSubmit: async (nuevo) => {
+        const nv = nuevo.trim()
+        st.input = null
+        if (!nv || nv === cur.key) { listo(); return }
+        if (!KEY_RE.test(nv)) { flash(st, i.keyInvalid, 'danger'); listo(); return }
+        const r = await guard(term, st, i.renaming, () => vc.renameSecret(cur.ns, cur.key, nv, activeId(st)))
+        if (r.ok) { flash(st, i.renamed(cur.key, nv)); st.secrets = r.v }
+        listo()
+      },
+      onCancel: () => { st.input = null; listo() }
+    })
+  })
+}
+
 /**
  * Hacer pública una variable es dejar que su valor SALGA de esta máquina, así que se
  * pregunta; volverla privada no expone nada y se aplica directo.
@@ -1420,11 +1454,17 @@ async function onKeyDevVars (term, st, key) {
  */
 function askVisibility (term, st, done) {
   const i = L(st)
+  // SE DEVUELVE LA PROMESA. `onConfirmKey` hace `await f?.()` para SERIALIZAR las
+  // operaciones contra el daemon —lo dice el comentario de `onInputKey`—, y soltarla aquí
+  // dejaba la escritura corriendo por fuera de esa serialización: se solapaba con el
+  // refresco periódico, los dos usan el mismo archivo de respuesta, el refresco lo borraba
+  // antes de que la escritura lo leyera y la pantalla se quedaba en «Guardando…» para
+  // siempre. El valor SÍ se había guardado, que es lo que lo hacía tan confuso.
   setConfirm(st, {
     text: i.newVarPrivateAsk,
     defaultYes: true,
-    onYes: () => { st.confirm = null; done(false) },   // privada
-    onNo: () => { st.confirm = null; done(true) }      // pública
+    onYes: () => { st.confirm = null; return done(false) },   // privada
+    onNo: () => { st.confirm = null; return done(true) }      // pública
   })
 }
 

package/src/tui/i18n.js

@@ -49,36 +49,41 @@ const es = {
   // 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.
+  // EL TÍTULO ES EL NOMBRE DEL PERMISO, no una descripción (dueño, 2026-09-03: «deben
+  // decir siempre lo que SON»). Antes puse frases —«Conectar y quitar dispositivos»— y el
+  // resultado fue una lista donde no se sabía qué permiso era cuál ni cómo nombrarlo para
+  // el CLI. Lo que hace cada uno va DEBAJO, que es su sitio.
   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: 'Entrar a las apps como tú',
-    store: 'Guardar tus datos',
-    read: 'Leer tus datos',
-    admin: 'Conectar y quitar dispositivos',
-    passwords: 'Pedir tus contraseñas',
-    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'
+    secrets: (cn) => `secretos «${cn}»`,
+    sign: 'firma',
+    store: 'guarda',
+    read: 'lee',
+    admin: 'administra',
+    passwords: 'contrasenas',
+    approve: 'aprueba',
+    sealer: 'sella',
+    unattended: 'desatendido',
+    replica: 'replica'
   },
+  // CADA PISTA SE SOSTIENE SOLA. Antes colgaban del título —«hacerlo desde ese aparato»
+  // continuaba a «Conectar y quitar dispositivos»—; ahora el título es la palabra que se
+  // teclea, así que la pista tiene que decir la frase entera.
   capHint: {
-    secrets: (cn) => `abrir SU cajón y ninguno más: las variables de «${cn}»`,
+    secrets: (cn) => `abrir el cajón de «${cn}» y ningún otro`,
     sign: 'usar tu identidad en las apps del ecosistema',
-    store: 'escribir en tu bóveda (perfil, contenido, datos sensibles)',
+    store: 'escribir en tu bóveda: perfil, contenido, datos',
     read: 'ver lo que guardaste',
-    admin: 'hacerlo desde ese aparato, sin venir aquí. No puede cambiar permisos',
-    passwords: 'el gestor: pedir una credencial por sitio, nunca la lista entera',
+    admin: 'conectar y quitar aparatos desde ahí, sin venir aquí. No puede cambiar permisos',
+    passwords: 'pedir una contraseña 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 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»',
+    unattended: 'llevarse claves privadas sin preguntarte. Apagado, hay que aprobarlo desde un aparato con «aprueba» cada vez que arranque',
     // 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'
+    replica: 'repartir los sobres que esta bóveda ya firmó, tal como salieron: no puede abrirlos 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}`,
@@ -227,6 +232,10 @@ const es = {
   newVarPrivateAsk: '¿Es privada?',
   makePublicConfirm: '¿Hacerla pública?',
   changingVisibility: 'Cambiando…',
+  renameLabel: (k) => `Nuevo nombre para ${k}`,
+  renameHint: 'MAYUSCULAS_CON_GUION_BAJO · el valor no se toca · Esc cancela',
+  renaming: 'Renombrando…',
+  renamed: (a, b) => `${a} ahora se llama ${b} — el servicio que la lee se reinicia; si busca el nombre viejo, ya no lo encuentra`,
   nowPublic: 'Pública: se entrega sin pedirte permiso',
   nowPrivate: 'Privada: para entregarla te pide permiso',
 
@@ -299,7 +308,7 @@ const es = {
   deviceRenamed: (n) => `Ahora se llama «${n}»`,
   helpSecrets: ({ hasSecrets } = {}) => [
     '←→ pestaña', '↑↓', 'n nueva variable', 'i cargar varias',
-    ...(hasSecrets ? ['v ver valor', 't pública/privada', 'x quitar (variable/scope)'] : []),
+    ...(hasSecrets ? ['v ver valor', 't pública/privada', 'r renombrar', 'x quitar (variable/scope)'] : []),
     'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
   ],
   helpDevVars: ({ hasVars } = {}) => [
@@ -376,28 +385,32 @@ const en = {
   capsSaved: (n) => `${n} change(s) saved in one go`,
   capsNothing: 'You have not changed anything',
   capsDiscard: 'Discard the unsaved changes?',
+  // El título es el NOMBRE del permiso, el mismo que se teclea. Ver la nota en el bloque
+  // español: describirlo dejaba una lista donde no se sabía qué permiso era cuál.
   capName: {
-    secrets: (cn) => `Read the «${cn}» keys`,
-    sign: 'Sign in to apps as you',
-    store: 'Save your data',
-    read: 'Read your data',
-    admin: 'Connect and remove devices',
-    passwords: 'Ask for your passwords',
-    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'
+    secrets: (cn) => `secrets «${cn}»`,
+    sign: 'sign',
+    store: 'store',
+    read: 'read',
+    admin: 'admin',
+    passwords: 'passwords',
+    approve: 'approve',
+    sealer: 'sealer',
+    unattended: 'unattended',
+    replica: 'replica'
   },
+  // Cada pista se sostiene sola: el título es la palabra, no una frase que continuar.
   capHint: {
+    secrets: (cn) => `open the «${cn}» drawer and no other`,
     sign: 'use your identity across the ecosystem apps',
-    store: 'write to your vault (profile, content, sensitive data)',
+    store: 'write to your vault: profile, content, data',
     read: 'see what you saved',
-    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',
+    admin: 'connect and remove devices from there, without coming here. It cannot change permissions',
+    passwords: 'ask for one password 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 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'
+    unattended: 'take private keys without asking you. Off, it must be approved from a device with «approve» every time it starts',
+    replica: 'hand out the envelopes this vault already signed, exactly as they left: 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}`,
@@ -535,6 +548,10 @@ const en = {
   newVarPrivateAsk: 'Is it private?',
   makePublicConfirm: 'Make it public?',
   changingVisibility: 'Changing…',
+  renameLabel: (k) => `New name for ${k}`,
+  renameHint: 'UPPERCASE_WITH_UNDERSCORES · the value is not touched · Esc cancels',
+  renaming: 'Renaming…',
+  renamed: (a, b) => `${a} is now ${b} — the service that reads it restarts; if it looks for the old name, it will not find it`,
   nowPublic: 'Public: handed over without asking you',
   nowPrivate: 'Private: handing it over asks you first',
 
@@ -593,7 +610,7 @@ const en = {
   deviceRenamed: (n) => `Now called "${n}"`,
   helpSecrets: ({ hasSecrets } = {}) => [
     '←→ tab', '↑↓', 'n new variable', 'i load several',
-    ...(hasSecrets ? ['v show value', 't public/private', 'x remove (variable/scope)'] : []),
+    ...(hasSecrets ? ['v show value', 't public/private', 'r rename', 'x remove (variable/scope)'] : []),
     'F5 refresh', 'Esc vaults', 'l Español', 'q quit'
   ],
   helpDevVars: ({ hasVars } = {}) => [

package/src/vault.js

@@ -26,7 +26,7 @@ import { startSealersPublisher } from './sealers.js'
 import { assertKeyOwnsDir } from './keyowner.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
-import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP } from './secretsStore.js'
+import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
 // `PENDING_TTL_MS` se usa abajo, al esperar la firma del aprobador: sin importarlo, esa
 // espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
 // llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
@@ -36,7 +36,9 @@ import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { openCommKey, COMM_CN, COMM_CAPS } from './commKey.js'
 import { seal } from '../lib/src/sealed.js'
+import { localSocketPath, socketDir } from '../lib/src/localdesk.js'
 import { dataDir, ensureDir } from './paths.js'
+import net from 'node:net'
 import { atRestFor, kekFor, migrateFile, encryptText, decryptText } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
 
@@ -321,15 +323,26 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * Así que una respuesta que no quepa no se manda: se sustituye por un error, que sí cabe.
    * Una bóveda que dice «no cabe» se arregla; una muda no se puede ni diagnosticar.
    */
+  /**
+   * QUIÉN CONTESTA A QUIÉN. Por defecto el proxio; un remitente LOCAL (el socket de esta
+   * máquina) se apunta aquí con su propia forma de contestar.
+   *
+   * Que haya dos transportes no cambia NADA de quién puede pedir qué: la autorización sale
+   * del certificado y del acta, igual por los dos caminos. Alcanzar el socket no autoriza
+   * nada — es la misma puerta, con el camino más corto.
+   */
+  const canales = new Map()
+
   const reply = (to, obj) => {
     try {
+      const enviar = canales.get(to) || ((o) => client.send(to, o))
       const bytes = Buffer.byteLength(JSON.stringify(obj))
       if (bytes > MAX_REPLY_BYTES) {
         log(`[vault] the reply to ${obj?.type} does not fit (${bytes} bytes > ${MAX_REPLY_BYTES}): sending an error instead of killing the connection`)
         audit('reply-too-big', { type: obj?.type || null, bytes })
-        return client.send(to, { type: MSG.ERROR, error: `reply too big (${bytes} bytes): ask for less at a time` })
+        return enviar({ type: MSG.ERROR, error: `reply too big (${bytes} bytes): ask for less at a time` })
       }
-      client.send(to, obj)
+      enviar(obj)
     } catch (e) { log('[vault] could not reply:', e.message) }
   }
 
@@ -610,6 +623,69 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   // Store de hilos+aperturas (Fase 3): escrituras requieren vault:store; lecturas
   // aceptan vault:store o vault:read. Cada op va firmada por D + cert (cadena D←maestra).
+  /**
+   * LOS DATOS DEL PERFIL (`docs/datos-del-perfil.md`). Tres métodos y ninguno más:
+   *
+   *   · `profilePut`      — guarda un dato. Privado = sobre ya sellado; público = en claro.
+   *   · `profileBundle`   — los sobres de ESTE aparato, para que arme su perfil.
+   *   · `profilePublic`   — lo público en claro, que puede pedir cualquiera.
+   *
+   * Lo que NO se comprueba aquí: el candado. Un sobre sellado no lo puede leer ni fabricar
+   * la bóveda, así que guardarlo no es una decisión suya y no necesita su maestra. Ese era
+   * el motivo real por el que editar el perfil exigía abrirla, y es el síntoma que abrió
+   * todo esto: se cerraba sola a los cinco minutos y editar dejaba de funcionar.
+   */
+  const PROFILE_METHODS = new Set(['profilePut', 'profileBundle', 'profilePublic', 'profileRecipients'])
+
+  async function handleProfile (from, p, d) {
+    // LO PÚBLICO NO PIDE NADA. Es lo que ve quien pregunta desde fuera y no tiene ninguna
+    // llave tuya: pedir un papel para leerlo sería contradecir lo que significa «público».
+    // Va firmado, así que quien lo recibe comprueba que es tuyo sin fiarse de nadie.
+    if (d.method === 'profilePublic') {
+      return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: secrets.profilePublic() })
+    }
+    // A QUIÉN HAY QUE ENVOLVERLE. Lo pide el aparato ANTES de sellar, porque sellar lo hace
+    // él: envolver solo necesita públicas, así que puede hacerlo un navegador sin que
+    // ninguna privada ande suelta. Sale de aquí y no de una lista suya para que conceder
+    // `firma` a un aparato nuevo baste — sin que nadie tenga que acordarse de nada.
+    if (d.method === 'profileRecipients') {
+      const members = await recipientsOf(PROFILE_OWNER)
+      return reply(from, {
+        type: MSG.STORE_RESULT,
+        method: d.method,
+        result: { recoveryPub: secrets.recoveryPub(), members: members.map((m) => ({ pub: m.pub, encPub: m.encPub })) }
+      })
+    }
+
+    const revoked = await revocationSet()
+    // `vault:sign` — hablar por ti. No `vault:store`, que es guardar cosas.
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.SIGN, ...(await contextoActa()), revoked })
+    if (!chk.ok) return denyChain(from, chk, p, 'profile')
+    if (!await actaAllows(from, chk, SCOPE.SIGN, 'profile')) return
+
+    try {
+      if (d.method === 'profileBundle') {
+        const b = secrets.profileBundleFor(chk.device)
+        return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: b })
+      }
+      // profilePut
+      const { key, cls, sobre, value } = d.args || {}
+      const quien = await deviceIdOf(chk.device).catch(() => null)
+      let r
+      if (cls === 'public') {
+        r = await secrets.profilePutPublic(key, value, { by: quien })
+      } else {
+        r = await secrets.putSealed(PROFILE_OWNER, key, sobre, { by: quien })
+      }
+      audit('profile.put', { key, cls: cls || 'private', by: quien, gen: r?.gen ?? null })
+      // Y a los demás aparatos, que si no se enteran al arrancar y vuelve la divergencia.
+      await notifyMembers('profile', { key, by: quien })
+      return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: r })
+    } catch (e) {
+      return reply(from, { type: MSG.ERROR, error: 'profile: ' + e.message })
+    }
+  }
+
   async function handleStore (from, p) {
     const d = p.data
     // `Object.hasOwn` y no `threads.methods[d.method]`: con la comprobación laxa,
@@ -619,9 +695,19 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return reply(from, { type: MSG.ERROR, error: 'store: invalid method' })
     }
     if (!isFresh(d)) return staleReply(from)
-    // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil. Un
-    // dispositivo enrolado puede seguir firmando, leyendo y guardando contenido;
-    // lo que no puede es reescribir quién sos mientras el perfil está bloqueado.
+    // EL PERFIL VA POR OTRO CAMINO, y por eso se atiende antes que nada
+    // (`docs/datos-del-perfil.md`). Dos diferencias, y las dos son el arreglo:
+    //
+    //   · **No hace falta abrir la bóveda.** Lo que llega es un sobre ya sellado y
+    //     firmado, que ella no puede leer ni falsificar: aceptarlo no es una decisión
+    //     suya. El candado estaba ahí porque guardaba el perfil en claro; ya no.
+    //   · **Lo gatea `firma`, no `guarda`.** Escribir tu identidad es hablar por ti, no
+    //     guardar un archivo en tu bóveda (dueño, 2026-09-03). El proxio tiene `guarda`
+    //     para lo suyo y no debe poder cambiar quién eres.
+    if (PROFILE_METHODS.has(d.method)) return await handleProfile(from, p, d)
+    // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil heredado
+    // (`profileSet`, el `me` plano). Un dispositivo enrolado puede seguir firmando,
+    // leyendo y guardando contenido.
     if (PROFILE_EDIT_METHODS.has(d.method) && isLocked()) {
       audit('rejected', { what: 'store', method: d.method, reason: 'locked' })
       return reply(from, { type: MSG.ERROR, error: 'profile locked: unlock it on the vault machine (dotrino-vault unlock) to edit it' })
@@ -981,7 +1067,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!publicOnly && needsApproval(chk.device, record)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
-      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
+      // `from` SE GUARDA: la respuesta llega más tarde —cuando alguien apruebe— y tiene que
+      // volver POR DONDE VINO. Si la pregunta entró por el mostrador local, mandarla por el
+      // proxio la deja en el vacío: quien preguntó está escuchando en el socket, no ahí.
+      // Lo cazó el E2E de aprobación, que se quedó esperando cinco minutos.
+      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek, from })
       audit('secrets.pending', { device: deviceId, ns, id: pend.id })
       log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
       const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
@@ -1093,8 +1183,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (op === 'deny') {
       audit('secrets.denied', { device: pend.deviceId, ns: pend.ns, id, by })
       log(`[vault] ${pend.ns}: request of ${pend.deviceId} DENIED by ${by}`)
-      try { client.sendByPubkey(pend.device, { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }) }
-      catch (e) { log(`[vault] ${pend.ns}: could not tell ${pend.deviceId} it was denied: ${e.message}`) }
+      try {
+        const err = { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }
+        const porLocal = pend.from && canales.get(pend.from)
+        if (porLocal) porLocal(err)
+        else client.sendByPubkey(pend.device, err)
+      } catch (e) { log(`[vault] ${pend.ns}: could not tell ${pend.deviceId} it was denied: ${e.message}`) }
       return answer({ op: 'deny.result', id, ok: true })
     }
     if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
@@ -1108,8 +1202,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // EL FALLO NO SE TRAGA. Tragarlo era lo peor de este mostrador: la bóveda apuntaba
     // «aprobado», el que pedía no recibía nada, y no quedaba una sola línea que mirar —
     // así que el dueño aprobaba una y otra vez creyendo que el teléfono no llegaba.
-    try { client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res }) }
-    catch (e) { log(`[vault] ${pend.ns}: approved, but the reply did not reach ${pend.deviceId}: ${e.message}`) }
+    // Por el canal por el que preguntó. Si fue el proxio, `sendByPubkey`: así lo recoge al
+    // volver aunque ahora esté apagado. Si fue el socket local, por el socket.
+    try {
+      const porLocal = pend.from && canales.get(pend.from)
+      if (porLocal) porLocal({ type: MSG.SECRETS_RESULT, ...res })
+      else client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res })
+    } catch (e) { log(`[vault] ${pend.ns}: approved, but the reply did not reach ${pend.deviceId}: ${e.message}`) }
     return answer({ op: 'approve.result', id, ok: true })
   }
 
@@ -1144,7 +1243,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     } catch (e) { log('[vault] could not notify approvers:', e.message) }
   }
 
-  client.on('message', async (from, payload) => {
+  client.on('message', (from, payload) => onMessage(from, payload))
+
+  // EL MOSTRADOR LOCAL, siempre que se pueda. Si no se puede abrir (un sistema sin sockets
+  // de archivo, un directorio de solo lectura) se dice y se sigue: los servicios usan el
+  // proxio como hasta ahora. Lo que NO se hace es callarlo — un atajo que no está y nadie
+  // lo dice es media hora buscando por qué algo va lento.
+  // El socket se nombra por la LLAVE de esta bóveda: una máquina puede tener varias, y un
+  // servicio solo conoce la maestra que lleva pineada. Así los dos lados calculan la misma
+  // ruta sin mirar ningún índice.
+  if (identity.me?.publickey) {
+    abrirMostradorLocal(localSocketPath((await pubkeyId(identity.me.publickey)).slice(0, 16)))
+  }
+
+  async function onMessage (from, payload) {
     if (!payload || typeof payload !== 'object') return
     try {
       if (payload.type === MSG.HELLO) return desk.handleHello(from, payload)
@@ -1165,7 +1277,60 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     } catch (e) {
       reply(from, { type: MSG.ERROR, error: e.message })
     }
-  })
+  }
+
+  /**
+   * EL MOSTRADOR LOCAL: el mismo protocolo, sin salir de la máquina.
+   *
+   * Un servicio en ESTA máquina hablaba con la bóveda dando la vuelta por
+   * `proxy.dotrino.com`: sale a internet, vuelve, y si el proxio tiene un mal momento el
+   * arranque se retrasa cinco segundos por nada. Absurdo cuando los dos procesos comparten
+   * disco (dueño, 2026-09-03: «estando en la misma máquina debería ser inmediato»).
+   *
+   * Es EL MISMO PROTOCOLO y el mismo enrutador: llega `{type, data, signature, cert}` y se
+   * comprueba igual, contra el certificado y contra el acta. **Alcanzar el socket no
+   * autoriza nada** — es la misma puerta por un camino más corto, no una puerta de atrás.
+   * Por eso no hay un solo `if` de «viene de local» en ningún handler, y no debe haberlo.
+   *
+   * Y no es un puerto: es un socket de archivo, en modo 0600 y bajo el directorio del
+   * usuario. No se alcanza desde otra máquina ni desde otro usuario, así que la promesa
+   * del `docker-compose` —«la bóveda no escucha nada»— sigue siendo cierta donde importa.
+   */
+  function abrirMostradorLocal (socketPath) {
+    let n = 0
+    const server = net.createServer((sock) => {
+      const id = 'local:' + (++n)
+      let buf = ''
+      const enviar = (obj) => { try { sock.write(JSON.stringify(obj) + '\n') } catch (_) {} }
+      canales.set(id, enviar)
+      sock.on('data', (chunk) => {
+        buf += chunk
+        // UN TOPE, y por lo mismo que en las respuestas: sin él, quien se conecte puede
+        // hacer crecer este buffer hasta tumbar la bóveda mandando y sin saltos de línea.
+        if (buf.length > MAX_REPLY_BYTES) { buf = ''; enviar({ type: MSG.ERROR, error: 'request too big' }); return }
+        let i
+        while ((i = buf.indexOf('\n')) >= 0) {
+          const linea = buf.slice(0, i); buf = buf.slice(i + 1)
+          if (!linea.trim()) continue
+          let p = null
+          try { p = JSON.parse(linea) } catch (_) { enviar({ type: MSG.ERROR, error: 'malformed request' }); continue }
+          onMessage(id, p).catch((e) => enviar({ type: MSG.ERROR, error: e.message }))
+        }
+      })
+      const cerrar = () => canales.delete(id)
+      sock.on('close', cerrar)
+      sock.on('error', cerrar)
+    })
+    server.on('error', (e) => log('[vault] the local desk could not open (' + e.message + '): services will use the proxy'))
+    try { fs.mkdirSync(socketDir(), { recursive: true, mode: 0o700 }) } catch (_) {}
+    try { fs.rmSync(socketPath, { force: true }) } catch (_) {}
+    server.listen(socketPath, () => {
+      try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
+      log('[vault] local desk at ' + socketPath + ' (same machine, no round trip)')
+    })
+    server.unref?.()
+    return server
+  }
 
   /**
    * AVISO DE OTRA BÓVEDA de la misma cuenta (multivault). Trae el acta nueva y aquí se
@@ -1897,6 +2062,19 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // abrirse desde un navegador. Lo que cambia es que «pública» ya sí quiere decir algo
     // para quien administra — puede leerla— además de que se despacha sin aprobación.
     const admins = isPublic ? await adminDevices() : []
+    // EL PERFIL SE LE ENVUELVE A QUIEN PUEDE HABLAR POR TI (`docs/datos-del-perfil.md`).
+    //
+    // Va explícito y antes que nada porque si no cae en la rama de «cajón sin dueño» y
+    // acabaría envuelto solo para quien ADMINISTRA — que no es lo que se decidió: leer y
+    // escribir tu identidad es `firma`, y no todos los que firman administran. Un teléfono
+    // normal firma y no administra, y tiene que ver tu perfil.
+    if (owner === PROFILE_OWNER) {
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      const firman = (record?.members || [])
+        .filter((m) => m.encPub && Acta.memberCan(record, m.pub, 'sign'))
+        .map((m) => ({ pub: m.pub, encPub: m.encPub }))
+      return conCoselladores(dedup(firman), co)
+    }
     if (owner.startsWith('ns:')) {
       const owned = await nsMembers(owner.slice(3))
       // Sin dueño (un cajón personal, o uno cuyo servicio ya no está) entra quien administra
@@ -2452,6 +2630,25 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   async function deleteSecret (ns, key) { const ok = await secrets.delete(ns, key); if (ok) { audit('secret.rm', { ns, key }); scheduleNotice(ns) } return ok }
 
+  /**
+   * RENOMBRAR una variable. Para el servicio que la lee es un cambio de configuración como
+   * cualquier otro —la de antes desaparece y aparece otra—, así que se avisa igual: si no,
+   * seguiría arrancando con el nombre viejo hasta el siguiente reinicio.
+   */
+  async function renameSecret (ns, from, to) {
+    const r = await secrets.rename(`ns:${ns}`, from, to)
+    if (r?.renamed) { audit('secret.rename', { ns, from, to }); scheduleNotice(ns) }
+    return r
+  }
+  async function renameDeviceSecret (pub, from, to) {
+    const r = await secrets.rename(`dev:${pub}`, from, to)
+    if (r?.renamed) {
+      audit('secret.rename', { device: await deviceIdOf(pub).catch(() => null), from, to, scope: 'device' })
+      scheduleDeviceNotice(pub)
+    }
+    return r
+  }
+
   /**
    * CARGAR CONFIGURACIÓN ES UNA TRANSACCIÓN: muchas variables, UN aviso.
    *
@@ -2738,7 +2935,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // El mostrador que atiende a la consola remota. Se expone para poder probar la
     // frontera de verdad (que el valor de una privada no salga ni dentro del sobre).
     vars: varsDesk,
-    setSecret, deleteSecret, listSecrets, setSecretVisibility, openSecrets,
+    setSecret, deleteSecret, renameSecret, renameDeviceSecret, listSecrets, setSecretVisibility, openSecrets,
     // Sella un `secrets.json` v3 entero. Es el punto de no retorno del despliegue y
     // por eso es una operación con nombre propio, no algo que ocurra de refilón al
     // desbloquear: deja `secrets.json.v3.bak` para poder volver.

package/src/vaultControl.js

@@ -513,6 +513,30 @@ export function deleteSecret (ns, key, profile) {
   })
 }
 
+/**
+ * Renombra una variable: el mismo sobre con otro nombre. No pide la frase — lo único que
+ * hay que rehacer es la firma, y de eso se encarga la llave de sellado.
+ *
+ * Se comprueban LAS DOS cosas: que la nueva esté y que la vieja ya no. Mirar solo una
+ * dejaría pasar una copia a medias, que es peor que un fallo.
+ */
+export function renameSecret (ns, key, to, profile) {
+  return secretOp({ op: 'rename', ns, key, to }, profile, (out) => {
+    if (!has(out.ns[ns], to) || has(out.ns[ns], key)) {
+      throw coded('the daemon did not rename the variable (check the service logs)', 'NOT_RENAMED')
+    }
+  })
+}
+
+/** Lo mismo para una variable de UN aparato. */
+export function renameDeviceSecret (pub, key, to, profile) {
+  return secretOp({ op: 'dev-rename', pub, key, to }, profile, (out) => {
+    if (!has(keysOf(out, pub), to) || has(keysOf(out, pub), key)) {
+      throw coded('the daemon did not rename the variable (check the service logs)', 'NOT_RENAMED')
+    }
+  })
+}
+
 /**
  * Cambia SOLO quién puede ver el valor: `public` deja que la consola remota lo vea,
  * `private` lo encierra en esta máquina. No toca el valor (ni hace falta conocerlo).