@dotrino/vaultd 0.26.2 → 0.46.2

package/src/tui/app.js

@@ -8,6 +8,13 @@
  *   · Dispositivos (pares): ver · emparejar · aprobar/rechazar · revocar
  *   · Scopes y variables (secretos): ver · agregar · quitar
  *
+ * LAS VARIABLES DE ENTORNO SE PONEN EN DOS SITIOS, y cada uno está donde se elige lo
+ * que las distingue: las del SCOPE, que comparten todos los aparatos del perfil que
+ * sirven ese namespace, en su pestaña; las de UN APARATO, que solo lee él y pisan a
+ * las del scope, dentro de Dispositivos (tecla `e`), que es donde ya elegiste el
+ * aparato. No se repiten en las dos pantallas a propósito: la de scopes enlaza a la
+ * otra en vez de duplicarla.
+ *
  * Cada "bóveda" es un PERFIL (maestra propia, dir propio, dispositivos y secretos
  * propios). Las acciones operan sobre la bóveda ACTIVA; para operar otra, cámbiala
  * en la pantalla de bóvedas.
@@ -22,7 +29,9 @@
  * en todas las pantallas: `p` es SIEMPRE emparejar (también en Bóvedas, sin tener
  * que entrar antes), el candado es `k` (la `l` es el idioma) y la contraseña `c`.
  */
+import fs from 'node:fs'
 import { execFile } from 'node:child_process'
+import { parseEnvInput } from '../../lib/src/envtext.js'
 import { createTerm, widthOf } from './term.js'
 import { qrToString } from '../qr.js'
 import { dict, otherLang, loadLang, saveLang } from './i18n.js'
@@ -46,13 +55,19 @@ const L = (st) => dict(st?.lang)
  */
 function humanErr (e, st) {
   const t = L(st)
+  // Con dato: «contraseña incorrecta (van 9 intentos)» y «espera 32 s» son lo que hace
+  // falta para saber qué está pasando; «error» a secas parece que la pantalla se colgó.
+  if (e?.code === 'WRONG_PASSWORD') return t.errWrongPassword(e.tries)
+  if (e?.code === 'TOO_MANY_TRIES') return t.errTooManyTries(e.waitSec)
   const byCode = {
     DAEMON_DOWN: t.errDaemonDown,
     NO_REPLY: t.errNoReply,
     NOT_APPLIED: t.errNotApplied,
     NOT_DELETED: t.errNotDeleted,
     PAIR_FAILED: t.errPairFailed,
-    MASTER_WITH_MEMBERS: t.errMasterWithMembers
+    APPROVE_FAILED: t.errWrongCode,
+    MASTER_WITH_MEMBERS: t.errMasterWithMembers,
+    PROFILE_LOCKED: t.errProfileLocked
   }
   return byCode[e?.code] || e?.message || String(e)
 }
@@ -123,6 +138,13 @@ function activeProfile (st) {
   return list.find((p) => p.current) || list[0] || null
 }
 const activeId = (st) => activeProfile(st)?.id || undefined
+/**
+ * La contraseña del perfil ACTIVO, que la TUI ya guarda para toda la sesión al
+ * desbloquear (ver `reunlockSilently`). Las operaciones que SELLAN una variable la
+ * necesitan: sin ella el daemon cae a la llave de la máquina, que no abre la copia
+ * maestra de un perfil con contraseña, y la escritura falla con «wrong password».
+ */
+const activePwd = (st) => st.sessionPwd?.get(activeId(st)) || undefined
 
 function lockGlyph (p) {
   if (!p?.protected) return ''
@@ -235,15 +257,21 @@ function deviceRows (st, t) {
   }
   for (const d of devices) {
     const label = d.label || t.muted(i.noLabel)
-    const extra = d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : ''
+    const vars = devVarsOf(st, d.sub).length
+    const debt = debtOf(st, d.sub)
+    const extra = (d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : '') +
+      (vars ? t.muted(`  vars:${vars}`) : '') +
+      // EN DEUDA: en el acta y sin poder abrir lo suyo. Va en color de aviso al lado de
+      // sus variables, que es donde se mira cuando algo no arranca.
+      (debt ? t.warn(`  ${i.deviceDebt(debt)}`) : '')
     // SIN ACCESO: está en el acta y no puede entrar. Es un aviso, no un adorno, así que va
     // en el color de aviso y en el sitio donde estaría su vencimiento.
-    const estado = d.noAccess
+    const status = d.noAccess
       ? t.warn(i.deviceNoAccess)
       : d.isMaster
         ? t.muted(i.thisVault)
         : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp))
