@dotrino/vaultd 0.93.0 → 0.94.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.93.0",
+  "version": "0.94.0",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {

package/src/ctl.js

@@ -24,6 +24,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { execFileSync } from 'node:child_process'
 import tty from 'node:tty'
+import crypto from 'node:crypto'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir } from './paths.js'
 // EL CANAL LOCAL VA CIFRADO (ver `ipc.js`): por aquí salen la contraseña y los valores.
@@ -573,7 +574,7 @@ async function cmdMembers () {
       m.addedAt ? `  ${D}· conectado el ${fechaCorta(m.addedAt)}${Z}` : '',
       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 where_
+    // 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)
   }
@@ -820,11 +821,11 @@ function cmdAtrest (rest) {
     // versión vieja dejó en claro, con el verificador de la contraseña dentro— meses
     // después de que su migración terminara. Se mira el perfil Y la raíz, porque el canal
     // local con la CLI vive arriba.
-    for (const [where_, d] of [['este perfil', dir], ['la raíz de la bóveda', vaultRoot]]) {
+    for (const [label, d] of [['este perfil', dir], ['la raíz de la bóveda', vaultRoot]]) {
       const loose = plaintextFilesIn(d)
       if (loose.length) {
         console.log('')
-        console.log(`${R}En claro en ${where_}:${Z} ` + loose.join(', '))
+        console.log(`${R}En claro en ${label}:${Z} ` + loose.join(', '))
         console.log('  Si es un respaldo de una migración terminada, bórralo: no lo cifra nadie.')
       }
     }
@@ -926,16 +927,66 @@ function cmdAtrest (rest) {
 }
 
 // Bitácora de actividad de seguridad (quién firmó/renovó/enroló y qué se rechazó).
-function cmdActivity (n = 30) {
-  const f = path.join(profileDir(), 'activity.log')
-  let lines = []
-  try { lines = fs.readFileSync(f, 'utf8').trim().split('\n').filter(Boolean) } catch {
+/**
+ * Toda la bitácora EN ORDEN, archivos rotados incluidos. Se leen del más viejo al más
+ * nuevo (`.5` … `.1`, y al final el vivo) porque la cadena los cruza: verificarla mirando
+ * solo el archivo actual diría «rota» en su primera línea, que es exactamente lo contrario
+ * de lo que pasa.
+ */
+function readActivity (dir) {
+  const atRest = atRestFor(dir)
+  const out = []
+  const files = []
+  for (let i = 9; i >= 1; i--) { const f = path.join(dir, `activity.log.${i}`); if (fs.existsSync(f)) files.push(f) }
+  files.push(path.join(dir, 'activity.log'))
+  for (const f of files) {
+    let raw = ''
+    try { raw = fs.readFileSync(f, 'utf8') } catch { continue }
+    for (const l of raw.trim().split('\n').filter(Boolean)) {
+      // `decrypt` deja pasar el texto en claro, así que una bitácora anterior a 0.89 se
+      // sigue leyendo entera.
+      try { out.push(atRest.decrypt(l)) } catch { out.push(l) }
+    }
+  }
+  return out
+}
+
+/**
+ * ¿ESTÁ LA CADENA ENTERA? Cada entrada lleva el hash de la anterior, así que tocar o quitar
+ * una rompe todo lo que va detrás. Esto lo recorre y dice dónde se rompió.
+ *
+ * Lo que NO comprueba, y se dice: que no le hayan cortado el FINAL. Un prefijo válido sigue
+ * siendo válido; cerrarlo pide anclar el último hash fuera de esta máquina.
+ */
+function verifyActivity (lines) {
+  const sha256 = (t) => crypto.createHash('sha256').update(t, 'utf8').digest('hex')
+  let prev = null; let seq = null; let checked = 0; let unchained = 0
+  for (const text of lines) {
+    let e; try { e = JSON.parse(text) } catch { continue }
+    if (typeof e.seq !== 'number') { unchained++; continue }   // entradas de antes de 0.94
+    if (seq !== null) {
+      if (e.seq !== seq + 1) return { ok: false, at: e.seq, why: `salta del #${seq} al #${e.seq}` }
+      if (e.prev !== prev) return { ok: false, at: e.seq, why: `el #${e.seq} no encadena con el #${seq}` }
+    }
+    seq = e.seq; prev = sha256(text); checked++
+  }
+  return { ok: true, checked, unchained, last: seq }
+}
+
+function cmdActivity (n = 30, { verify = false, exportar = false } = {}) {
+  const dir = profileDir()
+  const lines = readActivity(dir)
+  if (!lines.length) {
     console.log('Sin actividad registrada todavía (o el servicio es anterior a 0.1.10).'); return
   }
-  // Cada entrada va cifrada por separado (ver `audit` en `vault.js`). `decrypt` deja pasar
-  // el texto en claro, así que una bitácora anterior a 0.89 se sigue leyendo entera.
-  const atRest = atRestFor(profileDir())
-  lines = lines.map((l) => { try { return atRest.decrypt(l) } catch { return l } })
+  if (exportar) { for (const l of lines) console.log(l); return }
+  if (verify) {
+    const r = verifyActivity(lines)
+    if (!r.ok) { console.error(`${R}CADENA ROTA${Z} en la entrada #${r.at}: ${r.why}`); process.exit(1) }
+    console.log(`Cadena íntegra: ${r.checked} entrada(s) encadenada(s)${r.last ? ` hasta la #${r.last}` : ''}.`)
+    if (r.unchained) console.log(`  ${r.unchained} entrada(s) anteriores a 0.94, sin encadenar: no se pueden verificar.`)
+    return
+  }
   const ICON = { sign: '🖊 firma', renew: '♻ renovación', enroll: '➕ enrolado', revoke: '⛔ revocado', rejected: '🚫 RECHAZADO', secrets: '🔑 secretos leídos', 'secret.set': '🔑 secreto guardado', 'secret.rm': '🔑 secreto borrado' }
   for (const line of lines.slice(-n)) {
     try {
@@ -958,7 +1009,7 @@ function cmdActivity (n = 30) {
 /**
  * `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`,
- * where_ el valor puede llevar espacios y hasta un `=`) siga funcionando igual.
+ * donde el valor puede llevar espacios y hasta un `=`) siga funcionando igual.
  */
 function asPairs (args) {
   if (!args.length) return null
@@ -1395,7 +1446,7 @@ function reportProfiles (d) {
 async function cmdProfile (rest) {
   const [sub, ...rawArgs] = rest
   // `--kms <archivo>` se saca ANTES de armar el nombre: el nombre se compone juntando
-  // los argumentos loose, así que si no se quita acabaría llamándose «midevault --kms
+  // los argumentos sueltos, así que si no se quita acabaría llamándose «midevault --kms
   // cfg.json».
   const kmsAt = rawArgs.indexOf('--kms')
   const kmsFile = kmsAt !== -1 ? rawArgs[kmsAt + 1] : null
@@ -1610,6 +1661,8 @@ function help () {
                       (--machine para volver a la clave de esta máquina). Editar
                       atrest.json a mano NO vale: dejaría el perfil ilegible
   activity [n]        bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
+  activity --verify   comprueba que la cadena está entera (nadie tocó el pasado)
+  activity --export   la vuelca entera en JSONL, para auditar o guardar fuera
   logs                últimos logs del servicio
   version             muestra la versión instalada
 
@@ -1664,7 +1717,9 @@ export async function runCtl (argv) {
     case 'secret': return cmdSecret(rest)
     case 'approval': return cmdApproval(rest)
     case 'atrest': return cmdAtrest(rest)
-    case 'activity': return cmdActivity(Number(rest[0]) || 30)
+    case 'activity': return cmdActivity(Number(rest.find((a) => /^\d+$/.test(a))) || 30, {
+      verify: rest.includes('--verify'), exportar: rest.includes('--export')
+    })
     case 'logs': return cmdLogs()
     case 'version':
     case '--version':

package/src/vault.js

@@ -11,6 +11,7 @@
  * Toda la cripto es de `@dotrino/identity`. Este módulo solo orquesta.
  */
 import fs from 'node:fs'
+import nodeCrypto from 'node:crypto'
 import path from 'node:path'
 import { Identity } from '@dotrino/identity/node'
 import { verifyChain, pubkeyId, verifyDeviceSig } from '@dotrino/identity/capabilities'
@@ -119,7 +120,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * Lo dice el ACTA, con el permiso `unattended`: quien lo tiene se las lleva solo; quien
    * no, espera a que un aparato con `approve` lo firme.
    *
-   * Antes era al revés y vivía aquí: una list_ local de «estos SÍ piden permiso», así que
+   * Antes era al revés y vivía aquí: una lista local de «estos SÍ piden permiso», así que
    * un aparato nuevo nacía pudiendo llevarse las claves y nadie elegía eso — se elegía por
    * omisión. Ahora hay que conceder a propósito quién puede llevárselas solo, y **si falta
    * el dato se pide permiso**, que es lo que hay que hacer cuando no se sabe (dueño,
@@ -135,7 +136,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   // LA BÓVEDA DE CONTRASEÑAS: entradas y su llave, en el dir del perfil y cifradas en
   // reposo como todo lo demás. QUIÉN PUEDE PEDIR LO DICE EL ACTA (capacidad
-  // `passwords`), como cualquier otro permiso: aquí no hay una segunda list_ de
+  // `passwords`), como cualquier otro permiso: aquí no hay una segunda lista de
   // aparatos. Tenerla obligaba a acordarse de dos sitios al quitar un aparato, y era
   // además un emparejamiento paralelo al del ecosistema.
   const passwordsFile = path.join(dir, 'passwords.json')
@@ -367,18 +368,73 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // Y el modo, que hasta 0.89 se creaba 0664: legible por cualquier usuario.
     if ((fs.statSync(activityFile).mode & 0o077) !== 0) fs.chmodSync(activityFile, 0o600)
   } catch (_) { /* no hay bitácora todavía */ }
+  /**
+   * LA BITÁCORA ES UNA CADENA, no una lista de líneas sueltas.
+   *
+   * Cifrarla (0.89) le dio confidencialidad y ninguna integridad: quien tenga la llave de
+   * la máquina puede reescribir una línea y nadie lo nota. Como evidencia no valía nada, y
+   * eso es justo lo que un auditor mira (`CUMPLIMIENTO.md` §2).
+   *
+   * Cada entrada lleva su `seq` y el **hash de la anterior**, así que tocar o quitar una
+   * rompe la cadena de ahí en adelante y se ve. Se encadena el TEXTO exacto de la línea,
+   * no un objeto re-serializado: así verificar no depende de que las claves salgan en el
+   * mismo orden.
+   *
+   * **Lo que esto NO resuelve, dicho para no venderlo de más:** quien tenga la máquina
+   * puede cortar el final de la cadena y quedarse con un prefijo válido. Eso no se cierra
+   * en local — pide anclar el último hash fuera (un TSA, otro aparato). Lo que sí cierra
+   * es reescribir el pasado sin dejar rastro, que es el caso que importaba.
+   */
+  const AUDIT_MAX_BYTES = 1024 * 1024
+  /** Cuántos archivos viejos se guardan. Es la RETENCIÓN, y va declarada. */
+  const AUDIT_KEEP = 5
+  const sha256 = (text) => nodeCrypto.createHash('sha256').update(text, 'utf8').digest('hex')
+
+  let auditSeq = 0
+  let auditPrev = null
+
+  /** Reconstruye el estado de la cadena leyendo la última entrada que haya. */
+  try {
+    const lines = fs.readFileSync(activityFile, 'utf8').split('\n').filter(Boolean)
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const text = activityAtRest.decrypt(lines[i])
+        const e = JSON.parse(text)
+        if (typeof e.seq === 'number') { auditSeq = e.seq; auditPrev = sha256(text); break }
+      } catch (_) { /* una línea vieja o ilegible: se sigue hacia atrás */ }
+    }
+  } catch (_) { /* no hay bitácora todavía */ }
+
+  /**
+   * ROTA ARCHIVANDO, NO TIRANDO. Antes se quedaba con la mitad del archivo y la otra mitad
+   * desaparecía sin que nada lo dijera: una bitácora que pierde historia en silencio es
+   * peor que no tenerla, porque parece completa. Ahora los viejos se corren a `.1`…`.N` y,
+   * cuando uno se cae del borde, **queda anotado que se cayó**.
+   */
+  const rotateAudit = () => {
+    let dropped = null
+    const older = `${activityFile}.${AUDIT_KEEP}`
+    try { if (fs.existsSync(older)) { fs.rmSync(older); dropped = `activity.log.${AUDIT_KEEP}` } } catch (_) {}
+    for (let i = AUDIT_KEEP - 1; i >= 1; i--) {
+      try { if (fs.existsSync(`${activityFile}.${i}`)) fs.renameSync(`${activityFile}.${i}`, `${activityFile}.${i + 1}`) } catch (_) {}
+    }
+    try { fs.renameSync(activityFile, `${activityFile}.1`) } catch (_) {}
+    return dropped
+  }
+
   const audit = (op, info = {}) => {
     try {
-      const line = activityAtRest.encrypt(JSON.stringify({ ts: Date.now(), op, ...info }))
-      fs.appendFileSync(activityFile, line + '\n', { mode: 0o600 })
+      const entry = { seq: ++auditSeq, prev: auditPrev, ts: Date.now(), op, ...info }
+      const text = JSON.stringify(entry)
+      fs.appendFileSync(activityFile, activityAtRest.encrypt(text) + '\n', { mode: 0o600 })
+      auditPrev = sha256(text)
       // El `mode` de `appendFileSync` solo aplica al CREAR: las bitácoras de antes de
       // 0.89 ya existen con 0664 y hay que estrecharlas a mano.
       try { if ((fs.statSync(activityFile).mode & 0o077) !== 0) fs.chmodSync(activityFile, 0o600) } catch (_) {}
-      // rotación simple: si pasa de ~1 MB, conservar la última mitad
-      const st = fs.statSync(activityFile)
-      if (st.size > 1024 * 1024) {
-        const lines = fs.readFileSync(activityFile, 'utf8').split('\n')
-        fs.writeFileSync(activityFile, lines.slice(Math.floor(lines.length / 2)).join('\n'), { mode: 0o600 })
+      if (fs.statSync(activityFile).size > AUDIT_MAX_BYTES) {
+        const dropped = rotateAudit()
+        // La primera entrada del archivo nuevo dice de dónde viene, y si se perdió algo.
+        audit('log.rotated', { keep: AUDIT_KEEP, ...(dropped ? { dropped } : {}) })
       }
     } catch (_) {}
   }
@@ -464,7 +520,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    *
    * Sustituye a `trustedIssuer: master`, que comparaba contra UNA llave fija y por eso el
    * multivault no podía existir — una segunda selladora sellaba el acta y luego sus papeles
-   * los rechazaban los diez mostradores. Ahora se compara contra la list_ que dice el acta.
+   * los rechazaban los diez mostradores. Ahora se compara contra la lista que dice el acta.
    *
    * Sin acta se devuelven nulos a propósito: `verifyDelegation` responde `no-acta` y el
    * mostrador deniega. Es lo contrario de un repliegue — no hay con qué decidir, así que no
@@ -664,7 +720,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * exactamente lo que el acta nombra, así que decir quién pregunta no necesita más.
    *
    * La respuesta es sí o no, y nada más: al que sigue dentro no se le manda el acta —no la
-   * pidió, y contarle el perfil entero a quien no trae papel es dar de más—. Al que ya no
+   * pidió, y contarle el perfil entero a quien no trae papel es attach de más—. Al que ya no
    * está se le manda el aviso FIRMADO de expulsión, que es lo único que le borra la cuenta.
    * Que un desconocido pregunte no cuesta nada: lo que se le puede contestar es un aviso a
    * nombre de SU propia llave, que no le sirve contra nadie más (`verifyRevoke` exige que
@@ -710,7 +766,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('devices', { device: await deviceIdOf(chk.device).catch(() => null), solo: 'revocaciones' })
       return reply(from, { type: MSG.DEVICES_RESULT, devices: [], revoked, acta: record })
     }
-    // El acta viaja con la list_: así cada dispositivo se entera de los cambios de
+    // El acta viaja con la lista: así cada dispositivo se entera de los cambios de
     // política (quién manda, quién puede qué) sin un canal aparte.
     // Si el dispositivo estuvo apagado y viene con un `seq` viejo, se le manda la CADENA
     // que falta (ventana de retención, §1.3) para que compruebe el encadenamiento en vez
@@ -728,7 +784,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
     // `sub` (pubkey completa) va incluida: es la DIRECCIÓN de cada dispositivo en el
     // proxy → permite a las apps AUTODESCUBRIR tus máquinas (p. ej. la terminal
-    // list_ tus agentes sin pegar nada). Solo la ve quien presenta un cert tuyo válido.
+    // lista tus agentes sin pegar nada). Solo la ve quien presenta un cert tuyo válido.
     const devices = await Promise.all(issued.map(async (x) => ({
       deviceId: x.sub ? await deviceIdOf(x.sub) : null, sub: x.sub || null, label: x.label || '', scope: x.scope, exp: x.exp, nonce: x.nonce
     })))
@@ -773,7 +829,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
     // EL SCOPE SALE DEL ACTA, no del cert viejo. El acta es la política (lo que el dueño
     // decidió con `caps`); el cert es su reflejo, y solo dura 30 días para poder cambiar.
-    // Copiar `p.cert.scope` congelaba la política en el momento del emparejamiento: dar
+    // Copiar `p.cert.scope` congelaba la política en el momento del emparejamiento: attach
     // `administra` no llegaba nunca al cert (la consola remota no podía funcionar) y
     // QUITARLO tampoco surtía efecto hasta que el cert caducara, hasta un mes después.
     // Si el miembro ya no está en el acta, no se renueva nada: lo echaron.
@@ -1059,7 +1115,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * NUNCA. El pedido solo se veía si al dueño se le ocurría abrir la app por su cuenta.
    *
    * El aviso no lleva nada que no esté ya en el pedido, y el timbre que sale de aquí sigue
-   * sin contenido: quien lo recibe pregunta por la list_, no la lee del aviso.
+   * sin contenido: quien lo recibe pregunta por la lista, no la lee del aviso.
    */
   async function notifyApprovers (pend, record) {
     try {
@@ -1170,7 +1226,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       cek: await passwordsKey(),
       // UNA sola condición, y es del ACTA: el aparato tiene la capacidad `passwords`.
       // Quitársela —o quitar el aparato— le corta esto en la siguiente pasada, sin
-      // que haya una segunda list_ que acordarse de tocar.
+      // que haya una segunda lista que acordarse de tocar.
       isAllowed: (pub) => !!actaCache && Acta.memberCan(actaCache, pub, 'passwords'),
       encPubOf: (pub) => (actaCache?.members || []).find((m) => m.pub === pub)?.encPub || null,
       // EN VIVO, no del caché: conceder o quitar `unattended` tiene que surtir efecto en
@@ -1348,11 +1404,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // Esto avisaba únicamente por `issued` —las delegaciones que emitió esta bóveda—, y
       // eso deja fuera exactamente el caso del multivault: la segunda bóveda entró por
       // `join`, así que la delegación la emitió la PRIMERA. Cuando la segunda sellaba un
-      // acta nueva (admitir un aparato con su permiso `sella`), su list_ de emitidas no
+      // acta nueva (admitir un aparato con su permiso `sella`), su lista de emitidas no
       // tenía a la primera dentro y el cambio no llegaba a ninguna parte: las dos bóvedas
       // quedaban con actas distintas y la del dueño sin enterarse de nada.
       //
-      // El acta es la list_ de quién es del perfil: esa es la list_ correcta. `issued` se
+      // El acta es la lista de quién es del perfil: esa es la lista correcta. `issued` se
       // suma porque cubre a quien tiene cert y todavía no aparece ahí.
       const miembros = (await identity.profileMembers?.().catch(() => null))?.members || []
       const yo = identity.me?.publickey || null
@@ -1417,7 +1473,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // podría abrirlas, porque su envoltura no existe. Dos cerrojos para lo mismo, a
       // propósito: que uno falle no basta para leerlas.
       //
-      // Se sella la list_ ENTERA, no solo los valores: el proxy tampoco tiene por qué
+      // Se sella la lista ENTERA, no solo los valores: el proxy tampoco tiene por qué
       // aprender cómo se llaman tus variables ni qué servicios corres.
       return {
         enc: await identity.sealContent(JSON.stringify({
@@ -1438,7 +1494,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       }
     },
     /**
-     * PARA QUIÉN ENVOLVER. Lo contesta la bóveda porque la list_ sale del ACTA
+     * PARA QUIÉN ENVOLVER. Lo contesta la bóveda porque la lista sale del ACTA
      * (`recipientsOf`), y tener dos sitios respondiendo a «quién puede abrir este cajón» es
      * exactamente cómo se acaba dejando fuera a alguien sin que nadie se entere.
      */
@@ -1622,7 +1678,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // listar y borrar no la piden (ver `secretsStore.js`).
   /**
    * Los miembros que deben poder abrir un cajón: los SERVICIOS de ese namespace
-   * (miembros del acta con ese `cn`). La bóveda NO entra en la list_ — envolverle la
+   * (miembros del acta con ese `cn`). La bóveda NO entra en la lista — envolverle la
    * CEK a ella misma sería devolverle la capacidad de leerlo todo, que es justo lo
    * que este diseño quita.
    */
@@ -1630,7 +1686,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const record = (await identity.profileActa?.().catch(() => null))?.acta
     if (!record) return []
     // LLEVAR EL `cn` NO ES PODER LEER. El acta manda también aquí: un miembro entra en la
-    // list_ si además puede leer los secretos de ese cajón (`memberCanReadSecrets`).
+    // lista si además puede leer los secretos de ese cajón (`memberCanReadSecrets`).
     //
     // Sin esa segunda mitad, el `cn` era la única puerta y `cn` es un texto libre: la LLAVE
     // DE COMUNICACIÓN de la bóveda entra en el acta con `cn: 'vault'` y `caps: ['sign']`,
@@ -1648,7 +1704,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * ningún sitio, que es todo el punto del §8.2 — la capacidad de leer se muda de una
    * frase que se escribe en cualquier parte a una llave que no sale del aparato.
    *
-   * La bóveda NO entra en la list_, ni aquí ni en `nsMembers`: envolverle la llave a
+   * La bóveda NO entra en la lista, ni aquí ni en `nsMembers`: envolverle la llave a
    * ella misma sería devolverle la capacidad de leerlo todo, que es justo lo que este
    * diseño quita. Hay un test que lo afirma.
    */
@@ -1841,7 +1897,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * hay quien la teclee.
    *
    * Que no puedan leer es CORRECTO y no se relaja. Lo que se arregla aquí es que se
-   * vea: hasta ahora un servicio recién enrolado aparecía en la list_ como cualquier
+   * vea: hasta ahora un servicio recién enrolado aparecía en la lista como cualquier
    * otro y arrancaba sin configuración, repitiendo un error en su propio log que nadie
    * mira. Con esto, la consola y la TUI pueden decir exactamente qué falta y qué hacer
    * (`dotrino-vault secret settle`, que sí pide la frase).
@@ -1860,7 +1916,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // «Ver» de la consola le fallaría sin explicar por qué.
       // Un aparato que administra NO debe tener envoltura de los cajones con dueño
       // (`recipientsOf`), así que no se le cuenta como falta: lo que ahí falta es a
-      // propósito y ponerlo en la list_ sería pedir que se «arregle» lo correcto.
+      // propósito y ponerlo en la lista sería pedir que se «arregle» lo correcto.
       const ownedNs = new Set((record?.members || []).filter((x) => x.cn).map((x) => x.cn))
       const drawers = m.cn
         ? [`ns:${m.cn}`, `dev:${m.pub}`]
@@ -1960,7 +2016,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * único que la frase guarda (§8.3).
    *
    * No lanza: devuelve qué pasó con cada cajón, porque una deuda que no se puede saldar
-   * tiene que seguir viéndose en la list_ en vez de tumbar la operación entera.
+   * tiene que seguir viéndose en la lista en vez de tumbar la operación entera.
    */
   /**
    * PIDE AL SERVICIO QUE REPARTA la llave de su cajón a un miembro nuevo (§8.11).
@@ -2236,8 +2292,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const out = { drawers: 0, wrapped: 0, dropped: 0, sinLlave: [], failed: [] }
     for (const owner of secrets.owners?.() || []) {
       const before = new Set(secrets.recipientsIn(owner))
-      // POR VISIBILIDAD, no una list_ fija: una pública lleva además la envoltura de quien
-      // administra. Con una sola list_ se le daría también la de una privada con dueño, que
+      // POR VISIBILIDAD, no una lista fija: una pública lleva además la envoltura de quien
+      // administra. Con una sola lista se le daría también la de una privada con dueño, que
       // es justo lo que no puede pasar.
       const members = (esPublica) => recipientsOf(owner, { public: esPublica })
       try {
@@ -2300,7 +2356,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!owed) return null
     // QUIÉN RECIBE ENVOLTURA LO DICE `recipientsOf`, Y SOLO ÉL.
     //
-    // Antes cada llamador traía su propia list_ (`nsMembers`, o el miembro suelto), y todas
+    // Antes cada llamador traía su propia lista (`nsMembers`, o el miembro suelto), y todas
     // se dejaban fuera a los SELLADORES — que `recipientsOf` sí incluye. Resultado: escribir
     // una variable envolvía para el servicio y dejaba al sellador con la generación vieja
     // (dueño, 2026-09-01: «al envolver hay que envolver siempre para todos los selladores,
@@ -2406,9 +2462,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * pública, y no se puede leer. Eso es cierto y se arregla abriendo la bóveda; inventarse
    * un valor o esconder la fila sería peor.
    */
-  const withEnvelopes = (list_, kind, caller) => {
-    if (!caller) return list_
-    const dar = (owner, k) => {
+  const withEnvelopes = (entries, kind, caller) => {
+    if (!caller) return entries
+    const attach = (owner, k) => {
       if (!k.public) return k
       const e = secrets.entryOf?.(owner, k.key)
       const wrap = e?.gen != null ? secrets.wrapOf?.(owner, e.gen, caller) : null
@@ -2416,10 +2472,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     }
     if (kind === 'ns') {
       const out = {}
-      for (const [ns, keys] of Object.entries(list_)) out[ns] = keys.map((k) => dar(`ns:${ns}`, k))
+      for (const [ns, keys] of Object.entries(entries)) out[ns] = keys.map((k) => attach(`ns:${ns}`, k))
       return out
     }
-    return list_.map((row) => ({ ...row, keys: row.keys.map((k) => dar(`dev:${row.pub}`, k)) }))
+    return entries.map((row) => ({ ...row, keys: row.keys.map((k) => attach(`dev:${row.pub}`, k)) }))
   }
 
   function listSecrets () {
@@ -2549,10 +2605,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
     // ¿Pide permiso este aparato para recibir claves privadas? Lo dice el ACTA
-    // (`unattended`), no una list_ de esta máquina — por eso ya no hay `setApproval` ni
+    // (`unattended`), no una lista de esta máquina — por eso ya no hay `setApproval` ni
     // `supervised`: se concede y se quita como cualquier otro permiso, con `caps`.
     needsApproval: async (pub) => needsApproval(pub, await refreshActa()),
-    // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se list_: es donde está la
+    // La bóveda de contraseñas (`passwords.js`). Aquí SÍ se lista: es donde está la
     // llave. Lo que no puede es listarla un aparato.
     passwordDevices,
     passwordsVault: () => passwords?.vault || null,
@@ -2599,7 +2655,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // desbloquear: deja `secrets.json.v3.bak` para poder volver.
     /**
      * Convierte el archivo de secretos al formato nuevo. `membersOf` es opcional y lo
-     * normal es NO pasarlo: por defecto se usa la misma list_ de destinatarios que
+     * normal es NO pasarlo: por defecto se usa la misma lista de destinatarios que
      * cualquier escritura —los servicios del cajón MÁS los aparatos que administran—.
      *
      * Pasarla a mano fue un error real: la conversión envolvía solo a los servicios, y
@@ -2644,7 +2700,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     isMaster: () => identity.isMaster(),
     setCaps: async (pub, caps) => {
       const r = await identity.setCaps(pub, caps)
-      // ¿SE QUEDÓ ALGUNO POR EL CAMINO? El acta tiene una list_ CERRADA de permisos y
+      // ¿SE QUEDÓ ALGUNO POR EL CAMINO? El acta tiene una lista CERRADA de permisos y
       // `cleanCaps` descarta los que no conoce — correcto al recibir un acta ajena, y
       // pésimo aquí: conceder `+sella` con una versión del pilar que no sabe qué es
       // devolvía «Listo», resellaba el acta y no concedía nada. Costó una tarde en un