@dotrino/vaultd 0.26.2 → 0.46.2

package/src/ctl.js

@@ -23,8 +23,11 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { execFileSync } from 'node:child_process'
+import tty from 'node:tty'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
+import { assertVar } from './secretsStore.js'
+import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
 import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 import { VERSION } from './version.js'
@@ -49,7 +52,18 @@ function takeProfileFlag (args) {
 }
 /** Campo `profile` de las peticiones al daemon (omitido = perfil activo). */
 const withProfile = (obj) => (PROFILE ? { ...obj, profile: PROFILE } : obj)
-const writeReq = (name, obj) => fs.writeFileSync(path.join(dir, name), JSON.stringify(withProfile({ ...obj, at: Date.now() })), { mode: 0o600 })
+/**
+ * Deja una petición para el daemon. ATÓMICA (escribir aparte y renombrar): el daemon
+ * vigila la carpeta con `fs.watch`, que avisa al CREAR el archivo y no al terminar de
+ * escribirlo, así que escrito en el sitio se puede leer a medias — y una petición que no
+ * parsea se pierde con todos sus datos.
+ */
+const writeReq = (name, obj) => {
+  const dest = path.join(dir, name)
+  const tmp = dest + '.tmp'
+  fs.writeFileSync(tmp, JSON.stringify(withProfile({ ...obj, at: Date.now() })), { mode: 0o600 })
+  fs.renameSync(tmp, dest)
+}
 
 const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
 // La versión se inyecta en build (esbuild --define); en dev cae a 'dev'.
@@ -60,13 +74,13 @@ const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
  * contenedor, así que decir siempre «systemctl» manda a la mitad de la gente a un
  * comando que no existe.
  */
-const EN_DOCKER = !!process.env.DOTRINO_IN_DOCKER
-const START_HINT = EN_DOCKER
+const IN_DOCKER = !!process.env.DOTRINO_IN_DOCKER
+const START_HINT = IN_DOCKER
   ? 'docker start dotrino-vault'
   : process.platform === 'linux'
     ? 'systemctl --user start dotrino-vault'
     : 'dotrino-vaultd   (o: npx -y @dotrino/vaultd)'
-const RESTART_HINT = EN_DOCKER
+const RESTART_HINT = IN_DOCKER
   ? 'docker restart dotrino-vault'
   : process.platform === 'linux'
     ? 'systemctl --user restart dotrino-vault'