-    rows.push({ text: ` ${t.bold(d.deviceId)}  ${label}  ${estado}${extra}`, sel: true, meta: d })
+    rows.push({ text: ` ${t.bold(d.deviceId)}  ${label}  ${status}${extra}`, sel: true, meta: d })
   }
   const revoked = st.devices?.revoked || []
   if (revoked.length) {
@@ -256,11 +284,15 @@ function deviceRows (st, t) {
 /**
  * LA PREGUNTA DEL EMPAREJAMIENTO. La decisión es del vault (es quien lo inicia) y
  * este daemon puede tener varias cuentas: antes de mostrar el QR hay que decir a
- * cuál entra el dispositivo. Hoy se responde con las dos formas que existen —una
- * cuenta que ya vive aquí, o una nueva que se estrena para él—; la tercera
- * («adoptar la que trae el aparato») necesita el protocolo de adopción y se
- * muestra desactivada para no prometer lo que todavía no hace
- * (docs/vinculacion-de-cuentas.md §5).
+ * cuál entra el dispositivo. Se responde con las tres formas que existen —una
+ * cuenta que ya vive aquí, una nueva que se estrena para él, o un SERVICIO de la
+ * cuenta activa—; la cuarta («adoptar la que trae el aparato») necesita el
+ * protocolo de adopción y se muestra desactivada para no prometer lo que todavía
+ * no hace (docs/vinculacion-de-cuentas.md §5).
+ *
+ * Lo del servicio estaba SOLO en la línea de comandos (`pair --service <ns>`), y una
+ * máquina que sirve el proxy no se empareja de otra manera: sin esta opción, la TUI
+ * te dejaba a medio camino y había que salirse a la terminal a terminar el trabajo.
  */
 function pairModeRows (st, t) {
   const i = L(st)
@@ -272,6 +304,9 @@ function pairModeRows (st, t) {
   rows.push({ text: ` ${t.bold(i.pairModeNew)}`, sel: true, meta: { mode: 'new' } })
   rows.push({ text: t.muted('     ' + i.pairModeNewHint), sel: false })
   rows.push({ text: '', sel: false })
+  rows.push({ text: ` ${t.bold(i.pairModeService)}`, sel: true, meta: { mode: 'service' } })
+  rows.push({ text: t.muted('     ' + i.pairModeServiceHint), sel: false })
+  rows.push({ text: '', sel: false })
   rows.push({ text: ' ' + t.muted(i.pairModeAdopt), sel: false })
   rows.push({ text: t.muted('     (' + i.pairModeAdoptSoon + ')'), sel: false })
   return rows
@@ -282,25 +317,25 @@ function pairModeRows (st, t) {
  * una marca de si los tiene. El de administrar va aparte y avisado: es el único que deja
  * a ese aparato meter y sacar dispositivos sin venir aquí.
  */
-const CAPS_ORDEN = ['sign', 'store', 'read', 'admin']
+const CAPS_ORDER = ['sign', 'store', 'read', 'admin']
 
 function capsRows (st, t) {
   const i = L(st)
-  const objetivo = st.capsFor
-  if (!objetivo) return [{ text: t.muted(i.loading), sel: false }]
-  const miembro = (st.members || []).find((m) => m.pub === objetivo.pub)
-  if (!miembro) return [{ text: t.muted(i.capsNoMember), sel: false }]
+  const target = st.capsFor
+  if (!target) return [{ text: t.muted(i.loading), sel: false }]
+  const member = (st.members || []).find((m) => m.pub === target.pub)
+  if (!member) return [{ text: t.muted(i.capsNoMember), sel: false }]
 
-  const tiene = new Set(miembro.caps || [])
+  const has = new Set(member.caps || [])
   const rows = [
-    { text: ' ' + t.bold(i.capsFor(objetivo.deviceId, miembro.label || '')), sel: false },
+    { text: ' ' + t.bold(i.capsFor(target.deviceId, member.label || '')), sel: false },
     { text: '', sel: false }
   ]
-  for (const cap of CAPS_ORDEN) {
-    const marca = tiene.has(cap) ? '[x]' : '[ ]'
-    const nombre = i.capName[cap]
-    const linea = ` ${marca}  ${cap === 'admin' ? t.bold(nombre) : nombre}`
-    rows.push({ text: linea, sel: true, meta: { cap } })
+  for (const cap of CAPS_ORDER) {
+    const mark = has.has(cap) ? '[x]' : '[ ]'
+    const name = i.capName[cap]
+    const line = ` ${mark}  ${cap === 'admin' ? t.bold(name) : name}`
+    rows.push({ text: line, sel: true, meta: { cap } })
     rows.push({ text: t.muted('      ' + i.capHint[cap]), sel: false })
   }
   rows.push({ text: '', sel: false })
@@ -308,21 +343,90 @@ function capsRows (st, t) {
   return rows
 }
 
+/** Las variables por SCOPE: las que comparten todos los aparatos que sirven ese ns. */
 function secretRows (st, t) {
   const i = L(st)
-  const ns = st.secrets || {}
+  const ns = st.secrets?.ns || {}
   const names = Object.keys(ns).sort()
   const rows = []
-  if (!names.length) {
-    rows.push({ text: t.muted(i.noScopes), sel: false })
-    return rows
+  // El puntero a la otra pantalla va SIEMPRE, con scopes y sin ellos: es la mitad de la
+  // función y quien la busca no tiene por qué adivinar que vive en Dispositivos.
+  const footer = [{ text: '', sel: false }, { text: t.muted(' ' + i.devVarsElsewhere), sel: false }]
+  // ARRIBA DEL TODO, antes que las variables: lo que está sin sellar significa que esos
+  // aparatos NO están leyendo su configuración ahora mismo, y que solo la contraseña lo
+  // arregla. Un aviso que hay que buscar no es un aviso.
+  const head = []
+  for (const [owner, info] of Object.entries(st.secrets?.pending || {})) {
+    const who = (info?.members || []).map((m) => deviceIdOf(st, m.pub) + ' (' + m.keys.join(', ') + ')').join(', ')
+    head.push({ text: t.warn(' ' + i.pendingSeal(owner, info?.kind, who)), sel: false })
   }
+  const p = activeProfile(st)
+  if (p && !p.protected) head.push({ text: t.warn(' ' + i.noPasswordWarn), sel: false })
+  if (head.length) head.push({ text: '', sel: false })
+  if (!names.length) return [...head, { text: t.muted(i.noScopes), sel: false }, ...footer]
+  rows.push(...head)
   for (const n of names) {
     rows.push({ text: t.accent(` ▸ ${n}`) + t.muted(i.scopeOf(n)), sel: true, meta: { ns: n, key: null } })
-    for (const k of ns[n].slice().sort()) {
-      rows.push({ text: `      ${k}   ${t.muted('••••••')}`, sel: true, meta: { ns: n, key: k } })
+    for (const k of sortByKey(ns[n])) {
+      rows.push({ text: varLine(k, t, i), sel: true, meta: { ns: n, key: k.key, public: k.public } })
     }
   }
+  return [...rows, ...footer]
+}
+
+/** Las claves guardadas para UN aparato (`pub`), o `[]`. Cada una es `{key, public}`. */
+const devVarsOf = (st, pub) => (st.secrets?.dev || []).find((x) => x.pub === pub)?.keys || []
+
+/**
+ * Lo que ese aparato NO puede abrir (§8.11). Un servicio que entra después de escrita
+ * una variable no tiene envoltura de ella, y hasta que alguien se la reparta está en el
+ * acta sin poder arrancar del todo. Aquí se cuenta cuántas, que es lo que cabe en una
+ * fila; el detalle está en la consola.
+ */
+/** El ID corto de un aparato a partir de su llave, tal como lo enseña la lista de Aparatos. */
+const deviceIdOf = (st, pub) =>
+  (st.devices?.issued || []).find((d) => d.sub === pub)?.deviceId || (st.members || []).find((m) => m.pub === pub)?.id || pub.slice(0, 8)
+
+const debtOf = (st, pub) => {
+  const d = (st.secrets?.incomplete || []).find((x) => x.pub === pub)
+  return d ? [...new Set(Object.values(d.owners || {}).flat())].length : 0
+}
+
+const sortByKey = (list) => (list || []).slice().sort((a, b) => a.key.localeCompare(b.key))
+
+/**
+ * Una variable: su nombre y su valor. La PÚBLICA enseña el suyo —pública significa que ese
+ * valor puede salir de esta máquina, así que taparlo delante de su dueño, en la máquina
+ * donde vive, era lo único que la marca no quería decir— con el aviso de que viaja cuando
+ * la consola remota lo pide. La privada sigue tapada: no sale ni a esta pantalla.
+ */
+const varLine = (v, t, i) => `      ${v.key}   ` +
+  (v.public ? `${short(v.value)}   ${t.warn(i.varPublic)}` : t.muted('••••••'))
+
+/** Un valor largo no puede empujar la marca «pública» fuera de la pantalla. */
+const short = (s) => {
+  const v = String(s ?? '')
+  return v.length > 40 ? v.slice(0, 39) + '…' : v
+}
+
+/**
+ * Las variables de UN aparato. Se entra desde Dispositivos con `e`, ya con el aparato
+ * elegido: por eso aquí no se vuelve a elegir, solo se agrega y se quita.
+ */
+function devVarRows (st, t) {
+  const i = L(st)
+  const target = st.varsFor
+  if (!target) return [{ text: t.muted(i.loading), sel: false }]
+  const keys = sortByKey(devVarsOf(st, target.pub))
+  const rows = [
+    { text: ' ' + t.bold(i.devVarsFor(target.deviceId, target.label || '')), sel: false },
+    // Dato, no explicación: qué servicio es este aparato es lo que decide qué namespace
+    // lee, y por lo tanto a qué variables del scope le ganan estas.
+    { text: t.muted(' ' + i.devVarsService(target.cn)), sel: false },
+    { text: '', sel: false }
+  ]
+  if (!keys.length) rows.push({ text: t.muted(' ' + i.noDevVars), sel: false })
+  for (const k of keys) rows.push({ text: varLine(k, t, i), sel: true, meta: { key: k.key, public: k.public } })
   return rows
 }
 
@@ -341,27 +445,27 @@ function meRows (st, t) {
   if (!me) return [{ text: t.muted(i.noProfile), sel: false }, { text: '', sel: false }, { text: t.muted(i.noProfileHint), sel: false }]
 
   const rows = []
-  const campo = (etiqueta, valor, oculto) => rows.push({
-    text: `  ${t.muted(String(etiqueta).padEnd(12))} ${valor}${oculto ? t.muted(i.hidden) : ''}`, sel: false
+  const field = (label, value, hidden) => rows.push({
+    text: `  ${t.muted(String(label).padEnd(12))} ${value}${hidden ? t.muted(i.hidden) : ''}`, sel: false
   })
   rows.push({ text: t.muted(i.profileUpdated(me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—')), sel: false })
   rows.push({ text: '', sel: false })
-  campo(i.fieldName, me.nickname ? t.bold(me.nickname) : t.muted(i.noName))
-  campo(i.fieldPhoto, me.avatar
+  field(i.fieldName, me.nickname ? t.bold(me.nickname) : t.muted(i.noName))
+  field(i.fieldPhoto, me.avatar
     ? `${me.avatar.type || '?'} · ${(me.avatar.bytes / 1024).toFixed(1)} KB`
     : t.muted(i.no))
 
   const STD = [['nombres', i.fieldFirstName], ['apellidos', i.fieldLastName], ['email', i.fieldEmail],
     ['telefono', i.fieldPhone], ['direccion', i.fieldAddress]]
-  const puestos = STD.filter(([k]) => me[k])
-  if (puestos.length) rows.push({ text: '', sel: false })
-  for (const [k, etiqueta] of puestos) campo(etiqueta, me[k], me[k + 'Visible'] === false)
+  const filled = STD.filter(([k]) => me[k])
+  if (filled.length) rows.push({ text: '', sel: false })
+  for (const [k, label] of filled) field(label, me[k], me[k + 'Visible'] === false)
 
-  for (const [titulo, lista] of [[i.links, me.links], [i.otherData, me.fields]]) {
-    if (!Array.isArray(lista) || !lista.length) continue
+  for (const [title, list] of [[i.links, me.links], [i.otherData, me.fields]]) {
+    if (!Array.isArray(list) || !list.length) continue
     rows.push({ text: '', sel: false })
-    rows.push({ text: t.accent(' ▸ ' + titulo), sel: false })
-    for (const x of lista) campo(x.type || x.label || '', x.value, x.visible === false)
+    rows.push({ text: t.accent(' ▸ ' + title), sel: false })
+    for (const x of list) field(x.type || x.label || '', x.value, x.visible === false)
   }
   return rows
 }
@@ -381,28 +485,60 @@ async function guard (term, st, msg, fn) {
   try { const v = await fn(); st.busy = null; return { ok: true, v } } catch (e) { st.busy = null; flash(st, humanErr(e, st), 'danger'); return { ok: false, e } }
 }
 
-async function refreshAll (term, st) {
-  const r = await guard(term, st, L(st).loading, () => vc.snapshot(activeId(st)))
+/**
+ * ¿La bóveda ACTIVA está cerrada? El candado es POR BÓVEDA, no del vault: que una esté
+ * cerrada no puede dejarte sin la lista ni sin poder entrar a otra.
+ */
+const activeLocked = (st) => { const p = activeProfile(st); return !!(p?.protected && p.locked) }
+
+// `api` es `vaultControl` — se recibe para poder probar ESTA función (la que se rompió)
+// sin un daemon detrás, que es donde vive la regla de qué se pide y en qué orden.
+async function refreshAll (term, st, api = vc) {
+  // LA LISTA DE BÓVEDAS VA PRIMERO Y APARTE. Antes esto pedía el volcado de la bóveda
+  // activa y, si esa era la cerrada, se salía sin llegar a guardar la lista: la TUI abría
+  // en blanco, sin bóvedas y con un error rojo. O sea que la contraseña de UNA bóveda te
+  // dejaba fuera del vault entero, que es exactamente lo que un candado por perfil no debe
+  // hacer.
+  const p = await guard(term, st, L(st).loadingVaults, () => api.listProfiles())
+  if (p.ok) st.profiles = p.v
+  // Cerrada: no se pide su contenido, y tampoco se enseña un error por mirarla desde
+  // fuera. Lo que hubiera cargado se suelta, para no dejar en pantalla lo de antes.
+  if (activeLocked(st)) {
+    st.devices = null; st.secrets = null; st.members = []; st.me = undefined
+    return
+  }
+  const r = await guard(term, st, L(st).loading, () => api.snapshot(activeId(st)))
   if (!r.ok) return
-  const { devices, secrets, profiles, acta } = r.v
+  const { devices, secrets, profiles, record } = r.v
   if (profiles) st.profiles = profiles
-  if (secrets) st.secrets = secrets.ns || {}
+  // Los DOS cajones de variables viajan juntos: `ns` (por scope) y `dev` (por aparato).
+  if (secrets) st.secrets = { ns: secrets.ns || {}, dev: Array.isArray(secrets.dev) ? secrets.dev : [] }
   // El ACTA entra en el volcado normal: es de donde sale la lista de dispositivos (ver
   // `mergeMembersAndCerts`). Antes solo se pedía al abrir la pantalla de permisos.
-  if (acta) st.members = acta.members || []
+  if (record) st.members = record.members || []
   if (devices) {
     const issued = (devices.issued || devices.active || devices.delegations || [])
-    st.devices = { issued: await Promise.all(issued.map(async (d) => ({ ...d, deviceId: d.sub ? await vc.deviceIdOf(d.sub) : '????-????' }))), revoked: devices.revoked || [] }
+    st.devices = { issued: await Promise.all(issued.map(async (d) => ({ ...d, deviceId: d.sub ? await api.deviceIdOf(d.sub) : '????-????' }))), revoked: devices.revoked || [] }
   }
 }
 
+/**
+ * Guarda un volcado de dispositivos EN LOS DOS SITIOS.
+ *
+ * La lista se pinta desde el ACTA (`st.members`) con los certificados pegados
+ * (`st.devices`), así que quedarse solo con la mitad deja la pantalla mintiendo: aprobar
+ * un aparato no lo hacía aparecer y quitarlo no lo hacía desaparecer, hasta que algo
+ * volviera a pedir el acta. Peor todavía en una lista: el aparato recién entrado no salía,
+ * así que la fila «la última» era otra y quitarla se llevaba por delante a quien no era.
+ */
+function applyDump (st, v) {
+  st.devices = v
+  if (Array.isArray(v?.members)) st.members = v.members
+}
+
 async function refreshDevices (term, st) {
   const r = await guard(term, st, L(st).loadingDevices, () => vc.listDevices(activeId(st)))
-  if (!r.ok) return
-  st.devices = r.v
-  // La lista se pinta desde el acta; traerla aparte dejaba la pantalla con los miembros de
-  // hace dos operaciones (quitar uno no lo quitaba de la vista).
-  if (Array.isArray(r.v.members)) st.members = r.v.members
+  if (r.ok) applyDump(st, r.v)
 }
 async function refreshSecrets (term, st) {
   const r = await guard(term, st, L(st).loadingSecrets, () => vc.listSecrets(activeId(st)))
@@ -416,24 +552,66 @@ async function refreshMe (term, st) {
   const r = await guard(term, st, L(st).loadingProfile, () => vc.getMe(activeId(st)))
   st.me = r.ok ? r.v : null
 }
-async function refreshProfiles (term, st) {
-  const r = await guard(term, st, L(st).loadingVaults, () => vc.listProfiles())
+async function refreshProfiles (term, st, api = vc) {
+  const r = await guard(term, st, L(st).loadingVaults, () => api.listProfiles())
   if (r.ok) st.profiles = r.v
 }
 
-/** Asegura la bóveda desbloqueada antes de EDITARLA (rename/rm/password). */
-async function ensureUnlocked (term, st, p, thenFn) {
+/**
+ * TECLEADA UNA VEZ, VALE PARA TODA LA SESIÓN de la TUI.
+ *
+ * El candado vive en la MEMORIA DEL DAEMON, así que cualquier cosa que se lleve ese
+ * estado —un `systemctl restart` al actualizar, un reinicio del servicio, una petición
+ * que se perdió— dejaba la bóveda cerrada otra vez EN MITAD de la sesión, y la TUI
+ * volvía a pedir la contraseña como si nunca se hubiera tecleado.
+ *
+ * Por eso la contraseña de lo que se abre aquí se guarda en `st.sessionPwd` (SOLO en
+ * memoria de este proceso) y se vuelve a usar en silencio para reabrir la misma bóveda.
+ * Se olvida con el candado (`k`), al quitar la contraseña y al salir de la TUI, que es
+ * exactamente donde el dueño dijo que tiene que volver a hacer falta.
+ */
+// `api` es `vaultControl` — se recibe para poder probar esto sin un daemon detrás.
+async function reunlockSilently (term, st, p, api = vc) {
+  const pwd = st.sessionPwd?.get(p.id)
+  if (!pwd) return false
+  const r = await guard(term, st, L(st).unlocking, () => api.unlockProfile(p.id, pwd))
+  // Ya no vale (se la cambiaron desde otro sitio, o el freno está esperando): se olvida
+  // y se vuelve al camino normal, que es preguntar diciendo por qué.
+  if (!r.ok) { st.sessionPwd.delete(p.id); return false }
+  await refreshProfiles(term, st, api)
+  return true
+}
+
+/**
+ * Pide la contraseña si hace falta y sigue. Lo que se abre aquí queda anotado en
+ * `st.unlockedHere` para volver a cerrarlo AL SALIR (ver `runTui`): la contraseña dura lo
+ * que dura la sesión, no hasta que alguien reinicie el servicio. Lo que ya estaba abierto
+ * antes de entrar no se toca — no lo abrió esta pantalla, no le toca cerrarlo.
+ */
+async function ensureUnlocked (term, st, p, thenFn, reason = null, api = vc) {
   if (!p.protected || !p.locked) return thenFn()
+  // Cerrada, pero la contraseña ya se tecleó en esta sesión: se reabre sin molestar.
+  if (await reunlockSilently(term, st, p, api)) {
+    const fresh = (st.profiles?.profiles || []).find((x) => x.id === p.id) || p
+    return thenFn(fresh)
+  }
   const i = L(st)
   setInput(st, {
     label: i.passwordOf(p.name || p.id),
     mask: true,
-    hint: i.passwordToEdit,
+    // Si la anterior fue rechazada, el motivo se queda AQUÍ, pegado al campo, en vez de
+    // irse en un aviso de cuatro segundos que se lleva el siguiente redibujado. Eso era lo
+    // que hacía que un rechazo pareciera «me la vuelve a pedir porque sí».
+    hint: reason || i.passwordToEdit,
     onSubmit: async (pwd) => {
       st.input = null
-      const r = await guard(term, st, i.unlocking, () => vc.unlockProfile(p.id, pwd))
-      if (!r.ok) return
-      await refreshProfiles(term, st)
+      const r = await guard(term, st, i.unlocking, () => api.unlockProfile(p.id, pwd))
+      // Rechazada: se vuelve a pedir en el acto, diciendo por qué. Cerrar el campo obligaba
+      // a adivinar qué había pasado y a empezar de nuevo.
+      if (!r.ok) return ensureUnlocked(term, st, p, thenFn, humanErr(r.e, st), api)
+      st.unlockedHere?.add(p.id)
+      st.sessionPwd?.set(p.id, pwd) // vale para toda la sesión (ver reunlockSilently)
+      await refreshProfiles(term, st, api)
       const fresh = (st.profiles.profiles || []).find((x) => x.id === p.id) || p
       await thenFn(fresh)
     },
@@ -445,7 +623,7 @@ async function ensureUnlocked (term, st, p, thenFn) {
 
 function moveSel (st, key, screen, count) {
   if (count <= 0) { st.sel[screen] = 0; return }
-  // Clampa el índice guardado ANTES de aplicar el delta: si la lista encogió, la
+  // Clampa el índice guardado ANTES de apply el delta: si la lista encogió, la
   // primera flecha debe moverse desde la posición visible, no desde un índice viejo.
   st.sel[screen] = Math.max(0, Math.min(st.sel[screen], count - 1))
   if (key.name === 'up') st.sel[screen] = Math.max(0, st.sel[screen] - 1)
@@ -474,27 +652,38 @@ async function onKeyProfiles (term, st, key) {
   if (key.name === 'enter' && cur) {
     // Entrar a la bóveda: la activa (si no lo estaba ya) y pasa a sus pestañas
     // (Dispositivos/Scopes) — así siempre es explícito de qué bóveda son los ítems.
-    if (!cur.current) {
-      const r = await guard(term, st, i.switchingVault, () => vc.useProfile(cur.id))
-      if (!r.ok) return true
-      flash(st, i.vaultNowActive(cur.name || cur.id))
+    //
+    // Y si tiene candado, se pide la contraseña AQUÍ, antes de enseñar nada: dentro se ven
+    // los aparatos, las variables y tus datos, que es justo lo que la contraseña tapa.
+    await ensureUnlocked(term, st, cur, async (p = cur) => {
+      if (!p.current) {
+        const r = await guard(term, st, i.switchingVault, () => vc.useProfile(p.id))
+        if (!r.ok) return
+        flash(st, i.vaultNowActive(p.name || p.id))
+      }
+      // ENTRAR RECARGA TODO, SIEMPRE. Antes solo se recargaba al CAMBIAR de bóveda, y lo
+      // que traía era `refreshDevices`: aparatos y acta, no las variables. Así que entrar a
+      // la bóveda que ya estaba activa —el caso normal cuando estaba cerrada y acabas de
+      // teclear la contraseña, que es cuando la memoria está vacía a propósito— dejaba
+      // Scopes en blanco hasta que alguien pulsara F5. Un volcado trae las tres cosas.
       await refreshAll(term, st)
-    }
-    st.screen = 'devices'
-    await refreshDevices(term, st)
+      st.screen = 'devices'
+    })
   } else if (ch === 'p' && cur) {
     // Emparejar SIN tener que entrar antes: `p` significa lo mismo aquí que en la
     // pestaña Dispositivos. Se activa la bóveda elegida (el QR sale de UNA, y las
     // acciones siguientes —aprobar, revocar— miran a la activa) y se abre la
     // pregunta de a qué cuenta entra el dispositivo.
-    if (!cur.current) {
-      const r = await guard(term, st, i.switchingVault, () => vc.useProfile(cur.id))
-      if (!r.ok) return true
-      await refreshAll(term, st)
-    }
-    st.sel.pairmode = 0
-    st.scroll.pairmode = { value: 0 }
-    st.screen = 'pairmode'
+    await ensureUnlocked(term, st, cur, async (p = cur) => {
+      if (!p.current) {
+        const r = await guard(term, st, i.switchingVault, () => vc.useProfile(p.id))
+        if (!r.ok) return
+        await refreshAll(term, st)
+      }
+      st.sel.pairmode = 0
+      st.scroll.pairmode = { value: 0 }
+      st.screen = 'pairmode'
+    })
   } else if (ch === 'n') {
     setInput(st, {
       label: i.newVaultLabel,
@@ -545,8 +734,10 @@ async function onKeyProfiles (term, st, key) {
           onSubmit: async (again) => {
             st.input = null
             if (again !== pwd) { flash(st, i.passwordMismatch, 'danger'); return }
-            const r = await guard(term, st, i.savingPassword, () => vc.setProfilePassword(p.id, pwd))
-            if (r.ok) { flash(st, i.passwordSaved); await refreshProfiles(term, st) }
+            const r = await guard(term, st, i.savingPassword, () => vc.setProfilePassword(p.id, pwd, st.sessionPwd?.get(p.id)))
+            // La nueva es la que vale para el resto de la sesión: guardar la vieja dejaría
+            // a la TUI reabriendo con una contraseña que ya no existe.
+            if (r.ok) { st.sessionPwd?.set(p.id, pwd); flash(st, i.passwordSaved); await refreshProfiles(term, st) }
           },
           onCancel: () => { st.input = null }
         })
@@ -556,8 +747,8 @@ async function onKeyProfiles (term, st, key) {
   } else if (ch === 'x' && cur) { // quitar contraseña
     if (!cur.protected) { flash(st, i.noPasswordSet, 'warn'); return true }
     await ensureUnlocked(term, st, cur, async (p = cur) => {
-      const r = await guard(term, st, i.removingPassword, () => vc.removeProfilePassword(p.id))
-      if (r.ok) { flash(st, i.passwordRemoved); await refreshProfiles(term, st) }
+      const r = await guard(term, st, i.removingPassword, () => vc.removeProfilePassword(p.id, st.sessionPwd?.get(p.id)))
+      if (r.ok) { st.sessionPwd?.delete(p.id); flash(st, i.passwordRemoved); await refreshProfiles(term, st) }
     })
   } else if (ch === 'u' && cur) {
     if (!cur.protected) { flash(st, i.noPasswordSet, 'warn'); return true }
@@ -566,7 +757,10 @@ async function onKeyProfiles (term, st, key) {
   } else if (ch === 'k' && cur) { // locK (antes `l`, que ahora es el idioma)
     if (!cur.protected) { flash(st, i.noPasswordSet, 'warn'); return true }
     const r = await guard(term, st, i.lockingVault, () => vc.lockProfile(cur.id))
-    if (r.ok) { flash(st, i.vaultLocked); await refreshProfiles(term, st) }
+    // Echar el candado a mano es DECIR que vuelva a hacer falta la contraseña: si la TUI
+    // se quedara con ella, la siguiente tecla la reabriría sola y el candado no cerraría
+    // nada.
+    if (r.ok) { st.sessionPwd?.delete(cur.id); st.unlockedHere?.delete(cur.id); flash(st, i.vaultLocked); await refreshProfiles(term, st) }
   }
   return true
 }
@@ -605,7 +799,7 @@ async function onKeyDevices (term, st, key) {
         st.confirm = null
         // Por `sub`: se le retiran TODOS los certificados, no solo el de esta fila.
         const r = await guard(term, st, i.revoking, () => vc.revokeDevice({ sub: cur.sub, nonce: cur.nonce }, activeId(st)))
-        if (r.ok) { flash(st, i.deviceRevoked(cur.deviceId)); st.devices = r.v; st.sel.devices = 0 }
+        if (r.ok) { flash(st, i.deviceRevoked(cur.deviceId)); applyDump(st, r.v); st.sel.devices = 0 }
       },
       onNo: () => { st.confirm = null }
     })
@@ -617,11 +811,11 @@ async function onKeyDevices (term, st, key) {
       label: i.renameDeviceLabel(cur.deviceId),
       hint: i.renameDeviceHint,
       value: cur.label || '',
-      onSubmit: async (valor) => {
-        const nombre = String(valor || '').trim()
-        if (!nombre) return
-        const r = await guard(term, st, i.renaming, () => vc.setDeviceLabel(cur.sub, nombre, activeId(st)))
-        if (r.ok) { st.devices = r.v; flash(st, i.deviceRenamed(nombre)) }
+      onSubmit: async (raw) => {
+        const name = String(raw || '').trim()
+        if (!name) return
+        const r = await guard(term, st, i.renaming, () => vc.setDeviceLabel(cur.sub, name, activeId(st)))
+        if (r.ok) { applyDump(st, r.v); flash(st, i.deviceRenamed(name)) }
       }
     })
   } else if (ch === 'c' && cur?.sub) {
@@ -629,16 +823,44 @@ async function onKeyDevices (term, st, key) {
     st.sel.caps = 0
     await refreshMembers(term, st)
     st.screen = 'caps'
+  } else if (ch === 'e' && cur?.sub) {
+    // Variables de ESTE aparato. Solo un servicio las lee (es el único que pide su
+    // bundle), así que a un teléfono se le dice que no y por qué, en vez de dejarle
+    // guardar configuración que no va a leer nadie.
+    if (!cur.cn) { flash(st, i.devVarsOnlyServices, 'warn'); return true }
+    st.varsFor = { pub: cur.sub, deviceId: cur.deviceId, label: cur.label || '', cn: cur.cn }
+    st.sel.devvars = 0
+    await refreshSecrets(term, st)
+    st.screen = 'devvars'
   } else if (key.name === 'f5') {
     await refreshDevices(term, st)
   }
   return true
 }
 
-/** Abre el emparejamiento contra `profile` y salta a la pantalla del QR. */
-async function beginPairing (term, st, profile) {
-  const r = await guard(term, st, L(st).startingPairing, () => vc.startPairing({ profile }))
-  if (r.ok) { st.pairing = r.v; st.pending = null; st.scroll.pairing = { value: 0 }; st.screen = 'pairing' }
+/**
+ * Tira la cuenta que NACIÓ para un emparejamiento que no llegó a término y vuelve a la que
+ * estabas usando. Es una cuenta recién creada y vacía —el aparato nunca entró—, así que no
+ * hay nada dentro que perder; lo que sí molesta es que se queden acumulando.
+ */
+async function descartarCuenta (term, st, id, volverA) {
+  const i = L(st)
+  const r = await guard(term, st, i.discardingAccount, () => vc.removeProfile(id))
+  if (volverA) await guard(term, st, i.switchingVault, () => vc.useProfile(volverA))
+  await refreshAll(term, st)
+  if (r.ok) flash(st, i.accountDiscarded)
+}
+
+/**
+ * Abre el emparejamiento contra `profile` y salta a la pantalla del QR. Con `service`,
+ * el QR es el de un SERVICIO de ese namespace (cert limitado a sus variables).
+ */
+async function beginPairing (term, st, profile, service = null) {
+  const r = await guard(term, st, L(st).startingPairing, () => vc.startPairing({ profile, ...(service ? { service } : {}) }))
+  // `service` se pega al estado porque el daemon no lo devuelve: la pantalla del QR
+  // tiene que poder decir qué se está entregando, que no es lo mismo un aparato tuyo
+  // que una máquina que solo va a leer la configuración del proxy.
+  if (r.ok) { st.pairing = { ...r.v, ...(service ? { service } : {}) }; st.pending = null; st.scroll.pairing = { value: 0 }; st.screen = 'pairing' }
   return r.ok
 }
 
@@ -659,27 +881,27 @@ async function onKeyCaps (term, st, key) {
   if (key.name === 'f5') { await refreshMembers(term, st); return true }
   if ((key.name !== 'enter' && ch !== ' ') || !cur) return true
 
-  const miembro = (st.members || []).find((m) => m.pub === st.capsFor?.pub)
-  if (!miembro) return true
-  const caps = new Set(miembro.caps || [])
-  const dando = !caps.has(cur.cap)
-  if (dando) caps.add(cur.cap); else caps.delete(cur.cap)
+  const member = (st.members || []).find((m) => m.pub === st.capsFor?.pub)
+  if (!member) return true
+  const caps = new Set(member.caps || [])
+  const giving = !caps.has(cur.cap)
+  if (giving) caps.add(cur.cap); else caps.delete(cur.cap)
 
-  const aplicar = async () => {
-    const r = await guard(term, st, i.applyingCaps, () => vc.setDeviceCaps(miembro.pub, [...caps], activeId(st)))
+  const apply = async () => {
+    const r = await guard(term, st, i.applyingCaps, () => vc.setDeviceCaps(member.pub, [...caps], activeId(st)))
     if (!r.ok) return
-    st.devices = r.v
+    applyDump(st, r.v)
     await refreshMembers(term, st)
-    flash(st, dando ? i.capGiven(i.capName[cur.cap]) : i.capTaken(i.capName[cur.cap]))
+    flash(st, giving ? i.capGiven(i.capName[cur.cap]) : i.capTaken(i.capName[cur.cap]))
   }
 
   // Administrar se PREGUNTA: es el permiso que deja a ese aparato admitir y expulsar
   // dispositivos sin pasar por aquí. Los otros tres se marcan y ya.
-  if (cur.cap === 'admin' && dando) {
-    setConfirm(st, { text: i.confirmAdmin(st.capsFor.deviceId), onYes: aplicar })
+  if (cur.cap === 'admin' && giving) {
+    setConfirm(st, { text: i.confirmAdmin(st.capsFor.deviceId), onYes: apply })
     return true
   }
-  await aplicar()
+  await apply()
   return true
 }
 
@@ -696,24 +918,48 @@ async function onKeyPairMode (term, st, key) {
 
   if (cur.mode === 'here') { await beginPairing(term, st, activeId(st)); return true }
 
+  // SERVICIO: entra a la cuenta activa, pero con un certificado que solo sirve para
+  // pedir las variables de SU namespace. El nombre del ns es el que luego pide el
+  // servicio al arrancar, así que se valida aquí con la misma regla que la CLI: un
+  // ns con mayúsculas o espacios se enrola igual y falla el día del despliegue.
+  if (cur.mode === 'service') {
+    setInput(st, {
+      label: i.serviceNsLabel,
+      hint: i.serviceNsHint,
+      onSubmit: async (raw) => {
+        st.input = null
+        const ns = String(raw || '').trim().toLowerCase()
+        if (!/^[a-z0-9-]{1,32}$/.test(ns)) { flash(st, i.serviceNsBad, 'danger'); return }
+        await beginPairing(term, st, activeId(st), ns)
+      },
+      onCancel: () => { st.input = null }
+    })
+    return true
+  }
+
   // Cuenta nueva: se crea aquí, se ACTIVA (así aprobar/rechazar y las listas miran
   // a la misma que el QR) y recién entonces se abre el emparejamiento contra ella.
   setInput(st, {
     label: i.newAccountLabel,
     hint: i.newAccountHint,
-    onSubmit: async (name) => {
+    onSubmit: async (raw) => {
       st.input = null
-      const nombre = name.trim()
-      if (!nombre) { flash(st, i.nameEmpty, 'danger'); return }
-      const r = await guard(term, st, i.creatingVault, () => vc.addProfile(nombre))
+      const name = raw.trim()
+      if (!name) { flash(st, i.nameEmpty, 'danger'); return }
+      const previa = activeId(st)
+      const r = await guard(term, st, i.creatingVault, () => vc.addProfile(name))
       if (!r.ok) return
-      const nuevo = r.v?.id || (r.v?.profiles || []).find((p) => p.name === nombre)?.id
-      if (!nuevo) { flash(st, i.errNoReply, 'danger'); return }
-      const u = await guard(term, st, i.switchingVault, () => vc.useProfile(nuevo))
+      const created = r.v?.id || (r.v?.profiles || []).find((p) => p.name === name)?.id
+      if (!created) { flash(st, i.errNoReply, 'danger'); return }
+      const u = await guard(term, st, i.switchingVault, () => vc.useProfile(created))
       if (!u.ok) return
       await refreshAll(term, st)
-      flash(st, i.accountCreated(nombre))
-      await beginPairing(term, st, nuevo)
+      flash(st, i.accountCreated(name))
+      // Si el emparejamiento no llega a abrirse, la cuenta que se creó PARA él se va con
+      // él: si no, cada intento fallido dejaba una cuenta vacía —y encima activa— que
+      // luego había que ir a borrar a mano adivinando cuál era.
+      if (!await beginPairing(term, st, created)) await descartarCuenta(term, st, created, previa)
+      else st.pairing.born = { id: created, from: previa }
     },
     onCancel: () => { st.input = null }
   })
@@ -729,7 +975,18 @@ function promptApprove (term, st) {
       st.input = null
       if (!code.trim()) { flash(st, i.codeMissing, 'danger'); return }
       const r = await guard(term, st, i.approving, () => vc.approvePending(code.trim(), activeId(st)))
-      if (r.ok) { flash(st, i.deviceApproved); st.devices = r.v; st.pending = null; st.screen = 'devices' }
+      if (r.ok) {
+        flash(st, i.deviceApproved)
+        st.pending = null
+        // El aparato entró: la cuenta que se creó para esto ya es de alguien, así que deja
+        // de estar en la lista de las que se descartan al salir.
+        st.pairing = null
+        st.screen = 'devices'
+        // Sin lista (el volcado se perdió): se pide otra vez. El aparato ya está dentro;
+        // lo único que falta es la foto, y esa se vuelve a pedir sin drama.
+        if (r.v) applyDump(st, r.v)
+        else await refreshDevices(term, st)
+      }
     },
     onCancel: () => { st.input = null }
   })
@@ -765,11 +1022,26 @@ async function onKeyPairing (term, st, key) {
     return true
   }
   if (ch === 'r') { // restart: reiniciar el emparejamiento
+    const born = st.pairing?.born
     const r = await guard(term, st, i.restartingPairing, () => vc.startPairing({ profile: activeId(st) }))
-    if (r.ok) { st.pairing = r.v; st.pending = null; st.scroll.pairing = { value: 0 } }
+    if (r.ok) { st.pairing = { ...r.v, ...(born ? { born } : {}) }; st.pending = null; st.scroll.pairing = { value: 0 } }
     return true
   }
-  if (key.name === 'escape' || ch === 'b') { st.screen = 'devices'; st.pairing = null; await refreshDevices(term, st) }
+  if (key.name === 'escape' || ch === 'b') {
+    // Te vas sin que nadie haya entrado, y la cuenta se creó PARA esto: se pregunta antes
+    // de dejarla ahí. Es la otra mitad del mismo descuido — con «cuenta nueva» era fácil
+    // acabar con tres cuentas vacías y ninguna forma de saber cuál era cuál.
+    const born = st.pairing?.born
+    if (born) {
+      setConfirm(st, {
+        text: i.confirmDiscardAccount,
+        onYes: async () => { st.confirm = null; st.pairing = null; st.screen = 'devices'; await descartarCuenta(term, st, born.id, born.from) },
+        onNo: async () => { st.confirm = null; st.pairing = null; st.screen = 'devices'; await refreshDevices(term, st) }
+      })
+      return true
+    }
+    st.screen = 'devices'; st.pairing = null; await refreshDevices(term, st)
+  }
   return true
 }
 
@@ -792,6 +1064,8 @@ async function onKeySecrets (term, st, key) {
 
   if (ch === 'n') {
     promptNewVariable(term, st)
+  } else if (ch === 'i') {
+    promptLoadScopeVars(term, st)
   } else if ((ch === 'x' || key.name === 'delete') && cur) {
     if (cur.key) {
       setConfirm(st, {
@@ -804,7 +1078,7 @@ async function onKeySecrets (term, st, key) {
         onNo: () => { st.confirm = null }
       })
     } else {
-      const count = (st.secrets?.[cur.ns] || []).length
+      const count = (st.secrets?.ns?.[cur.ns] || []).length
       setConfirm(st, {
         text: i.removeScopeConfirm(cur.ns, count),
         onYes: async () => {
@@ -815,38 +1089,234 @@ async function onKeySecrets (term, st, key) {
         onNo: () => { st.confirm = null }
       })
     }
+  } else if (ch === 'v' && cur?.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 (key.name === 'f5') {
     await refreshSecrets(term, st)
   }
   return true
 }
 
+/**
+ * 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.
+ */
+/**
+ * VER el valor de una variable. Es lo único que la contraseña guarda desde v5, y en la
+ * máquina de la bóveda no hay otro camino: la llave de este aparato vive en este mismo
+ * disco, así que si abriera sin frase una copia del disco abriría todo.
+ *
+ * Si el perfil no tiene contraseña se abre con la llave de la máquina y no se pregunta
+ * nada — pero se dice, para que no parezca una protección que no está puesta.
+ */
+async function revealValue (term, st, owner, key, isPublic) {
+  const i = L(st)
+  const p = activeProfile(st)
+  const mostrar = async (pwd) => {
+    const r = await guard(term, st, i.revealing, () => vc.revealSecret(owner, key, activeId(st), pwd))
+    if (r.ok) flash(st, i.revealed(key, r.v), 'ok')
+  }
+  if (isPublic) return mostrar(undefined)             // una pública no está cerrada
+  if (!p?.protected) { flash(st, i.revealNoPwd, 'warn'); return mostrar(undefined) }
+  const guardada = activePwd(st)
+  if (guardada) return mostrar(guardada)
+  setInput(st, {
+    label: i.revealAsk,
+    hint: i.revealHint,
+    mask: true,
+    onSubmit: async (pwd) => {
+      st.input = null
+      if (!pwd) return
+      await mostrar(pwd)
+    },
+    onCancel: () => { st.input = null }
+  })
+}
+
+async function toggleVisibility (term, st, wasPublic, apply) {
+  const i = L(st)
+  const run = async () => {
+    const r = await guard(term, st, i.changingVisibility, apply)
+    if (r.ok) { flash(st, wasPublic ? i.nowPrivate : i.nowPublic); st.secrets = r.v }
+  }
+  if (wasPublic) return run()
+  setConfirm(st, { text: i.makePublicConfirm, onYes: run, onNo: () => { st.confirm = null } })
+}
+
+/**
+ * Teclas de las variables de UN aparato: agregar y quitar. Nada más — el aparato ya se
+ * eligió en Dispositivos, y de ahí se vuelve con Esc.
+ */
+async function onKeyDevVars (term, st, key) {
+  const i = L(st)
+  const rows = devVarRows(st, term.t)
+  const sels = rows.filter((r) => r.sel).map((r) => r.meta)
+  moveSel(st, key, 'devvars', sels.length)
+  const cur = sels[Math.min(st.sel.devvars || 0, sels.length - 1)]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+  const target = st.varsFor
+
+  if (key.name === 'escape' || ch === 'b') {
+    st.screen = 'devices'; st.varsFor = null
+    await refreshDevices(term, st)
+    return true
+  }
+  if (key.name === 'f5') { await refreshSecrets(term, st); return true }
+  if (ch === 'n') { promptNewDeviceVariable(term, st); return true }
+  if (ch === 'i' && target) { promptLoadVars(term, st, { pub: target.pub, where: target.deviceId }); return true }
+  if (ch === 't' && cur && target) {
+    await toggleVisibility(term, st, cur.public, () => vc.setDeviceSecretVisibility(target.pub, cur.key, !cur.public, activeId(st), activePwd(st)))
+  } else if (ch === 'v' && cur?.key) {
+    await revealValue(term, st, `dev:${target.pub}`, cur.key, cur.public)
+    return true
+  }
+  if ((ch === 'x' || key.name === 'delete') && cur && target) {
+    setConfirm(st, {
+      text: i.removeDevVarConfirm(target.deviceId, cur.key),
+      onYes: async () => {
+        st.confirm = null
+        const r = await guard(term, st, i.removingVar, () => vc.deleteDeviceSecret(target.pub, cur.key, activeId(st)))
+        if (r.ok) { flash(st, i.varRemoved); st.secrets = r.v; st.sel.devvars = Math.max(0, st.sel.devvars - 1) }
+      },
+      onNo: () => { st.confirm = null }
+    })
+  }
+  return true
+}
+
+/**
+ * Al crear una variable se PREGUNTA si su valor puede salir de esta máquina. Se pregunta
+ * al crearla, y no después, porque es cuando quien la escribe sabe qué es: un puerto se
+ * puede enseñar, una llave de producción no. La respuesta por defecto —Enter, o `n`— es
+ * la privada.
+ */
+function askVisibility (term, st, done) {
+  const i = L(st)
+  setConfirm(st, {
+    text: i.newVarPublicAsk,
+    onYes: () => { st.confirm = null; done(true) },
+    onNo: () => { st.confirm = null; done(false) }
+  })
+}
+
+function promptNewDeviceVariable (term, st) {
+  const i = L(st)
+  const target = st.varsFor
+  if (!target) return
+  setInput(st, {
+    label: i.keyLabel(target.deviceId),
+    hint: i.keyHint,
+    onSubmit: (key) => {
+      const kv = key.trim()
+      if (!KEY_RE.test(kv)) { flash(st, i.keyInvalid, 'danger'); return }
+      st.input = null
+      setInput(st, {
+        label: i.valueLabel(target.deviceId, kv),
+        mask: true,
+        hint: i.valueHint,
+        onSubmit: async (value) => {
+          st.input = null
+          if (!value) { flash(st, i.valueEmpty, 'danger'); return }
+          askVisibility(term, st, async (isPublic) => {
+            const r = await guard(term, st, i.savingVar, () => vc.setDeviceSecret(target.pub, kv, value, activeId(st), isPublic))
+            if (r.ok) { flash(st, i.varSaved(target.deviceId, kv)); st.secrets = r.v }
+          })
+        },
+        onCancel: () => { st.input = null }
+      })
+    },
+    onCancel: () => { st.input = null }
+  })
+}
+
+/**
+ * CARGAR VARIAS DE UNA VEZ (tecla `i`, de *import*, la misma palabra que en el CLI).
+ *
+ * Guardar las variables de un servicio una por una es, para la bóveda, un cambio de
+ * configuración por variable: el servicio obedece el primero —sale y lo levanta su
+ * supervisor— y arranca con media configuración mientras se teclea el resto. Cargarlas
+ * juntas hace que se reinicie UNA vez, con todo puesto.
+ *
+ * Se acepta lo que se pueda escribir en una línea (`CLAVE=valor CLAVE2=valor2`) o la
+ * RUTA de un `.env`, que es como suele llegar la configuración de un servicio.
+ */
+function promptLoadVars (term, st, { ns = null, pub = null, where }) {
+  const i = L(st)
+  setInput(st, {
+    label: i.loadLabel(where),
+    hint: i.loadHint,
+    onSubmit: async (raw) => {
+      const text = raw.trim()
+      st.input = null
+      if (!text) return
+      let content = text
+      // Sin un `=` no es una lista de variables: es la ruta de un archivo.
+      if (!text.includes('=')) {
+        try { content = fs.readFileSync(text, 'utf8') } catch (_) { flash(st, i.loadNoFile(text), 'danger'); return }
+      }
+      const { items, errors } = parseEnvInput(content)
+      // Un archivo con un problema no se carga a medias: se dice qué línea y no se
+      // escribe nada. Media configuración aplicada es peor que ninguna.
+      if (errors.length) { flash(st, i.loadNothing + ' ' + i.envErr[errors[0].code](errors[0]), 'danger'); return }
+      askVisibility(term, st, async (isPublic) => {
+        const withVisibility = items.map((it) => ({ ...it, public: isPublic }))
+        const r = await guard(term, st, i.loadingVars, () => (pub
+          ? vc.applyDeviceSecrets(pub, withVisibility, activeId(st))
+          : vc.applySecrets(ns, withVisibility, activeId(st))))
+        if (r.ok) { flash(st, i.loadedVars(items.length, where)); st.secrets = r.v }
+      })
+    },
+    onCancel: () => { st.input = null }
+  })
+}
+
+/** Cargar varias en un SCOPE: primero cuál, luego el bloque. */
+function promptLoadScopeVars (term, st) {
+  const i = L(st)
+  const existing = Object.keys(st.secrets?.ns || {})
+  setInput(st, {
+    label: i.nsLabel,
+    hint: existing.length ? i.nsHintExisting(existing.join(', ')) : i.nsHint,
+    onSubmit: (ns) => {
+      const nsName = ns.trim()
+      if (!NS_RE.test(nsName)) { flash(st, i.nsInvalid, 'danger'); return }
+      st.input = null
+      promptLoadVars(term, st, { ns: nsName, where: nsName })
+    },
+    onCancel: () => { st.input = null }
+  })
+}
+
 function promptNewVariable (term, st) {
   const i = L(st)
-  const existing = Object.keys(st.secrets || {})
+  const existing = Object.keys(st.secrets?.ns || {})
   setInput(st, {
     label: i.nsLabel,
     hint: existing.length ? i.nsHintExisting(existing.join(', ')) : i.nsHint,
     onSubmit: (ns) => {
-      const nsv = ns.trim()
-      if (!NS_RE.test(nsv)) { flash(st, i.nsInvalid, 'danger'); promptNewVariable(term, st); return }
+      const nsName = ns.trim()
+      if (!NS_RE.test(nsName)) { flash(st, i.nsInvalid, 'danger'); promptNewVariable(term, st); return }
       st.input = null
       setInput(st, {
-        label: i.keyLabel(nsv),
+        label: i.keyLabel(nsName),
         hint: i.keyHint,
         onSubmit: (key) => {
           const kv = key.trim()
           if (!KEY_RE.test(kv)) { flash(st, i.keyInvalid, 'danger'); return }
           st.input = null
           setInput(st, {
-            label: i.valueLabel(nsv, kv),
+            label: i.valueLabel(nsName, kv),
             mask: true,
             hint: i.valueHint,
             onSubmit: async (value) => {
               st.input = null
               if (!value) { flash(st, i.valueEmpty, 'danger'); return }
-              const r = await guard(term, st, i.savingVar, () => vc.setSecret(nsv, kv, value, activeId(st)))
-              if (r.ok) { flash(st, i.varSaved(nsv, kv)); st.secrets = r.v }
+              askVisibility(term, st, async (isPublic) => {
+                const r = await guard(term, st, i.savingVar, () => vc.setSecret(nsName, kv, value, activeId(st), isPublic))
+                if (r.ok) { flash(st, i.varSaved(nsName, kv)); st.secrets = r.v }
+              })
             },
             onCancel: () => { st.input = null }
           })
@@ -900,13 +1370,20 @@ const helpSegs = (i, screen, st = {}) => {
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
     me: i.helpMe,
-    caps: i.helpCaps
+    caps: i.helpCaps,
+    devvars: i.helpDevVars
   }[screen] || []
   if (typeof segs !== 'function') return segs
+  // El aparato señalado ahora mismo: `e variables` solo tiene sentido en un servicio (es
+  // el único que las lee), y las filas seleccionables de la lista son justo los aparatos.
+  const devs = mergeMembersAndCerts(st.members, st.devices?.issued || [])
+  const cur = devs[Math.min(st.sel?.devices || 0, devs.length - 1)]
   return segs({
-    pendiente: !!st.pending,
-    hayAparatos: (st.devices?.issued || []).length > 0,
-    haySecretos: Object.keys(st.secrets || {}).length > 0
+    pending: !!st.pending,
+    hasDevices: (st.devices?.issued || []).length > 0,
+    isService: !!cur?.cn,
+    hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
+    hasVars: devVarsOf(st, st.varsFor?.pub).length > 0
   })
 }
 
@@ -914,7 +1391,8 @@ const title = (i, screen) => ({
   profiles: i.titleProfiles,
   pairing: i.titlePairing,
   pairmode: i.titlePairMode,
-  caps: i.titleCaps
+  caps: i.titleCaps,
+  devvars: i.titleDevVars
 })[screen] || ''
 
 /** Barra de pestañas horizontal (Dispositivos | Scopes y variables) de la bóveda entrada. */
@@ -937,6 +1415,9 @@ function pairingBody (st, t, cols, height) {
   const acct = info.profileName || ap?.name || info.profile || ap?.id || '—'
   const left = Math.max(0, Math.round((info.expiresAt - Date.now()) / 60000))
   lines.push(t.bold(i.pairAccount(acct, left)))
+  // Y si lo que se entrega es un SERVICIO, se dice: el papel que sale de este QR no
+  // firma ni ve el contenido, solo lee las variables de ese namespace.
+  if (info.service) lines.push(t.warn(i.pairService(info.service)))
   // QR: se dibuja siempre que quepa de ancho; si es más alto que la pantalla se
   // puede hacer scroll hacia arriba/abajo para verlo completo.
   let qr = ''
@@ -977,9 +1458,9 @@ function render (term, st) {
 
   const s = st.state
   const up = st.daemonUp
-  const ver = s?.version || 'dev'
+  const version = s?.version || 'dev'
   const daemonTxt = up ? i.daemonRunning : i.daemonStopped
-  lines[0] = t.bar(`dotrino-vault ${ver}   daemon: ${daemonTxt}   ${vc.vaultDir()}`, cols)
+  lines[0] = t.bar(`dotrino-vault ${version}   daemon: ${daemonTxt}   ${vc.vaultDir()}`, cols)
 
   const ap = activeProfile(st)
   const apTxt = ap ? `${t.accent('●')} ${t.bold(ap.name || i.noName)} ${lockGlyph(ap)} ${t.muted('· ' + (ap.fingerprint || '—'))}` : t.muted('—')
@@ -1001,6 +1482,7 @@ function render (term, st) {
   else if (st.screen === 'secrets') body = renderList(secretRows(st, t), st.sel.secrets, contentH, cols, t, scrollRef)
   else if (st.screen === 'me') body = renderList(meRows(st, t), -1, contentH, cols, t, scrollRef)
   else if (st.screen === 'caps') body = renderList(capsRows(st, t), st.sel.caps || 0, contentH, cols, t, scrollRef)
+  else if (st.screen === 'devvars') body = renderList(devVarRows(st, t), st.sel.devvars || 0, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairmode') body = renderList(pairModeRows(st, t), st.sel.pairmode, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
@@ -1086,7 +1568,13 @@ export async function runTui () {
   const st = {
     screen: 'profiles', // se arranca en la lista de bóvedas: hay que ENTRAR a una
     lang: loadLang(), // es/en — se conmuta con `l` y se recuerda en prefs.json
-    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0, devvars: 0 },
+    // Las bóvedas que ha abierto ESTA sesión, para volver a cerrarlas al salir.
+    unlockedHere: new Set(),
+    // Su contraseña, SOLO en memoria y SOLO mientras la TUI esté abierta: sirve para
+    // reabrir sin volver a preguntar si el daemon pierde el estado (ver
+    // `reunlockSilently`). Se olvida con `k`, al quitar la contraseña y al salir.
+    sessionPwd: new Map(),
     scroll: {},
     profiles: null,
     devices: null,
@@ -1155,13 +1643,21 @@ export async function runTui () {
       else if (st.screen === 'secrets') running = await onKeySecrets(term, st, key)
       else if (st.screen === 'me') running = await onKeyMe(term, st, key)
       else if (st.screen === 'caps') running = await onKeyCaps(term, st, key)
+      else if (st.screen === 'devvars') running = await onKeyDevVars(term, st, key)
       else if (st.screen === 'pairmode') running = await onKeyPairMode(term, st, key)
       else if (st.screen === 'pairing') running = await onKeyPairing(term, st, key)
     }
   } finally {
+    // AL SALIR SE VUELVE A CERRAR lo que se abrió aquí. Sin esto, teclear la contraseña una
+    // vez dejaba la bóveda abierta para todo el que pasara por esta máquina hasta el
+    // siguiente reinicio del servicio — un candado que solo se cierra reiniciando no es un
+    // candado. (Si la TUI muere de un tirón —kill, ventana cerrada— no hay quien lo haga:
+    // ahí el cierre lo pone el reinicio, como antes.)
+    st.sessionPwd.clear()
+    for (const id of st.unlockedHere) { try { await vc.lockProfile(id) } catch (_) {} }
     term.close()
   }
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, profileRows, deviceRows, secretRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }
+export const __test = { render, activeLocked, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }