@dotrino/vaultd 0.98.0 → 0.105.2

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 } = {}) => [