@@ -88,7 +102,7 @@ function alive (pid) { try { return !!pid && (process.kill(pid, 0) || true) } ca
  * vigila la carpeta igualmente, así que la petición se atiende en cuanto se escribe el
  * archivo; la señal solo se ahorra la latencia del watcher.
  */
-function avisar (pid, sig) { try { process.kill(pid, sig) } catch (_) { /* Windows, o el daemon ya se enteró */ } }
+function sendSignal (pid, sig) { try { process.kill(pid, sig) } catch (_) { /* Windows, o el daemon ya se enteró */ } }
 function sleep (ms) { return new Promise((r) => setTimeout(r, ms)) }
 function requireDaemon () {
   const s = readState()
@@ -138,6 +152,20 @@ function showChallenge (pe) {
   console.log('  Si no reconoces este dispositivo:  dotrino-vault reject %s\n', pe.deviceId)
 }
 
+/**
+ * EL CANDADO. Un perfil con contraseña y bloqueado no se ve ni se toca desde esta consola:
+ * el daemon contesta `locked` y sin contenido, y aquí se corta con un mensaje que dice qué
+ * hacer. Los aparatos ya emparejados siguen atendidos — lo que está cerrado es esta
+ * pantalla, no la bóveda.
+ */
+function assertOpen (d) {
+  if (d?.locked) {
+    console.error('Perfil bloqueado. Ábrelo con:  dotrino-vault unlock')
+    process.exit(1)
+  }
+  return d
+}
+
 async function cmdPair (args = []) {
   const s = requireDaemon()
   try { fs.rmSync(pairFile, { force: true }) } catch (_) {}
@@ -152,6 +180,30 @@ async function cmdPair (args = []) {
       console.error('uso: dotrino-vault pair --service <ns>   (ns en minúsculas, p.ej. proxy)'); process.exit(2)
     }
   }
+  // --scope <lista>: los PERMISOS del cert, y nada más. No hay tipos de aparato
+  // (2026-08-22, dueño): un aparato es un aparato y lo que puede hacer. Sin --scope,
+  // el juego de siempre (sign,read,store); `--service <ns>` es el atajo de
+  // `secrets:<ns>`, y los dos se combinan (`--service eco --scope sign` = un bot que
+  // firma como aparato del acta y lee solo su cajón). `admin` no se empareja: se
+  // concede desde el PC (`caps <ID> +administra`).
+  const scIdx = args.indexOf('--scope')
+  let scope = null
+  if (scIdx >= 0) {
+    const raw = args[scIdx + 1]
+    if (!raw || raw.startsWith('-')) { console.error('uso: dotrino-vault pair --scope sign,read,store,secrets:<ns>'); process.exit(2) }
+    const ALIAS = { firma: 'sign', lee: 'read', guarda: 'store' }
+    scope = []
+    for (const tok of raw.split(',').map((t) => t.trim()).filter(Boolean)) {
+      const t = ALIAS[tok] || tok
+      if (t === 'admin' || t === 'administra') { console.error('`admin` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +administra'); process.exit(2) }
+      if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
+      const m = /^secrets:([a-z0-9-]{1,32})$/.exec(t)
+      if (m) { scope.push('vault:secrets:' + m[1]); continue }
+      console.error('permiso desconocido: %s  (sign | read | store | secrets:<ns>)', tok); process.exit(2)
+    }
+    if (service) scope.push('vault:secrets:' + service)
+    scope = [...new Set(scope)]
+  }
   // `--new-account [nombre]`: la otra respuesta a «¿a qué cuenta entra?». En vez de
   // meter el dispositivo en una cuenta que ya vive aquí, se ESTRENA una (vacía) y
   // entra a ella; las demás no se tocan. En la TUI esto es una pregunta con sus
@@ -183,11 +235,16 @@ async function cmdPair (args = []) {
   }
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
-  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
-  avisar(s.pid, 'SIGUSR1')
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(scope ? { scope } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
+  sendSignal(s.pid, 'SIGUSR1')
 
   let pair = null
-  for (let i = 0; i < 50; i++) { await sleep(100); const p = readJson(pairFile, null); if (p?.expiresAt > Date.now()) { pair = p; break } }
+  for (let i = 0; i < 50; i++) {
+    await sleep(100)
+    const p = readJson(pairFile, null)
+    assertOpen(p) // el candado se contesta por el mismo archivo, para no dejar esperando
+    if (p?.expiresAt > Date.now()) { pair = p; break }
+  }
   if (!pair) { console.error('No se recibió respuesta del daemon para el emparejamiento.'); process.exit(1) }
 
   // Una sola forma para las dos cosas: la invitación compacta (base64url de ~100
@@ -237,7 +294,7 @@ function cmdApprove (code) {
   if (!code) { console.error('uso: dotrino-vault approve <código>   (los dígitos que muestra el dispositivo)'); process.exit(2) }
   const s = requireDaemon()
   writeReq('approve-request.json', { code: String(code) })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Aprobando con el código %s… verifica con: dotrino-vault devices', code)
 }
 
@@ -245,7 +302,7 @@ function cmdReject (deviceId) {
   if (!deviceId) { console.error('uso: dotrino-vault reject <deviceId>'); process.exit(2) }
   const s = requireDaemon()
   writeReq('reject-request.json', { deviceId })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Rechazado %s.', deviceId)
 }
 
@@ -265,12 +322,13 @@ async function cmdMe () {
   const meFile = path.join(dir, 'me.json')
   try { fs.rmSync(meFile, { force: true }) } catch (_) {}
   writeReq('me-request.json', {})
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   let dump = null
   for (let n = 0; n < 50; n++) { await sleep(100); const d = readJson(meFile, null); if (d?.at) { dump = d; break } }
   // El volcado es contenido del usuario: se lee y se BORRA, no se queda ahí suelto.
   try { fs.rmSync(meFile, { force: true }) } catch (_) {}
   if (!dump) { console.error('La bóveda no respondió. ¿Está corriendo?  dotrino-vault status'); process.exit(1) }
+  assertOpen(dump)
 
   const me = dump.me
   if (!me) {
@@ -279,8 +337,8 @@ async function cmdMe () {
     return
   }
 
-  const cuando = me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—'
-  console.log('\n%sPerfil%s · actualizado %s\n', B, Z, cuando)
+  const when = me.updatedAt ? new Date(me.updatedAt).toLocaleString() : '—'
+  console.log('\n%sPerfil%s · actualizado %s\n', B, Z, when)
   console.log('  nombre      : %s', me.nickname || '(sin nombre)')
   console.log('  foto        : %s', me.avatar
     ? `sí · ${me.avatar.type || 'desconocido'} · ${(me.avatar.bytes / 1024).toFixed(1)} KB`
@@ -289,17 +347,17 @@ async function cmdMe () {
   // Los campos estándar. `visible` es del usuario: teléfono y dirección nacen ocultos.
   const STD = [['nombres', 'nombres'], ['apellidos', 'apellidos'], ['email', 'correo'],
     ['telefono', 'teléfono'], ['direccion', 'dirección']]
-  const puestos = STD.filter(([k]) => me[k])
-  if (puestos.length) {
+  const filled = STD.filter(([k]) => me[k])
+  if (filled.length) {
     console.log('')
-    for (const [k, etiqueta] of puestos) {
-      console.log('  %s: %s%s', etiqueta.padEnd(12), me[k], me[k + 'Visible'] === false ? '   (oculto)' : '')
+    for (const [k, label] of filled) {
+      console.log('  %s: %s%s', label.padEnd(12), me[k], me[k + 'Visible'] === false ? '   (oculto)' : '')
     }
   }
-  for (const [titulo, lista] of [['Enlaces', me.links], ['Otros datos', me.fields]]) {
-    if (!Array.isArray(lista) || !lista.length) continue
-    console.log('\n  %s:', titulo)
-    for (const x of lista) console.log('    %s %s%s', (x.type || x.label || '').padEnd(12), x.value, x.visible === false ? '   (oculto)' : '')
+  for (const [title, list] of [['Enlaces', me.links], ['Otros datos', me.fields]]) {
+    if (!Array.isArray(list) || !list.length) continue
+    console.log('\n  %s:', title)
+    for (const x of list) console.log('    %s %s%s', (x.type || x.label || '').padEnd(12), x.value, x.visible === false ? '   (oculto)' : '')
   }
 
   console.log('')
@@ -311,30 +369,35 @@ async function cmdMe () {
  */
 async function cmdMembers () {
   const s = requireDaemon()
-  const actaFile = path.join(dataDir(), 'acta.json')
-  try { fs.rmSync(actaFile, { force: true }) } catch (_) {}
+  const recordFile = path.join(dataDir(), 'acta.json')
+  try { fs.rmSync(recordFile, { force: true }) } catch (_) {}
   writeReq('dump-request.json', {})
-  avisar(s.pid, 'SIGUSR2')
-  let acta = null
-  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(actaFile, null); if (a?.at) { acta = a; break } }
-  if (!acta) { console.error('El daemon no respondió.'); process.exit(1) }
-  if (!acta.members?.length) { console.log('Este perfil todavía no tiene acta.'); return }
+  sendSignal(s.pid, 'SIGUSR2')
+  let record = null
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(recordFile, null); if (a?.at) { record = a; break } }
+  if (!record) { console.error('El daemon no respondió.'); process.exit(1) }
+  assertOpen(record)
+  if (!record.members?.length) { console.log('Este perfil todavía no tiene acta.'); return }
 
   const CAP = { sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves', admin: `${B}administra el perfil${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
   // misma que se enseña al emparejar y en la lista de miembros.
-  const perfilId = await deviceIdOf(acta.profileId).catch(() => '????-????')
-  console.log('\n%sPerfil%s %s · acta #%d\n', B, Z, perfilId, acta.seq)
-  for (const m of acta.members) {
-    const quien = m.label || m.id
-    const marcas = [
+  const profileId = await deviceIdOf(record.profileId).catch(() => '????-????')
+  console.log('\n%sPerfil%s %s · acta #%d\n', B, Z, profileId, record.seq)
+  for (const m of record.members) {
+    const who = m.label || m.id
+    const marks = [
       m.isMaster ? `${B}Master${Z}` : null,
       m.isMe ? 'este dispositivo' : null,
       m.cn ? `servicio «${m.cn}»` : null
     ].filter(Boolean)
     const caps = m.caps.length ? m.caps.map((c) => CAP[c] || c).join(', ') : '(sin permisos)'
-    console.log('  %s  %s%s\n      %s', m.id, quien, marcas.length ? '  [' + marcas.join(' · ') + ']' : '', caps)
+    console.log('  %s  %s%s\n      %s', m.id, who, marks.length ? '  [' + marks.join(' · ') + ']' : '', caps)
+    // Un servicio SIN llave de cifrado no puede leer ninguna variable privada: van
+    // selladas a esa llave. Se dice aquí, junto a él, porque es el único sitio donde
+    // 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')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
@@ -350,55 +413,56 @@ async function cmdMembers () {
  * tener que revocar y volver a emparejar.
  */
 async function cmdLabel (args = []) {
-  const [id, ...resto] = args
-  const nombre = resto.join(' ').trim()
-  if (!id || !nombre) {
+  const [id, ...rest] = args
+  const name = rest.join(' ').trim()
+  if (!id || !name) {
     console.error('uso: dotrino-vault label <ID> <nombre>   (p.ej. label AB12-CD34 "Teléfono de casa")')
     process.exit(2)
   }
-  const m = await buscarMiembro(id)
-  writeReq('label-request.json', { pub: m.pub, label: nombre })
-  avisar(requireDaemon().pid, 'SIGUSR2')
-  console.log('Listo: %s ahora se llama «%s». Compruébalo con: dotrino-vault members', m.id, nombre.slice(0, 60))
+  const m = await findMember(id)
+  writeReq('label-request.json', { pub: m.pub, label: name })
+  sendSignal(requireDaemon().pid, 'SIGUSR2')
+  console.log('Listo: %s ahora se llama «%s». Compruébalo con: dotrino-vault members', m.id, name.slice(0, 60))
 }
 
 /** Busca un miembro del acta por su identificador (AB12-CD34) o se rinde con un mensaje claro. */
-async function buscarMiembro (id) {
+async function findMember (id) {
   const s = requireDaemon()
-  const actaFile = path.join(dataDir(), 'acta.json')
-  try { fs.rmSync(actaFile, { force: true }) } catch (_) {}
+  const recordFile = path.join(dataDir(), 'acta.json')
+  try { fs.rmSync(recordFile, { force: true }) } catch (_) {}
   writeReq('dump-request.json', {})
-  avisar(s.pid, 'SIGUSR2')
-  let acta = null
-  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(actaFile, null); if (a?.at) { acta = a; break } }
-  const m = acta?.members?.find((x) => x.id === String(id).toUpperCase())
+  sendSignal(s.pid, 'SIGUSR2')
+  let record = null
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = readJson(recordFile, null); if (a?.at) { record = a; break } }
+  assertOpen(record)
+  const m = record?.members?.find((x) => x.id === String(id).toUpperCase())
   if (!m) { console.error('No hay ningún dispositivo con ese identificador. Míralos con: dotrino-vault members'); process.exit(1) }
   return m
 }
 
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
-  const [id, ...cambios] = args
-  if (!id || !cambios.length) {
+  const [id, ...changes] = args
+  if (!id || !changes.length) {
     console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra')
     process.exit(2)
   }
-  const NOMBRE = {
+  const CAP_BY_WORD = {
     firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin',
     sign: 'sign', store: 'store', read: 'read', admin: 'admin'
   }
   const s = requireDaemon()
-  const m = await buscarMiembro(id)
+  const m = await findMember(id)
 
   const caps = new Set(m.caps)
-  for (const c of cambios) {
-    const signo = c[0]
-    const cap = NOMBRE[c.slice(1).toLowerCase()]
-    if (!cap || (signo !== '+' && signo !== '-')) { console.error('permiso no reconocido: %s', c); process.exit(2) }
-    if (signo === '+') caps.add(cap); else caps.delete(cap)
+  for (const c of changes) {
+    const sign = c[0]
+    const cap = CAP_BY_WORD[c.slice(1).toLowerCase()]
+    if (!cap || (sign !== '+' && sign !== '-')) { console.error('permiso no reconocido: %s', c); process.exit(2) }
+    if (sign === '+') caps.add(cap); else caps.delete(cap)
   }
   writeReq('caps-request.json', { pub: m.pub, caps: [...caps] })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Listo. Compruébalo con: dotrino-vault members')
 }
 
@@ -406,25 +470,26 @@ async function cmdDevices () {
   const s = requireDaemon()
   try { fs.rmSync(devFile, { force: true }) } catch (_) {}
   writeReq('dump-request.json', {}) // de qué perfil queremos los dispositivos
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   let snap = null
   for (let i = 0; i < 50; i++) { await sleep(100); const d = readJson(devFile, null); if (d?.at) { snap = d; break } }
   if (!snap) { console.error('El daemon no respondió.'); process.exit(1) }
+  assertOpen(snap)
   const revoked = snap.revoked || []
-  const fuera = new Set(revoked.map((r) => r?.nonce || r))
+  const revokedSet = new Set(revoked.map((r) => r?.nonce || r))
   // UN APARATO, UNA LÍNEA. El daemon lleva la cuenta por CERTIFICADO —correcto para él,
   // porque revocar es revocar un papel—, pero renovar emite uno nuevo cada 30 días: un
   // aparato de un año salía doce veces, y los ya retirados seguían contando como
   // enrolados. Se agrupa por llave y se dice cuántos certificados tiene.
-  const porLlave = new Map()
+  const byKey = new Map()
   for (const d of (snap.issued || snap.active || snap.delegations || [])) {
-    if (d.revokedAt || fuera.has(d.nonce)) continue
-    const clave = d.sub || d.nonce
-    const y = porLlave.get(clave)
-    if (!y) porLlave.set(clave, { ...d, certs: 1 })
+    if (d.revokedAt || revokedSet.has(d.nonce)) continue
+    const key = d.sub || d.nonce
+    const y = byKey.get(key)
+    if (!y) byKey.set(key, { ...d, certs: 1 })
     else { y.certs++; if ((d.exp || 0) > (y.exp || 0)) Object.assign(y, { ...d, certs: y.certs }) }
   }
-  const active = [...porLlave.values()]
+  const active = [...byKey.values()]
   console.log('Dispositivos enrolados: %d', active.length)
   for (const d of active) {
     const did = d.sub ? await deviceIdOf(d.sub) : '????-????'
@@ -454,14 +519,14 @@ async function cmdRevoke (arg) {
   const esId = /^[0-9a-f]{4}-?[0-9a-f]{4}$/i.test(arg)
   const s = requireDaemon()
   if (esId) {
-    const m = await buscarMiembro(arg.toUpperCase().includes('-') ? arg.toUpperCase() : arg.toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
+    const m = await findMember(arg.toUpperCase().includes('-') ? arg.toUpperCase() : arg.toUpperCase().replace(/(.{4})(.{4})/, '$1-$2'))
     writeReq('revoke-request.json', { sub: m.pub })
-    avisar(s.pid, 'SIGUSR2')
+    sendSignal(s.pid, 'SIGUSR2')
     console.log('Quitado %s (todos sus certificados). Se autoborrará al reconectar. Verifica: dotrino-vault devices', m.id)
     return
   }
   writeReq('revoke-request.json', { nonce: arg })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   console.log('Revocación enviada para nonce=%s. El dispositivo se autoborrará al reconectar. Verifica: dotrino-vault devices', arg)
 }
 
@@ -478,6 +543,10 @@ function profileDir () {
     ? list.find((x) => x.id === PROFILE || (x.name || '').toLowerCase() === ref)
     : (list.find((x) => x.current) || list[0])
   if (!p) { console.error('el perfil no existe: %s', PROFILE); process.exit(1) }
+  // El candado también aquí: esto es la única puerta que lee el directorio del perfil sin
+  // pasar por el daemon (la bitácora), y sin esta línea `activity` seguía contando quién
+  // firmó y cuándo con la bóveda cerrada.
+  assertOpen(p)
   return path.join(dir, 'p', p.id)
 }
 
@@ -500,43 +569,445 @@ function cmdActivity (n = 30) {
   }
 }
 
-// Secretos de servicios: se cargan aquí (el dueño, en el PC del vault) y los
-// leen los SERVICIOS enrolados con `pair --service <ns>`. Nunca se listan valores.
+// Variables de entorno de los servicios: se cargan aquí (el dueño, en el PC del vault) y
+// las leen los SERVICIOS enrolados con `pair --service <ns>`. Nunca se listan valores.
+//
+// DOS CAJONES: las del SCOPE (`secret set <ns> …`) las comparten todos los aparatos que
+// sirven ese namespace; las del APARATO (`secret device set <ID> …`) las lee solo ese
+// aparato y PISAN a las del scope con el mismo nombre. Ahí va lo que cambia de máquina a
+// máquina (el puerto, la URL pública) sin tener que partir el ns en uno por servidor.
+/**
+ * `KEY=valor KEY2=valor2` — la forma de CARGAR VARIAS de una vez. Devuelve `null` si no
+ * son todos pares, para que la forma clásica de tres argumentos (`set ns CLAVE valor`,
+ * donde el valor puede llevar espacios y hasta un `=`) siga funcionando igual.
+ */
+function asPairs (args) {
+  if (!args.length) return null
+  const out = []
+  for (const a of args) {
+    const m = PAIR_RE.exec(a)
+    if (!m) return null
+    out.push({ op: 'set', key: m[1], value: m[2] })
+  }
+  return out
+}
+
+/** Un `.env` con un problema no se carga A MEDIAS: se dice qué línea y no se escribe nada. */
+function abortEnv (errors) {
+  console.error('%sNo se cargó nada%s:', R, Z)
+  for (const e of errors) console.error('  · %s', envErrorText(e))
+  process.exit(2)
+}
+
+/** Los códigos del lector de `.env`, en la lengua del CLI. */
+function envErrorText (e) {
+  if (e.code === 'shape') return `línea ${e.line}: no tiene la forma CLAVE=valor`
+  if (e.code === 'key') return `línea ${e.line}: «${e.key}» va en MAYÚSCULAS_CON_GUION_BAJO`
+  if (e.code === 'novalue') return `línea ${e.line}: ${e.key} no tiene valor (para quitarla: secret rm)`
+  if (e.code === 'dup') return `línea ${e.line}: ${e.key} ya venía en la línea ${e.first}`
+  return 'no hay ninguna variable que cargar'
+}
+
+/** El problema de una variable, en español, o `null`. Las reglas son las del cajón. */
+function problemWith (key, value) {
+  try { assertVar(key, value); return null } catch (e) {
+    if (/invalid key/.test(e.message)) return 'el nombre va en MAYÚSCULAS_CON_GUION_BAJO (p. ej. TURN_KEY_ID)'
+    if (/non-empty/.test(e.message)) return 'no tiene valor (para quitarla: secret rm)'
+    if (/too long/.test(e.message)) return 'el valor es demasiado largo'
+    return e.message
+  }
+}
+
 async function cmdSecret (rest) {
-  const [sub, ns, key, ...valueParts] = rest
+  // --public / --private: si el VALOR puede salir de esta máquina hacia la consola remota.
+  // Se sacan de la línea antes de partirla, para que puedan ir en cualquier posición y no
+  // se cuelen dentro del valor (que es lo último y puede llevar espacios).
+  let isPublic
+  const rest2 = rest.filter((a) => {
+    if (a === '--public') { isPublic = true; return false }
+    if (a === '--private') { isPublic = false; return false }
+    return true
+  })
+  const [sub, ...args] = rest2
   const s = requireDaemon()
+
+  /**
+   * La contraseña del perfil, y SOLO si el perfil la tiene.
+   *
+   * Desde v5 la piden únicamente las operaciones que **LEEN** un valor: verlo, cambiarle
+   * la visibilidad (para enseñarlo hay que sacarlo), convertir el archivo y saldar lo que
+   * quedó a deber. **Guardar no la pide**: sellar solo necesita las públicas de quien va
+   * a leer (`docs/secretos-sellados.md` §8.1). Borrar tampoco, porque tirar un sobre no
+   * obliga a abrirlo.
+   */
+  let cachedPwd
+  const adminPassword = async () => {
+    if (cachedPwd !== undefined) return cachedPwd
+    const d = await profileRequest('list')
+    const list = Array.isArray(d.profiles) ? d.profiles : []
+    const p = PROFILE
+      ? list.find((x) => x.id === PROFILE || x.name === PROFILE)
+      : (list.find((x) => x.current) || list[0])
+    if (!p?.protected) { cachedPwd = null; return null }
+    // Nunca por argumento: quedaría en `ps` y en el historial de la shell. Si no hay
+    // terminal se dice qué falta, en vez de fallar con «el daemon no aplicó el cambio».
+    let pwd
+    try { pwd = await askPassword('Contraseña del perfil: ') } catch (_) {
+      console.error('Este perfil tiene contraseña y hace falta para guardar una variable.')
+      console.error('Ejecútalo desde un terminal (por ssh, con -t).')
+      process.exit(1)
+    }
+    if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+    cachedPwd = pwd
+    return pwd
+  }
   const secretsListFile = path.join(dir, 'secrets-list.json')
   const signalAndWaitList = async () => {
     try { fs.rmSync(secretsListFile, { force: true }) } catch (_) {}
     writeReq('dump-request.json', {}) // de qué perfil son los secretos
-    avisar(s.pid, 'SIGUSR2')
-    for (let i = 0; i < 50; i++) { await sleep(100); const d = readJson(secretsListFile, null); if (d?.at) return d }
+    sendSignal(s.pid, 'SIGUSR2')
+    for (let i = 0; i < 50; i++) {
+      await sleep(100)
+      const d = readJson(secretsListFile, null)
+      // El volcado lleva el valor de las públicas: se borra en cuanto se tiene, para que no
+      // se quede esperando en el disco a que copien la carpeta (ver `daemon.js`).
+      if (d?.at) { try { fs.rmSync(secretsListFile, { force: true }) } catch (_) {} ; return assertOpen(d) }
+    }
     console.error('El daemon no respondió.'); process.exit(1)
   }
+  /**
+   * SELLA el almacén: pasa un `secrets.json` v3 (valores que esta bóveda puede leer) a
+   * v4 (cada privada cifrada a la llave de su destinatario). Corre UNA vez.
+   *
+   * Es una operación con nombre propio y no un efecto de desbloquear, porque es el
+   * punto de no retorno: a partir de aquí la contraseña es lo ÚNICO que puede
+   * re-sellar, y perderla impide rotar una variable o sumar un aparato al namespace.
+   * Deja `secrets.json.v3.bak` al lado para poder volver.
+   */
+  async function secretMigrate () {
+    console.log('Esto SELLA las variables privadas a la llave de cada aparato.')
+    console.log('A partir de aquí, esta contraseña es lo único que puede volver a sellarlas:')
+    console.log('si la pierdes no podrás rotar una variable ni sumar un aparato al namespace.')
+    console.log('Se deja una copia en secrets.json.v3.bak por si hay que volver.\n')
+    const pwd = await askPassword('Contraseña del perfil: ')
+    if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+    writeReq('secret-request.json', { op: 'migrate', password: pwd })
+    console.log('\nPedido enviado. Mira el resultado con:  journalctl --user -u dotrino-vault -n 20')
+  }
+
+  const USAGE = [
+    'uso: dotrino-vault secret set <ns> <CLAVE> <valor> [--public|--private]',
+    '                                                  (la comparten todos los aparatos del ns)',
+    '     dotrino-vault secret set <ns> CLAVE=valor [CLAVE2=valor2 …]   varias DE UNA VEZ',
+    '     dotrino-vault secret import <ns> [archivo.env]               desde un .env (o stdin)',
+    '     dotrino-vault secret rm  <ns> <CLAVE>',
+    '     dotrino-vault secret device set <ID> <CLAVE> <valor> [--public|--private]',
+    '                                                  (solo la lee ese aparato, y pisa a la del ns)',
+    '     dotrino-vault secret device set <ID> CLAVE=valor [CLAVE2=valor2 …]',
+    '     dotrino-vault secret device import <ID> [archivo.env]',
+    '     dotrino-vault secret device rm  <ID> <CLAVE>',
+    '     dotrino-vault secret list',
+    '     dotrino-vault secret migrate                                 SELLA los secretos (una vez)',
+    '',
+    'CARGA LA CONFIGURACIÓN DE UN SERVICIO DE UNA VEZ (`set` con varios pares, o `import`):',
+    'la bóveda la aplica entera y avisa UNA sola vez. De una en una, cada variable es un',
+    'cambio de configuración y el servicio se reinicia a media carga.',
+    '',
+    'Pública o privada dice UNA cosa: si el VALOR puede salir de esta máquina hacia la',
+    'consola remota (vault.dotrino.com). Se nace privada. El servicio recibe las dos igual.'
+  ].join('\n')
+
+  /**
+   * Manda un grupo entero al daemon y comprueba que llegó completo.
+   *
+   * Se valida TODO aquí antes de escribir nada: si una variable del archivo está mal, no
+   * se carga ninguna. Media configuración aplicada es peor que ninguna, porque el
+   * servicio arranca con ella y parece que funcionó.
+   */
+  const sendBatch = async ({ ns = null, pub = null, items, where }) => {
+    const bad = items.map((it) => [it.key, problemWith(it.key, it.value)]).filter(([, p]) => p)
+    if (bad.length) {
+      console.error('%sNo se cargó nada%s. Revisa:', R, Z)
+      for (const [key, p] of bad) console.error('  · %s: %s', key, p)
+      process.exit(2)
+    }
+    const withVisibility = items.map((it) => (isPublic === undefined ? it : { ...it, public: isPublic }))
+    // Guardar NO pide la contraseña (§8.1).
+    const base = pub ? { op: 'batch', pub, items: withVisibility } : { op: 'batch', ns, items: withVisibility }
+    writeReq('secret-request.json', base)
+    const d = await signalAndWaitList()
+    const list = pub
+      ? ((Array.isArray(d.dev) ? d.dev : []).find((x) => x.pub === pub)?.keys || [])
+      : (d.ns?.[ns] || [])
+    const missing = items.filter((it) => !has(list, it.key)).map((it) => it.key)
+    if (missing.length) {
+      if (d?.secretError) return noSeAplico(d)
+      console.error('El daemon no guardó: %s (revisa: dotrino-vault logs)', missing.join(', '))
+      process.exit(1)
+    }
+    console.log('%d variables guardadas en %s%s%s%s', items.length, B, where, Z,
+      isPublic === undefined ? '' : isPublic ? '   (públicas)' : '   (privadas)')
+    console.log('Un solo aviso de cambio: el servicio se reinicia una vez, con todo puesto.')
+  }
+
+  /** El texto del `.env`: de un archivo, o de la entrada estándar si no se da ninguno. */
+  const readEnvText = (file) => {
+    if (file) {
+      try { return fs.readFileSync(file, 'utf8') } catch (e) {
+        console.error('No se pudo leer %s: %s', file, e.message); process.exit(1)
+      }
+    }
+    if (process.stdin.isTTY) {
+      console.error('%s\n\nimport necesita un archivo, o el .env por la entrada estándar:', USAGE)
+      console.error('  dotrino-vault secret import proxy .env')
+      console.error('  cat .env | dotrino-vault secret import proxy')
+      process.exit(2)
+    }
+    return fs.readFileSync(0, 'utf8')
+  }
+
+  /**
+   * Una variable en la lista: su nombre y su valor. La PÚBLICA enseña el suyo (pública
+   * quiere decir que ese valor puede salir de esta máquina: taparlo aquí, delante de su
+   * dueño, era lo único que la marca no significaba). La privada no se muestra.
+   */
+  const printVar = (k) => console.log('  · %s   %s', k.key, k.public ? `${k.value ?? ''}   (pública)` : '••••••')
+  /**
+   * Por qué no se aplicó. El daemon deja el motivo en el volcado siguiente; sin él lo
+   * único que se podía decir era «revisa los logs», que no ayuda a quien acaba de
+   * escribir mal la contraseña.
+   */
+  const noSeAplico = (d) => {
+    if (d?.secretError?.code === 'WRONG_PASSWORD') console.error('Contraseña incorrecta.')
+    else if (d?.secretError?.error) console.error('No se aplicó: %s', d.secretError.error)
+    else console.error('El daemon no aplicó el cambio (revisa: dotrino-vault logs)')
+    process.exit(1)
+  }
+  const has = (list, key) => (list || []).some((x) => x.key === key)
+  /**
+   * Los cajones que quedaron a deber un sellado. Sale ARRIBA del todo en rojo porque no
+   * es un detalle: mientras esté ahí, los aparatos de ese cajón NO están leyendo sus
+   * variables, y la bóveda no puede arreglarlo sola — necesita la contraseña.
+   */
+  /**
+   * Un perfil SIN contraseña abre sus variables privadas con la llave de esta máquina,
+   * cuyo material vive en este mismo disco: una copia del disco las abre. Es un default
+   * deliberado —tiene que seguir funcionando— pero NO es lo mismo, y callarlo es
+   * exactamente el error del comentario mentiroso de `atrest.js`.
+   */
+  const printNoPassword = async () => {
+    const d = await profileRequest('list')
+    const list = Array.isArray(d.profiles) ? d.profiles : []
+    const p = PROFILE ? list.find((x) => x.id === PROFILE || x.name === PROFILE) : (list.find((x) => x.current) || list[0])
+    if (!p || p.protected) return
+    console.log('%sEste perfil no tiene contraseña%s: las privadas se abren con la llave de ESTA', B, Z)
+    console.log('máquina, cuyo material vive en este mismo disco — o sea que una copia del disco')
+    console.log('las abre. Ponle una con:  dotrino-vault profile password\n')
+  }
+  const printPending = (d) => {
+    const pend = Object.entries(d?.pending || {})
+    if (!pend.length) return
+    console.error('%sHay %d cajón(es) sin sellar%s:', R, pend.length, Z)
+    for (const [owner, info] of pend) {
+      console.error('  · %s — %s', owner, info?.kind === 'rotate'
+        ? 'se fue un miembro y no se pudo rotar su llave'
+        : 'entró un aparato y no se le pudo entregar la llave')
+    }
+    console.error('Sus aparatos NO leen sus variables. Se arregla guardando una variable')
+    console.error('de ese cajón con la contraseña:  dotrino-vault secret set <ns> <CLAVE> <valor>\n')
+  }
+
+  if (sub === 'migrate') return secretMigrate()
+
+  // --- VER un valor, su histórico y volver atrás ---------------------------------
+  // Las tres van juntas porque son la misma idea: ver es lo único que la contraseña
+  // guarda, y revertir es ver + volver a guardar (§8.3/§8.4).
+  const ownerDe = async (kind, ref) => {
+    if (kind === 'ns') return `ns:${ref}`
+    const m = await findMember(ref)
+    return `dev:${m.pub}`
+  }
+
+  if (sub === 'show' || sub === 'history' || sub === 'revert') {
+    // `secret show device <ID> <CLAVE>` mira el cajón de un aparato.
+    const esDev = args[0] === 'device'
+    const [ref, key, extra] = esDev ? args.slice(1) : args
+    if (!ref || (sub !== 'history' && !key)) {
+      console.error('uso: dotrino-vault secret %s [device] <ns|ID> <CLAVE>%s', sub, sub === 'revert' ? ' <marca>' : '')
+      process.exit(2)
+    }
+    const owner = await ownerDe(esDev ? 'dev' : 'ns', ref)
+
+    if (sub === 'history') {
+      writeReq('secret-request.json', { op: 'history', owner, key: key || null })
+      const d = await signalAndWaitList()
+      const items = d.history?.items || []
+      if (!items.length) { console.log('No hay versiones anteriores de %s%s.', owner, key ? `/${key}` : ''); return }
+      console.log('\n%sVersiones anteriores%s  (la de arriba es la más reciente)\n', B, Z)
+      for (const h of items) {
+        // Sin `by` no es que falte un dato: es que se escribió AQUÍ, desde esta máquina.
+        // Lo que llega por la consola remota sí trae de qué aparato vino.
+        console.log('  %s  %s%s%s  %s%s', new Date(h.ts).toISOString(), B, h.key, Z,
+          h.by ? `desde ${h.by.slice(0, 12)}…` : 'desde esta máquina', h.signed ? '' : '   (sobre sin firma)')
+      }
+      console.log('\nPara volver a una:  dotrino-vault secret revert %s%s <CLAVE> <marca>\n',
+        esDev ? 'device ' : '', ref)
+      return
+    }
+
+    if (sub === 'revert') {
+      if (!extra) { console.error('uso: dotrino-vault secret revert [device] <ns|ID> <CLAVE> <marca>'); process.exit(2) }
+      const ts = Number.isFinite(Number(extra)) ? Number(extra) : Date.parse(extra)
+      if (!Number.isFinite(ts)) { console.error('La marca es la que enseña `secret history` (fecha ISO).'); process.exit(2) }
+      const password = await adminPassword()
+      writeReq('secret-request.json', { op: 'revert', owner, key, ts, ...(password ? { password } : {}) })
+      const d = await signalAndWaitList()
+      if (d?.secretError) return noSeAplico(d)
+      console.log('Restaurada: %s/%s', owner, key)
+      return
+    }
+
+    // `show`: el valor. Es lo único que la contraseña guarda en esta máquina.
+    const password = await adminPassword()
+    writeReq('secret-request.json', { op: 'reveal', owner, key, ...(password ? { password } : {}) })
+    const d = await signalAndWaitList()
+    if (d?.secretError) return noSeAplico(d)
+    if (d.revealed?.owner !== owner || d.revealed?.key !== key) {
+      console.error('El daemon no devolvió el valor (revisa: dotrino-vault logs)')
+      process.exit(1)
+    }
+    if (d.revealed.value == null) { console.error('No existe esa variable.'); process.exit(1) }
+    console.log(d.revealed.value)
+    return
+  }
+
+  // Saldar lo que quedó a deber: heredarle a un aparato lo ya guardado, rotar de verdad.
+  if (sub === 'settle') {
+    const password = await adminPassword()
+    writeReq('secret-request.json', { op: 'settle', ...(password ? { password } : {}) })
+    const d = await signalAndWaitList()
+    if (d?.secretError) return noSeAplico(d)
+    const pend = Object.keys(d.pending || {})
+    if (!pend.length) console.log('Nada pendiente.')
+    else console.log('Siguen pendientes: %s', pend.join(', '))
+    return
+  }
+
   if (sub === 'list') {
     const d = await signalAndWaitList()
     const names = d.ns || {}
     const nss = Object.keys(names)
-    if (!nss.length) { console.log('No hay secretos guardados. Agrega uno:  dotrino-vault secret set <ns> <CLAVE> <valor>'); return }
+    const dev = Array.isArray(d.dev) ? d.dev : []
+    if (!nss.length && !dev.length) {
+      console.log('No hay variables guardadas. Agrega una:  dotrino-vault secret set <ns> <CLAVE> <valor>')
+      return
+    }
+    if (nss.length) console.log('\n%sPor scope%s (las comparten todos los aparatos del perfil)\n', B, Z)
     for (const n of nss) {
       console.log('%s%s%s  (scope vault:secrets:%s)', B, n, Z, n)
-      for (const k of names[n]) console.log('  · %s', k)
+      for (const k of names[n]) printVar(k)
+    }
+    if (dev.length) console.log('\n%sPor aparato%s (solo las lee ese aparato; pisan a las del scope)\n', B, Z)
+    for (const x of dev) {
+      const who = [x.label, x.cn ? `servicio «${x.cn}»` : null, x.orphan ? 'YA NO ESTÁ EN EL ACTA' : null].filter(Boolean).join(' · ')
+      console.log('%s%s%s%s', B, x.id, Z, who ? '  ' + who : '')
+      for (const k of x.keys) printVar(k)
+    }
+    console.log('\n(pública) = su valor se puede ver desde la consola remota. Las demás no salen de aquí.\n')
+    printPending(d)
+    await printNoPassword()
+    return
+  }
+
+  // Por APARATO: `secret device set|rm|visibility <ID> <CLAVE> [valor|public|private]`.
+  if (sub === 'device') {
+    const [op, id, key, ...valueParts] = args
+    const value = valueParts.join(' ')
+    const ops = ['set', 'rm', 'visibility', 'import']
+    const asGroup = op === 'import' || (op === 'set' && !!asPairs(args.slice(2)))
+    if (!ops.includes(op) || !id || (!asGroup && (!key || (op === 'set' && !value)))) { console.error(USAGE); process.exit(2) }
+    const m = await findMember(id)
+    // Se avisa aquí, con nombre y apellido, en vez de dejar que el daemon lo rechace y la
+    // CLI diga «no aplicó el cambio»: quien escribe esto quiere saber POR QUÉ no vale.
+    if (!m.cn) {
+      console.error('%s no es un servicio, y solo los servicios leen variables.', m.id)
+      console.error('Empareja el servicio con:  dotrino-vault pair --service <ns>')
+      process.exit(1)
     }
+    if (op === 'import') {
+      const { items, errors } = parseEnvText(readEnvText(args[2]))
+      if (errors.length) return abortEnv(errors)
+      return sendBatch({ pub: m.pub, items, where: m.id })
+    }
+    if (asGroup) return sendBatch({ pub: m.pub, items: asPairs(args.slice(2)), where: m.id })
+    if (key && PAIR_RE.test(key) && args.length > 3) {
+      console.error('%s\n\nO todos los argumentos son CLAVE=valor, o es una sola variable.', USAGE)
+      process.exit(2)
+    }
+    const req = op === 'set'
+      ? { op: 'dev-set', pub: m.pub, key, value, ...(isPublic === undefined ? {} : { public: isPublic }) }
+      : op === 'rm'
+        ? { op: 'dev-rm', pub: m.pub, key }
+        : { op: 'dev-vis', pub: m.pub, key, public: wantsPublic(value, USAGE) }
+    // Solo la visibilidad pide la frase: enseñar un valor obliga a sacarlo.
+    const password = op === 'vis' ? await adminPassword() : null
+    writeReq('secret-request.json', password ? { ...req, password } : req)
+    const d = await signalAndWaitList()
+    const keys = (Array.isArray(d.dev) ? d.dev : []).find((x) => x.pub === m.pub)?.keys || []
+    const ok = op === 'rm' ? !has(keys, key) : has(keys, key)
+    if (!ok) return noSeAplico(d)
+    if (op === 'rm') console.log('Variable borrada: %s/%s', m.id, key)
+    else console.log('Variable guardada: %s/%s%s', m.id, key, (keys.find((x) => x.key === key)?.public) ? '   (pública)' : '')
     return
   }
-  if (sub === 'set' || sub === 'rm') {
+
+  // Desde un `.env`: el caso real de estrenar un servicio, y el que de una en una
+  // reiniciaba al agente una vez por variable.
+  if (sub === 'import') {
+    const [ns, file] = args
+    if (!ns) { console.error(USAGE); process.exit(2) }
+    const { items, errors } = parseEnvText(readEnvText(file))
+    if (errors.length) return abortEnv(errors)
+    return sendBatch({ ns, items, where: ns })
+  }
+
+  if (sub === 'set' || sub === 'rm' || sub === 'visibility') {
+    const [ns, key, ...valueParts] = args
     const value = valueParts.join(' ')
-    if (!ns || !key || (sub === 'set' && !value)) {
-      console.error('uso: dotrino-vault secret set <ns> <CLAVE> <valor>\n     dotrino-vault secret rm <ns> <CLAVE>'); process.exit(2)
+    // `set <ns> CLAVE=valor CLAVE2=valor2` — varias de una vez, un solo aviso.
+    const pairs = sub === 'set' ? asPairs(args.slice(1)) : null
+    if (ns && pairs) return sendBatch({ ns, items: pairs, where: ns })
+    // Mezclar las dos formas (`K1=v1 CLAVE valor`) no es ninguna de las dos: mejor
+    // decirlo que guardar una variable llamada «K1=v1».
+    if (sub === 'set' && key && PAIR_RE.test(key) && args.length > 2) {
+      console.error('%s\n\nO todos los argumentos son CLAVE=valor, o es una sola variable: set <ns> <CLAVE> <valor>.', USAGE)
+      process.exit(2)
     }
-    writeReq('secret-request.json', sub === 'set' ? { op: 'set', ns, key, value } : { op: 'rm', ns, key })
+    if (!ns || !key || (sub === 'set' && !value)) { console.error(USAGE); process.exit(2) }
+    const req = sub === 'set'
+      ? { op: 'set', ns, key, value, ...(isPublic === undefined ? {} : { public: isPublic }) }
+      : sub === 'rm'
+        ? { op: 'rm', ns, key }
+        : { op: 'vis', ns, key, public: wantsPublic(value, USAGE) }
+    // Solo la visibilidad pide la frase: enseñar un valor obliga a sacarlo.
+    const password = sub === 'visibility' ? await adminPassword() : null
+    writeReq('secret-request.json', password ? { ...req, password } : req)
     const d = await signalAndWaitList()
-    const ok = sub === 'set' ? (d.ns?.[ns] || []).includes(key) : !(d.ns?.[ns] || []).includes(key)
-    if (ok) console.log(sub === 'set' ? 'Secreto guardado: %s/%s' : 'Secreto borrado: %s/%s', ns, key)
-    else { console.error('El daemon no aplicó el cambio (revisa: dotrino-vault logs)'); process.exit(1) }
+    const list = d.ns?.[ns] || []
+    const ok = sub === 'rm' ? !has(list, key) : has(list, key)
+    if (!ok) return noSeAplico(d)
+    if (sub === 'rm') console.log('Secreto borrado: %s/%s', ns, key)
+    else console.log('Secreto guardado: %s/%s%s', ns, key, (list.find((x) => x.key === key)?.public) ? '   (pública)' : '')
     return
   }
-  console.error('uso: dotrino-vault secret {set|rm|list}'); process.exit(2)
+  console.error(USAGE); process.exit(2)
+}
+
+/** `visibility … public|private` — el único argumento que acepta, y sin adivinar. */
+function wantsPublic (word, usage) {
+  if (word === 'public') return true
+  if (word === 'private') return false
+  console.error('%s\n\nvisibility acepta «public» o «private».', usage); process.exit(2)
 }
 
 /**
@@ -545,20 +1016,31 @@ async function cmdSecret (rest) {
  */
 function askPassword (prompt) {
   return new Promise((resolve, reject) => {
-    const stdin = process.stdin
-    if (!stdin.isTTY) return reject(new Error('hace falta un terminal para escribir la contraseña'))
+    // Se lee del TERMINAL, no de la entrada estándar. `secret import` ya usa stdin para
+    // el `.env` (`cat .env | dotrino-vault secret import proxy`) y aun así hay que poder
+    // escribir la contraseña; lo mismo vale para cualquier tubería.
+    let stdin = process.stdin
+    let own = null
+    if (!stdin.isTTY) {
+      try {
+        own = fs.openSync('/dev/tty', 'r')
+        stdin = new tty.ReadStream(own)
+      } catch (_) { return reject(new Error('a terminal is required to type the password')) }
+    }
     process.stdout.write(prompt)
     stdin.setRawMode(true); stdin.resume(); stdin.setEncoding('utf8')
     let buf = ''
     const done = (err, val) => {
-      stdin.setRawMode(false); stdin.pause(); stdin.removeListener('data', onData)
+      try { stdin.setRawMode(false) } catch (_) {}
+      stdin.removeListener('data', onData)
+      if (own !== null) { try { stdin.destroy() } catch (_) {} } else stdin.pause()
       process.stdout.write('\n')
       err ? reject(err) : resolve(val)
     }
     const onData = (ch) => {
       for (const c of ch) {
         if (c === '\n' || c === '\r' || c === '\u0004') return done(null, buf) // Enter / Ctrl-D
-        if (c === '\u0003') return done(new Error('cancelado')) // Ctrl-C
+        if (c === '\u0003') return done(new Error('cancelled')) // Ctrl-C
         if (c === '\u007f' || c === '\b') { buf = buf.slice(0, -1); continue } // borrar
         buf += c
       }
@@ -576,7 +1058,7 @@ async function profileRequest (op, extra = {}) {
   const s = requireDaemon()
   try { fs.rmSync(profilesFile, { force: true }) } catch (_) {}
   writeReq('profile-request.json', { op, ...extra })
-  avisar(s.pid, 'SIGUSR2')
+  sendSignal(s.pid, 'SIGUSR2')
   for (let i = 0; i < 100; i++) {
     await sleep(100)
     const d = readJson(profilesFile, null)
@@ -586,7 +1068,14 @@ async function profileRequest (op, extra = {}) {
 }
 
 function reportProfiles (d) {
-  if (d.error) { console.error('%s', d.error); process.exit(1) }
+  if (d.error) {
+    // Los dos rechazos del candado se dicen con palabras y con el dato que hace falta; el
+    // resto se reenvía tal cual (son diagnósticos del servicio).
+    if (d.code === 'WRONG_PASSWORD') console.error('Contraseña incorrecta%s.', d.tries ? ` — van ${d.tries} intentos fallidos` : '')
+    else if (d.code === 'TOO_MANY_TRIES') console.error('Demasiados intentos: espera %s s antes de volver a probar.', d.waitSec || '?')
+    else console.error('%s', d.error)
+    process.exit(1)
+  }
   if (d.done) console.log('%s', d.done)
   return d
 }
@@ -635,14 +1124,37 @@ async function cmdProfile (rest) {
     }
     case 'password': {
       const action = args[0]
-      if (action === 'rm') { reportProfiles(await profileRequest('password-rm')); return }
+      // QUITARLA pide la actual, y no por trámite: con ella se abre la copia maestra de
+      // los secretos para volver a cerrarla con la llave de esta máquina. Sin ese paso,
+      // quitar la contraseña dejaría las variables privadas ilegibles para siempre.
+      if (action === 'rm') {
+        console.log('Al quitarla, las variables privadas pasan a abrirse con la llave de ESTA')
+        console.log('máquina: siguen cifradas en el disco, pero su material vive en ese mismo')
+        console.log('disco, así que una copia del disco las abre. Los aparatos no se enteran.')
+        const cur = await askPassword('\nContraseña actual: ')
+        if (!cur) { console.error('Cancelado.'); process.exit(1) }
+        reportProfiles(await profileRequest('password-rm', { password: cur }))
+        return
+      }
       if (action && action !== 'set') { console.error('uso: dotrino-vault profile password [set|rm]'); process.exit(2) }
-      console.log('La contraseña solo se pide para EDITAR el perfil. Tus dispositivos siguen')
-      console.log('funcionando (firmando y leyendo) aunque el perfil esté bloqueado.')
-      const pwd = await askPassword('\nContraseña nueva (mínimo 4): ')
+      console.log('La contraseña se pide para EDITAR el perfil y para escribir variables')
+      console.log('privadas. Tus dispositivos siguen funcionando (firmando, leyendo y')
+      console.log('recibiendo su configuración) aunque el perfil esté bloqueado.')
+      // Si ya hay una, hace falta para poder abrir la copia maestra y re-sellarla. El
+      // camino recomendado para CAMBIARLA es quitarla y ponerla: así cada paso pide
+      // solo lo que necesita.
+      const actual = await askPassword('\nContraseña actual (vacío si no tiene): ')
+      // Se pide una FRASE, y se dice cómo sacarla, porque lo que da fuerza es la
+      // longitud y que no la elija un humano: un modismo tiene la entropía de un
+      // modismo, no la de su longitud. Desde el sellado, esta frase es lo único que
+      // separa una copia del disco de las variables privadas.
+      console.log('\nUsa VARIAS PALABRAS AL AZAR (mínimo 12 caracteres). Para que las elija')
+      console.log('la máquina y no tú:')
+      console.log("  grep -x '[a-z]\\{4,8\\}' /usr/share/dict/words | shuf -n5 | paste -sd-")
+      const pwd = await askPassword('\nContraseña nueva: ')
       const again = await askPassword('Repítela: ')
       if (pwd !== again) { console.error('Las contraseñas no coinciden.'); process.exit(1) }
-      reportProfiles(await profileRequest('password-set', { password: pwd }))
+      reportProfiles(await profileRequest('password-set', { password: pwd, current: actual || undefined }))
       return
     }
     default:
@@ -691,9 +1203,38 @@ function help () {
                       estrena una cuenta VACÍA en este vault y mete ahí al dispositivo
                       (sin la bandera entra a la cuenta activa, o a la de --profile)
   pair --service <ns> empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
-  secret set <ns> <CLAVE> <valor>   guarda un secreto para el servicio <ns>
-  secret rm <ns> <CLAVE>            borra un secreto
-  secret list                       lista nombres de secretos (nunca valores)
+  pair --scope <lista>  los PERMISOS del cert: sign,read,store,secrets:<ns> (sin esto: sign,read,store;
+                      se combina con --service: --service eco --scope sign = bot que firma y lee su cajón)
+  secret set <ns> <CLAVE> <valor>   variable del scope <ns>: la comparten TODOS los
+                                    aparatos del perfil que sirven ese namespace
+  secret set <ns> CLAVE=valor CLAVE2=valor2 …
+                                    carga VARIAS de una vez: se aplican juntas y el
+                                    servicio recibe UN solo aviso (se reinicia una vez)
+  secret import <ns> [archivo.env]  lo mismo desde un .env (o por la entrada estándar)
+  secret rm <ns> <CLAVE>            borra una variable del scope
+  secret device set <ID> <CLAVE> <valor>
+                                    variable de UN aparato: solo la lee él, y pisa a la
+                                    del scope que se llame igual (puerto, URL pública…)
+  secret device set <ID> CLAVE=valor …
+  secret device import <ID> [archivo.env]
+  secret device rm <ID> <CLAVE>     borra una variable de ese aparato
+  secret list                       lista los dos cajones: el valor de las públicas,
+                                    tapadas las privadas
+  secret show [device] <ns|ID> <CLAVE>
+                                    VE el valor de una privada. Es lo único que pide la
+                                    contraseña del perfil: en esta máquina es lo único
+                                    que la separa de una copia del disco
+  secret history [device] <ns|ID> [CLAVE]
+                                    las versiones anteriores (quién y cuándo)
+  secret revert [device] <ns|ID> <CLAVE> <marca>
+                                    vuelve a una versión anterior
+  secret settle                     salda lo pendiente: hereda lo ya guardado a un
+                                    aparato nuevo y rota de verdad el cajón del que se fue
+  --public | --private              (al hacer un set) si el VALOR puede salir de esta
+                                    máquina hacia la consola remota. Se nace privada,
+                                    y una privada NO se vuelve pública (bórrala y créala).
+  secret visibility <ns> <CLAVE> private               tapa una pública sin tocar el valor
+  secret device visibility <ID> <CLAVE> private
   pending             muestra el dispositivo pendiente + su código a comparar
   approve <código>    aprueba el dispositivo tipeando el código que MUESTRA (el vault no lo sabe)
   reject <deviceId>   rechaza un dispositivo pendiente