@dotrino/vaultd 0.87.0 → 0.89.0

package/lib/src/admin.js

@@ -204,7 +204,9 @@ export function createAdminDesk ({
         const toScope = typeof data.ns === 'string' && !!data.ns
         const toDevice = typeof data.pub === 'string' && !!data.pub
         if (data.op === 'vars') {
-          const result = await vars.list({ by })
+          // QUIÉN PREGUNTA, no solo su nombre: con su llave se le manda la envoltura de
+          // cada pública para que pueda abrirla en su casa.
+          const result = await vars.list({ by, caller: chk.device })
           audit('admin.vars', { by })
           return { ok: true, result }
         }

package/lib/src/atrest.js

@@ -14,8 +14,14 @@
  *   · `secrets.json`   secretos de servicios (tokens y llaves de producción)
  *   · `service-identity.json` en la máquina del SERVICIO (`@dotrino/vault/env`):
  *     lleva la llave privada de su dispositivo, así que va igual de cifrado.
- * Queda fuera a propósito `activity.log`: es la bitácora de auditoría y no guarda
- * payloads (solo op, dispositivo y hora), y se quiere legible para diagnosticar.
+ *   · `activity.log`   la bitácora de auditoría, cifrada LÍNEA A LÍNEA (ver `LINE_FILES`)
+ *   · `state.json`, `acta.json`, `secret-request.json`… el canal local con la CLI
+ *     (`src/ipc.js`), por donde pasan la contraseña del perfil y los valores
+ *   · `transport.json` el par de transporte de `@dotrino/proxy-client`, con su privada
+ *
+ * La bitácora estuvo fuera hasta 0.89, con el argumento de que «no guarda payloads». No
+ * guarda valores, pero sí el mapa de la cuenta —qué aparatos, con qué permisos, contra
+ * qué cajones y a qué hora—, que es lo que mira quien elige por dónde entrar.
  *
  * Qué NO resuelve, dicho sin adornos: **no protege contra alguien con acceso a esta misma
  * máquina como tu usuario o como root** — puede leer el mismo material que leemos nosotros.
@@ -178,15 +184,31 @@ export function migrateFile (file, key) {
 }
 
 /** Los archivos de este directorio que están cifrados por nosotros. */
+/**
+ * Archivos que van cifrados **línea a línea**, no de una pieza.
+ *
+ * La bitácora se ESCRIBE AÑADIENDO. Cifrarla entera obligaría a reescribir el archivo
+ * completo en cada anotación, así que cada entrada se cierra sola. Eso la deja fuera del
+ * barrido de abajo (una lectura de todo el archivo no descifra: son muchos textos pegados)
+ * y la mete en su propio camino al cambiar de proveedor.
+ */
+export const LINE_FILES = Object.freeze(['activity.log'])
+
 export function encryptedFilesIn (dir) {
   let names = []
   try { names = fs.readdirSync(dir) } catch (_) { return [] }
   return names.filter((n) => {
     if (n === CONFIG_FILE || n === WRAPPED_FILE || n === SALT_FILE || n === MACHINE_FILE) return false
+    if (LINE_FILES.includes(n)) return false
     try { return isEncrypted(fs.readFileSync(path.join(dir, n), 'utf8')) } catch (_) { return false }
   })
 }
 
+/** Las bitácoras presentes en `dir`, con sus líneas. `[]` si no hay ninguna. */
+export function lineFilesIn (dir) {
+  return LINE_FILES.filter((n) => { try { return fs.statSync(path.join(dir, n)).isFile() } catch (_) { return false } })
+}
+
 /**
  * CAMBIAR DE PROVEEDOR: descifra todo con la clave vieja y lo vuelve a cifrar con la nueva.
  *
@@ -219,6 +241,19 @@ export function rekeyDir (dir, newConfig, { password = '' } = {}) {
       throw new KekError('kek-rekey', `cannot decrypt ${n} with the current provider (${oldCfg.provider}): ${e.message}`)
     }
   }
+  // Las bitácoras, por líneas. `decryptText` deja pasar el texto en claro, así que una
+  // mitad vieja sin cifrar cruza intacta y sale cifrada con la clave nueva.
+  const lineFiles = lineFilesIn(dir)
+  const plainLines = new Map()
+  for (const n of lineFiles) {
+    const p = path.join(dir, n)
+    try {
+      const lines = fs.readFileSync(p, 'utf8').split('\n')
+      plainLines.set(n, lines.map((l) => (l ? decryptText(l, oldKey) : l)))
+    } catch (e) {
+      throw new KekError('kek-rekey', `cannot decrypt ${n} with the current provider (${oldCfg.provider}): ${e.message}`)
+    }
+  }
 
   // 2. La clave nueva, todavía sin escribir su envoltorio.
   let newKey; let newBlob = null
@@ -236,6 +271,15 @@ export function rekeyDir (dir, newConfig, { password = '' } = {}) {
     if (decryptText(blob, newKey) !== text) throw new KekError('kek-verify', `re-encryption check failed for ${n}: nothing was written`)
     out.set(n, blob)
   }
+  for (const [n, lines] of plainLines) {
+    const blobs = lines.map((l) => (l ? encryptText(l, newKey) : l))
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i] && decryptText(blobs[i], newKey) !== lines[i]) {
+        throw new KekError('kek-verify', `re-encryption check failed for ${n} (line ${i + 1}): nothing was written`)
+      }
+    }
+    out.set(n, blobs.join('\n'))
+  }
 
   // 4. A disco. Copia de seguridad, temporal, renombrar.
   const backups = []
@@ -266,6 +310,6 @@ export function rekeyDir (dir, newConfig, { password = '' } = {}) {
 
 export default {
   machineKey, kekFor, atRestFor, migrateFile, isEncrypted, encryptText, decryptText,
-  rekeyDir, encryptedFilesIn, readConfig, writeConfig, probe, KekError
+  rekeyDir, encryptedFilesIn, lineFilesIn, LINE_FILES, readConfig, writeConfig, probe, KekError
 }
 export { readConfig, writeConfig, probe, configFromEnv, KekError, CONFIG_FILE, WRAPPED_FILE }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.87.0",
+  "version": "0.89.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

@@ -25,13 +25,15 @@ 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 { dataDir } from './paths.js'
+// EL CANAL LOCAL VA CIFRADO (ver `ipc.js`): por aquí salen la contraseña y los valores.
+import { ipcRead, ipcWrite } from './ipc.js'
 import { assertVar } from './secretsStore.js'
 import { isValidSecretsNs } from './protocol.js'
 import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
 import { encodeInvite, inviteUrl, parseInvite } from '../lib/src/invite.js'
-import { readConfig as readKekConfig, probe as probeKek, rekeyDir, encryptedFilesIn, CONFIG_FILE as KEK_CONFIG_FILE } from '../lib/src/atrest.js'
+import { atRestFor, readConfig as readKekConfig, probe as probeKek, rekeyDir, encryptedFilesIn, CONFIG_FILE as KEK_CONFIG_FILE } from '../lib/src/atrest.js'
 import { VERSION } from './version.js'
 
 const dir = dataDir()
@@ -60,12 +62,7 @@ const withProfile = (obj) => (PROFILE ? { ...obj, profile: PROFILE } : obj)
  * 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 writeReq = (name, obj) => ipcWrite(path.join(dir, name), withProfile({ ...obj, at: Date.now() }))
 
 const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
 const D = '\x1b[2m' // apagado: para el dato que acompaña sin competir con el nombre
@@ -103,7 +100,7 @@ const RESTART_HINT = IN_DOCKER
     : 'cierra el vault y vuelve a arrancarlo'
 
 function readState () {
-  const s = readJson(stateFile, null)
+  const s = ipcRead(stateFile, null)
   if (!s) {
     console.error('El vault no parece haber arrancado todavía (no hay state.json en %s).', dir)
     console.error('Arráncalo:  %s', START_HINT)
@@ -318,7 +315,7 @@ async function cmdPair (args = []) {
   let pair = null
   for (let i = 0; i < 50; i++) {
     await sleep(100)
-    const p = readJson(pairFile, null)
+    const p = ipcRead(pairFile, null)
     assertOpen(p) // el candado se contesta por el mismo archivo, para no dejar esperando
     if (p?.expiresAt > Date.now()) { pair = p; break }
   }
@@ -357,7 +354,7 @@ async function cmdPair (args = []) {
   console.log('\nEsperando a que el dispositivo se conecte…  (Ctrl+C para salir)')
   for (let i = 0; i < 1500; i++) { // ~2.5 min
     await sleep(100)
-    const pe = readJson(pendingFile, null)
+    const pe = ipcRead(pendingFile, null)
     if (pe?.deviceId) { showChallenge(pe); return }
   }
   console.log('\nNingún dispositivo se conectó aún. Cuando lo haga:  dotrino-vault pending')
@@ -365,7 +362,7 @@ async function cmdPair (args = []) {
 
 function cmdPending () {
   requireDaemon()
-  const pe = readJson(pendingFile, null)
+  const pe = ipcRead(pendingFile, null)
   if (!pe?.deviceId) { console.log('No hay ningún dispositivo pendiente de aprobar.'); return }
   showChallenge(pe)
 }
@@ -441,7 +438,7 @@ async function cmdJoin (rest) {
   let visto = null
   for (let i = 0; i < 900; i++) {          // hasta 3 min: hay un humano tipeando al otro lado
     await sleep(200)
-    const d = readJson(res, null)
+    const d = ipcRead(res, null)
     if (!d) continue
     if (d.code && d.code !== visto) {
       visto = d.code
@@ -485,7 +482,7 @@ async function cmdMe () {
   writeReq('me-request.json', {})
   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 } }
+  for (let n = 0; n < 50; n++) { await sleep(100); const d = ipcRead(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) }
@@ -535,7 +532,7 @@ async function cmdMembers () {
   writeReq('dump-request.json', {})
   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 } }
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = ipcRead(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 }
@@ -615,7 +612,7 @@ async function findMember (id) {
   writeReq('dump-request.json', {})
   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 } }
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = ipcRead(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) }
@@ -695,7 +692,7 @@ async function cmdDevices () {
   writeReq('dump-request.json', {}) // de qué perfil queremos los dispositivos
   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 } }
+  for (let i = 0; i < 50; i++) { await sleep(100); const d = ipcRead(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 || []
@@ -775,6 +772,29 @@ function profileDir () {
 
 // DE DÓNDE SALE la clave que cifra el disco (`lib/src/kek.js`). Por defecto se deriva de
 // esta máquina; se puede pasar a un KMS, y entonces una copia del disco deja de servir.
+/**
+ * Archivos de un directorio que NO van cifrados y no tienen por qué estar ahí.
+ *
+ * La lista de excepciones es la misma que justifica el smoke `reposo.mjs` de
+ * `dotrino-test`: el salt y la huella son material del propio cifrado, el candado se lee
+ * antes de tener clave, `key.json` es una pública que dice de quién es la carpeta, y las
+ * preferencias no son de nadie. Todo lo demás en claro es un hallazgo.
+ */
+function enClaroEn (d) {
+  const OK = new Set(['atrest.salt', 'atrest.machine', 'atrest.kek', 'atrest.json', 'vault.lock', 'prefs.json', 'key.json'])
+  let names = []
+  try { names = fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name) } catch (_) { return [] }
+  return names.filter((n) => {
+    if (OK.has(n) || n.endsWith('.tmp')) return false
+    try {
+      const texto = fs.readFileSync(path.join(d, n), 'utf8')
+      if (!texto.trim()) return false
+      // La bitácora va cifrada línea a línea: basta con mirar la primera.
+      return !(n === 'activity.log' ? (texto.split('\n')[0] || '') : texto).startsWith('DOTRINO-ATREST-v1.')
+    } catch (_) { return false }
+  })
+}
+
 function cmdAtrest (rest) {
   // OJO: la clave es POR PERFIL. `dir` aquí dentro es el del perfil al que apunta el
   // comando (--profile, o el activo); la raíz de la bóveda es otra cosa y tiene la suya.
@@ -795,6 +815,20 @@ function cmdAtrest (rest) {
     }
     console.log('Archivos cifrados: ' + (archivos.length ? archivos.join(', ') : 'ninguno todavía'))
 
+    // Y LO QUE NO LO ESTÁ, que es la mitad que faltaba: listar lo cifrado no dice nada de
+    // lo que quedó fuera. Así apareció `profiles.json.pre041.bak` —un respaldo que una
+    // 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 [donde, d] of [['este perfil', dir], ['la raíz de la bóveda', vaultRoot]]) {
+      const sueltos = enClaroEn(d)
+      if (sueltos.length) {
+        console.log('')
+        console.log(`${R}En claro en ${donde}:${Z} ` + sueltos.join(', '))
+        console.log('  Si es un respaldo de una migración terminada, bórralo: no lo cifra nadie.')
+      }
+    }
+
     // ES POR PERFIL, y eso hay que verlo: en la misma bóveda un perfil puede ir con KMS
     // y el de al lado con la clave de la máquina. Sin esta lista, «lo puse en el KMS» es
     // una creencia y no un hecho comprobable.
@@ -898,6 +932,10 @@ function cmdActivity (n = 30) {
   try { lines = fs.readFileSync(f, 'utf8').trim().split('\n').filter(Boolean) } catch {
     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 } })
   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 {
@@ -1011,7 +1049,7 @@ async function cmdSecret (rest) {
     sendSignal(s.pid, 'SIGUSR2')
     for (let i = 0; i < 50; i++) {
       await sleep(100)
-      const d = readJson(secretsListFile, null)
+      const d = ipcRead(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) }
@@ -1056,8 +1094,8 @@ async function cmdSecret (rest) {
     '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 al entregarla se te pide APROBACIÓN. Las dos se',
-    'guardan cifradas igual y ninguna enseña su valor en la consola. Se nace privada.'
+    'Pública o privada dice DOS cosas: si al entregarla se te pide APROBACIÓN, y si quien',
+    'administra puede ver su valor. Las dos se guardan cifradas igual. Se nace privada.'
   ].join('\n')
 
   /**
@@ -1112,12 +1150,12 @@ async function cmdSecret (rest) {
   /**
    * Una variable en la lista: su nombre, y que TIENE valor. Ninguna lo enseña.
    *
-   * La pública lo enseñaba, porque se guardaba en claro. Desde 2026-09-02 las dos van
-   * selladas igual y `pública` solo dice que se entrega sin pedir aprobación (dueño: «la
-   * única diferencia es si se despachan o no, son políticas»). Enseñar el hueco vacío de
-   * una pública era peor que no enseñar nada: parecía que se había perdido.
+   * Las dos van selladas igual desde 2026-09-02. Lo que las separa es que a quien administra
+   * se le hace la envoltura de las PÚBLICAS y la bóveda le manda su sobre, así que puede
+   * abrirlas; de una privada de un cajón con dueño no tiene envoltura ni recibe sobre.
    */
-  const printVar = (k) => console.log('  · %s   ••••••%s', k.key, k.public ? '   (pública)' : '')
+  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
@@ -1187,7 +1225,7 @@ async function cmdSecret (rest) {
     // QUÉ SIGNIFICA HOY (dueño, 2026-09-02): todas se guardan selladas igual, y `pública`
     // solo dice a quién se le entrega SIN APROBACIÓN. Decir «su valor se puede ver» era
     // verdad cuando se guardaba en claro; dejarlo ahí sería prometer algo que ya no pasa.
-    console.log('\n(pública) = se entrega sin pedirte aprobación. Todas se guardan cifradas igual.\n')
+    console.log('\n(pública) = se entrega sin pedirte aprobación y quien administra puede leerla. Todas van cifradas.\n')
     printPending(d)
     await printNoPassword()
     return
@@ -1335,7 +1373,7 @@ async function profileRequest (op, extra = {}) {
   sendSignal(s.pid, 'SIGUSR2')
   for (let i = 0; i < 100; i++) {
     await sleep(100)
-    const d = readJson(profilesFile, null)
+    const d = ipcRead(profilesFile, null)
     if (d?.at) return d
   }
   console.error('El daemon no respondió.'); process.exit(1)

package/src/daemon.js

@@ -18,12 +18,14 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { takeLock } from '../lib/src/lock.js'
 import { startVaultManager } from './manager.js'
-import { dataDir, writeJson, readJson } from './paths.js'
+import { dataDir } from './paths.js'
+// EL CANAL LOCAL VA CIFRADO: por aquí pasan la contraseña, los valores y las invitaciones.
+import { ipcRead, ipcWrite } from './ipc.js'
 import { parseInvite } from '../lib/src/invite.js'
 import { watchBinary } from './selfupdate.js'
 import { VERSION } from './version.js'
 
-const readJsonSafe = (f) => readJson(f, null)
+const readJsonSafe = (f) => ipcRead(f, null)
 const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
 
 /**
@@ -73,7 +75,7 @@ export async function runDaemon () {
   // Cuando un dispositivo pide enrolarse, exponemos su deviceId (y a QUÉ perfil
   // quiere entrar) para que el dueño lo compare con el del dispositivo y apruebe.
   const onEnrollChallenge = ({ deviceId, scope, profile, profileName }) => {
-    writeJson(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName })
+    ipcWrite(pendingEnrollFile, { v: 2, at: Date.now(), deviceId, scope, profile, profileName })
   }
 
   const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })
@@ -86,7 +88,7 @@ export async function runDaemon () {
   // en `profiles`.
   const writeState = () => {
     const cur = mgr.summary().find((p) => p.current) || {}
-    writeJson(stateFile, {
+    ipcWrite(stateFile, {
       v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
       proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
       // Cuánto aguanta abierto el candado sin usarse. Va en la foto para que la consola
@@ -103,7 +105,7 @@ export async function runDaemon () {
   // contesta a lo mío». Sin esa marca, un repaso que caía en medio pasaba por respuesta:
   // el `unlock` se daba por hecho con la foto de cuando aún estaba cerrada, y un
   // «contraseña incorrecta» se perdía por el camino sin que nadie lo llegara a ver.
-  const dumpProfiles = (extra = {}) => { writeState(); writeJson(profilesFile, { v: 1, at: Date.now(), req: null, current: mgr.currentId(), profiles: mgr.summary(), ...extra }) }
+  const dumpProfiles = (extra = {}) => { writeState(); ipcWrite(profilesFile, { v: 1, at: Date.now(), req: null, current: mgr.currentId(), profiles: mgr.summary(), ...extra }) }
 
   console.log(`dotrino-vault · datos en ${dir} · proxy ${proxyUrl}`)
   for (const p of mgr.summary()) {
@@ -174,7 +176,7 @@ export async function runDaemon () {
       if (locked?.locked) {
         // Se responde por el MISMO archivo que espera quien pidió el QR: si no, se queda
         // mirando una pantalla vacía hasta que se agote el tiempo, sin saber por qué.
-        writeJson(pairFile, { v: 2, at: Date.now(), profile: locked.id, locked: true })
+        ipcWrite(pairFile, { v: 2, at: Date.now(), profile: locked.id, locked: true })
         return console.error('[vault] profile %s is locked: pairing refused', locked.id)
       }
       const vault = targetOf(pairReq)
@@ -189,7 +191,7 @@ export async function runDaemon () {
       const ALLOWED = (x) => x === 'vault:sign' || x === 'vault:read' || x === 'vault:store' || /^vault:secrets:[a-z0-9-]{1,32}$/.test(x)
       const asked = Array.isArray(pairReq?.scope) ? pairReq.scope.filter((x) => typeof x === 'string') : null
       if (asked && asked.some((x) => !ALLOWED(x))) {
-        writeJson(pairFile, { v: 2, at: Date.now(), error: 'scope not allowed: ' + asked.filter((x) => !ALLOWED(x)).join(',') })
+        ipcWrite(pairFile, { v: 2, at: Date.now(), error: 'scope not allowed: ' + asked.filter((x) => !ALLOWED(x)).join(',') })
         return console.error('[vault] pairing refused: scope not allowed (%s)', asked.join(','))
       }
       const scope = asked?.length
@@ -213,7 +215,7 @@ export async function runDaemon () {
       //               crea uno vacío), o no habría dónde meterla.
       const mode = pairReq?.mode === 'adopt' ? 'adopt' : 'join'
       const { qr, expiresInMs } = await vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName })
-      writeJson(pairFile, { v: 2, at: Date.now(), qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
+      ipcWrite(pairFile, { v: 2, at: Date.now(), qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
       // El token es un secreto efímero: no debe quedar en disco más allá de su
       // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
       const tok = qr.token
@@ -394,7 +396,7 @@ export async function runDaemon () {
         // esta consola: quien aprobaba desde la TUI leía «Dispositivo aprobado», el
         // pendiente desaparecía de la pantalla y el aparato seguía esperando al otro lado
         // sin que nadie pudiera reintentar.
-        const answer = (extra) => writeJson(approveFile, { v: 1, at: Date.now(), req: appr.id || null, ...extra })
+        const answer = (extra) => ipcWrite(approveFile, { v: 1, at: Date.now(), req: appr.id || null, ...extra })
         try {
           const vault = targetOf(appr)
           if (!vault) throw Object.assign(new Error('profile locked'), { code: 'PROFILE_LOCKED' })
@@ -482,7 +484,7 @@ export async function runDaemon () {
           const off = id.onVault?.((e) => {
             if (e?.phase === 'challenge' && e.code) {
               console.log('[vault] type this code in the other vault:  %s', e.code)
-              writeJson(joinResFile, { at: Date.now(), code: e.code, state: 'waiting', profile: p.id })
+              ipcWrite(joinResFile, { at: Date.now(), code: e.code, state: 'waiting', profile: p.id })
             }
           })
           // `'current'` y no `'new'`: el perfil que se acaba de crear ES el sitio, y su
@@ -498,13 +500,13 @@ export async function runDaemon () {
           // vacío no es más que un accidente del primer arranque.
           try { mgr.profiles.setCurrent(p.id) } catch (_) {}
           console.log('[vault] joined the account of the other vault (record #%s) as profile %s (now the active one)', r?.acta?.seq ?? '?', p.id)
-          writeJson(joinResFile, { at: Date.now(), state: 'done', seq: r?.acta?.seq ?? null, profile: p.id })
+          ipcWrite(joinResFile, { at: Date.now(), state: 'done', seq: r?.acta?.seq ?? null, profile: p.id })
         } catch (e) {
           console.error('[vault] could not join:', e.message)
           // El perfil nació para esto y está vacío: si el intento no llegó a término se va
           // con él. Si no, cada reintento dejaba una cuenta fantasma en el conmutador.
           if (nacido) { try { await mgr.remove(nacido) } catch (_) {} }
-          writeJson(joinResFile, { at: Date.now(), state: 'error', error: e.message })
+          ipcWrite(joinResFile, { at: Date.now(), state: 'error', error: e.message })
         }
       }
       // Secretos: `secret set/rm` (por SCOPE) y `secret device set/rm` (por APARATO),
@@ -641,12 +643,12 @@ export async function runDaemon () {
         // nombres de variables, ni acta. Antes el candado no tapaba ninguna de las tres.
         const closed = { v: 1, at: Date.now(), req: reqId, profile: t.id, locked: true }
         if (dumpReq) {
-          writeJson(secretsListFile, { ...closed, ns: {}, dev: [] })
-          writeJson(devFile, { ...closed, issued: [], revoked: [] })
-          writeJson(path.join(dir, 'acta.json'), { ...closed, members: [] })
+          ipcWrite(secretsListFile, { ...closed, ns: {}, dev: [] })
+          ipcWrite(devFile, { ...closed, issued: [], revoked: [] })
+          ipcWrite(path.join(dir, 'acta.json'), { ...closed, members: [] })
         }
         rm(meReqFile)
-        if (meReq) writeJson(meFile, { ...closed, req: meReq.id || null, me: null })
+        if (meReq) ipcWrite(meFile, { ...closed, req: meReq.id || null, me: null })
         return
       }
       if (dumpReq) {
@@ -658,7 +660,7 @@ export async function runDaemon () {
         // en cuanto lo tiene). Es material que su dueño marcó como mostrable, y aquí ya
         // viaja a un navegador; lo que NO puede pasar es que se quede en el disco esperando
         // a que alguien copie la carpeta, porque eso sí burlaría el cifrado en reposo.
-        writeJson(secretsListFile, {
+        ipcWrite(secretsListFile, {
           v: 2, at: Date.now(), req: reqId, profile: t.id,
           ns: t.vault.listSecrets(),
           dev: await t.vault.listDeviceSecrets(),
@@ -676,9 +678,9 @@ export async function runDaemon () {
         lastSecretError = null
         lastSecretValue = null
         lastSecretHistory = null
-        writeJson(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
+        ipcWrite(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
         // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
-        try { writeJson(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
+        try { ipcWrite(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
       }
 
       // PERFIL del usuario (apodo, foto, datos) tal como lo tiene la bóveda: `dotrino-vault me`.
@@ -692,7 +694,7 @@ export async function runDaemon () {
           const tm = resolveTarget(meReq) || { id: mgr.currentId(), vault: mgr.current() }
           const { me } = tm.vault.threads.methods.profileGet()
           const { avatar, ...rest } = me || {}
-          writeJson(meFile, { v: 1, at: Date.now(), req: meReq.id || null, profile: tm.id, me: me ? { ...rest, avatar: avatarInfo(avatar) } : null })
+          ipcWrite(meFile, { v: 1, at: Date.now(), req: meReq.id || null, profile: tm.id, me: me ? { ...rest, avatar: avatarInfo(avatar) } : null })
         } catch (e) { console.error('[vault] could not dump the profile:', e.message) }
       }
     } catch (e) {
@@ -806,8 +808,8 @@ export async function runDaemon () {
     const hecho = readJsonSafe(marca)
     if (hecho?.sn === qr.sn) return // ya se usó: un reinicio no vuelve a pedir entrar
 
-    writeJson(marca, { at: Date.now(), sn: qr.sn, ...(qr.iss ? { iss: qr.iss } : {}) })
-    writeJson(path.join(dir, 'join-request.json'), {
+    ipcWrite(marca, { at: Date.now(), sn: qr.sn, ...(qr.iss ? { iss: qr.iss } : {}) })
+    ipcWrite(path.join(dir, 'join-request.json'), {
       qr,
       label: 'bóveda',
       ...(process.env.DOTRINO_JOIN_NAME ? { name: process.env.DOTRINO_JOIN_NAME } : {})

package/src/ipc.js

@@ -0,0 +1,41 @@
+/**
+ * ipc.js — el CANAL LOCAL entre el daemon y la CLI, **cifrado en reposo**.
+ *
+ * El daemon y el `dotrino-vault` de tu shell no hablan por un socket: se dejan archivos
+ * JSON en el directorio de datos (`state.json`, `acta.json`, `secret-request.json`…, ver
+ * la cabecera de `daemon.js`). Ese contrato es cómodo y no escucha en ningún puerto, pero
+ * durante meses **fue el único sitio del vault que escribía en claro**, y por ahí pasa de
+ * todo:
+ *
+ *   · `secret-request.json`  la CONTRASEÑA del perfil y el VALOR de lo que se guarda
+ *   · `secrets-list.json`    el valor recién destapado, esperando a que la CLI lo recoja
+ *   · `pair.json`            la invitación de emparejamiento, que es un secreto
+ *   · `acta.json`/`devices.json`  quién es miembro, con qué permisos y qué certificados
+ *   · `me.json`, `profiles-list.json`  el perfil y las públicas maestras de cada uno
+ *
+ * Que los archivos fueran efímeros no salvaba nada: se escriben en el disco igual, y un
+ * `rm` no borra lo que ya se copió. Ahora van por el MISMO cifrado en reposo que el resto
+ * (`atrest.js`), que es lo correcto aquí y no un apaño: los dos extremos corren en esta
+ * máquina y con este usuario, así que comparten la clave sin negociar nada.
+ *
+ * **Por qué no un sobre.** Un sobre se cierra contra la pública de quien va a abrirlo, y
+ * el que abre esto es tu CLI, que no tiene llave propia — inventarle una la dejaría en el
+ * mismo disco y al lado, que es exactamente lo que no protege de nada. El sobre es para lo
+ * que VIAJA a otro; para lo que se queda en la máquina, el reposo.
+ *
+ * Ojo con el dir: todos estos archivos cuelgan del directorio raíz, así que la clave sale
+ * de ahí (`path.dirname`). Un archivo de perfil tiene otro salt y NO se lee con esta.
+ */
+import path from 'node:path'
+import { atRestFor } from './atrest.js'
+import { readJson, writeJson } from './paths.js'
+
+const codecOf = (file) => atRestFor(path.dirname(file))
+
+/** Lee un archivo del canal. `fallback` si no está o no se puede abrir. */
+export const ipcRead = (file, fallback = null) => readJson(file, fallback, codecOf(file))
+
+/** Escribe un archivo del canal, cifrado y 0600 (atómico: tmp + rename). */
+export const ipcWrite = (file, obj) => writeJson(file, obj, codecOf(file))
+
+export default { ipcRead, ipcWrite }

package/src/node-globals.js

@@ -8,14 +8,25 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import WebSocket from 'ws'
+import { atRestFor } from './atrest.js'
 
-/** localStorage síncrono respaldado por un archivo JSON (solo lo que usan los paquetes). */
+/**
+ * localStorage síncrono respaldado por un archivo JSON (solo lo que usan los paquetes)
+ * **y cifrado en reposo**.
+ *
+ * Lo de cifrarlo no es celo: aquí `@dotrino/proxy-client` guarda su par de transporte, y
+ * ese par lleva su PRIVADA. Era el único archivo del vault con una llave privada en claro
+ * en el disco. No firma nada que el acta reconozca —quien habla por la bóveda es la llave
+ * de comunicación (`commKey.js`)—, pero sí es la identidad con la que esta bóveda se
+ * sienta en el proxio: con ella se ocupa su sitio y su cola de mensajes.
+ */
 export function fileLocalStorage (filePath) {
+  const atRest = atRestFor(path.dirname(filePath))
   let data = {}
-  try { if (fs.existsSync(filePath)) data = JSON.parse(fs.readFileSync(filePath, 'utf8')) || {} } catch (_) {}
+  try { if (fs.existsSync(filePath)) data = JSON.parse(atRest.decrypt(fs.readFileSync(filePath, 'utf8'))) || {} } catch (_) {}
   const flush = () => {
     fs.mkdirSync(path.dirname(filePath), { recursive: true })
-    fs.writeFileSync(filePath, JSON.stringify(data), { mode: 0o600 })
+    fs.writeFileSync(filePath, atRest.encrypt(JSON.stringify(data)), { mode: 0o600 })
   }
   return {
     getItem: (k) => (k in data ? data[k] : null),

package/src/secretsStore.js

@@ -618,6 +618,24 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       return { gen }
     },
 
+    /**
+     * LA ENTRADA TAL CUAL (sobre, generación, visibilidad) — sin abrir nada.
+     *
+     * Es lo que hace falta para MANDARLE a alguien una variable que sí puede leer: el sobre
+     * viaja cerrado y lo abre en su casa, con su envoltura. Aquí no se descifra.
+     */
+    entryOf (owner, key) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      return varsOf(bag, k)[key] || null
+    },
+    /** La envoltura de ESA generación para ESE miembro, o `null` si no la tiene. */
+    wrapOf (owner, gen, memberPub) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      return (bag[k]?.keyring || []).find((g) => g.gen === gen)?.wraps?.[memberPub] || null
+    },
+
     /**
      * ¿EXISTE YA ESTA VARIABLE? Sin abrirla ni decir qué vale.
      *

package/src/vault.js

@@ -321,15 +321,30 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // AUDITORÍA: bitácora de actividad de seguridad (activity.log, JSONL) — qué
   // dispositivo firmó/renovó/enroló y qué se rechazó. `dotrino-vault activity`
   // la muestra. Sin contenido de payloads (privacidad): solo op, dispositivo, hora.
+  //
+  // VA CIFRADA, y una línea a la vez. Antes era el único archivo excluido del reposo, con
+  // el argumento de que «no guarda payloads»: no guarda valores, pero sí el mapa entero de
+  // la cuenta —qué aparatos hay, con qué permisos, contra qué cajones y a qué hora—, que
+  // es justo lo que quiere quien está eligiendo por dónde entrar. Y encima se creaba 0664,
+  // legible por cualquier usuario de la máquina.
+  //
+  // Cifrar por línea (y no el archivo entero) es lo que deja seguir AÑADIENDO: cada
+  // entrada se cierra sola, así que un `appendFileSync` sigue costando lo mismo y la
+  // rotación no necesita abrir nada.
   const activityFile = path.join(dir, 'activity.log')
+  const activityAtRest = atRestFor(dir)
   const audit = (op, info = {}) => {
     try {
-      fs.appendFileSync(activityFile, JSON.stringify({ ts: Date.now(), op, ...info }) + '\n')
+      const line = activityAtRest.encrypt(JSON.stringify({ ts: Date.now(), op, ...info }))
+      fs.appendFileSync(activityFile, line + '\n', { mode: 0o600 })
+      // 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'))
+        fs.writeFileSync(activityFile, lines.slice(Math.floor(lines.length / 2)).join('\n'), { mode: 0o600 })
       }
     } catch (_) {}
   }
@@ -1358,14 +1373,21 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
 
   const varsDesk = {
-    async list () {
-      // `listSecrets`/`listDeviceSecrets` ya traen el valor de las públicas y solo de esas:
-      // la frontera se decide en un sitio, y lo mismo ve el dueño en su terminal que aquí.
+    async list ({ caller = null } = {}) {
+      // EL VAULT DECIDE QUÉ ENVÍA PARA LEER (dueño, 2026-09-02: «la consola debe tener todos
+      // los sobres; la diferencia es si el vault se los envía para la lectura o no»).
+      //
+      // Tener la envoltura y recibir el sobre son dos cosas: quien administra tiene la
+      // envoltura de cada PÚBLICA, y por eso aquí se le manda el sobre de esas y solo de
+      // esas. Las privadas de un cajón con dueño no se mandan — y aunque se mandaran no
+      // 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 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({
-          ns: listSecrets(), dev: await listDeviceSecrets(),
+          ns: conSobres(listSecrets(), 'ns', caller), dev: conSobres(await listDeviceSecrets(), 'dev', caller),
           // Aparatos que están en el acta pero no pueden abrir lo suyo: hay que
           // enseñarlo donde se administra, no solo en el log del servicio.
           incomplete: await incompleteMembers(),
@@ -1572,7 +1594,18 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    */
   async function nsMembers (ns) {
     const record = (await identity.profileActa?.().catch(() => null))?.acta
-    return (record?.members || []).filter((m) => m.cn === ns)
+    if (!record) return []
+    // LLEVAR EL `cn` NO ES PODER LEER. El acta manda también aquí: un miembro entra en la
+    // 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']`,
+    // así que un cajón llamado `vault` —nombre perfectamente válido— la contaba entre sus
+    // dueños. No llegaba a recibir sobre (no tiene `encPub`, y `recipientsFor` los filtra),
+    // pero la salvaguarda era un accidente: bastaba que alguien le apuntara una `encPub`
+    // para envolverle la llave a la llave que firma con la bóveda CERRADA. Se comprueba el
+    // permiso, que es lo que de verdad se quería preguntar.
+    return (record.members || []).filter((m) => m.cn === ns && Acta.memberCanReadSecrets(record, m.pub, ns))
   }
 
   /**
@@ -2327,6 +2360,34 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * de esta máquina»: taparlo justo aquí —en la máquina donde vive, delante de su dueño—
    * era lo único que la marca no significaba. La consola remota ya las enseña.
    */
+  /**
+   * LE PONE A CADA PÚBLICA SU SOBRE Y LA ENVOLTURA DE QUIEN PREGUNTA, para que pueda leerla.
+   *
+   * Solo a las públicas: es la política de despacho, y es lo único que cambia entre una y
+   * otra. A una privada no se le manda nada — y aunque se le mandara, quien administra no
+   * tiene su envoltura en un cajón con dueño, así que no la abriría igual.
+   *
+   * Si falta la envoltura de quien pregunta (todavía no se le ha hecho, o el cajón se
+   * escribió antes de que entrara) se manda la variable SIN sobre: se ve que existe y que es
+   * 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 conSobres = (lista, tipo, caller) => {
+    if (!caller) return lista
+    const dar = (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
+      return e?.e && wrap ? { ...k, e: e.e, wrap } : k
+    }
+    if (tipo === 'ns') {
+      const out = {}
+      for (const [ns, keys] of Object.entries(lista)) out[ns] = keys.map((k) => dar(`ns:${ns}`, k))
+      return out
+    }
+    return lista.map((row) => ({ ...row, keys: row.keys.map((k) => dar(`dev:${row.pub}`, k)) }))
+  }
+
   function listSecrets () {
     // YA NO SE ENSEÑA EL VALOR DE UNA PÚBLICA (dueño, 2026-09-02). Desde que todas van en
     // sobre, «pública» dejó de significar «en claro»: dice a quién se le despacha sin

package/src/vaultControl.js

@@ -19,7 +19,9 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { pubkeyId } from '@dotrino/identity/capabilities'
-import { dataDir, readJson } from './paths.js'
+import { dataDir } from './paths.js'
+// El canal local va cifrado en reposo (ver `ipc.js`).
+import { ipcRead, ipcWrite } from './ipc.js'
 import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 
 const dir = dataDir()
@@ -49,7 +51,7 @@ const F = {
 }
 
 const p = (name) => path.join(dir, name)
-const read = (name, fb = null) => readJson(p(name), fb)
+const read = (name, fb = null) => ipcRead(p(name), fb)
 const rm = (name) => { try { fs.rmSync(p(name), { force: true }) } catch (_) {} }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
@@ -120,12 +122,10 @@ async function writeReq (name, obj, profile) {
   // nadie, se perdía: quien la había pedido esperaba seis segundos y leía «el daemon no
   // respondió», con el daemon sano. `rename` es atómico dentro del mismo sistema de
   // archivos, así que el vigilante o no ve nada, o ve la petición ENTERA.
-  const tmp = p(name) + '.tmp'
-  fs.writeFileSync(tmp, JSON.stringify(body), { mode: 0o600 })
-  fs.renameSync(tmp, p(name))
-  // `mode` de writeFileSync solo aplica al CREAR: re-chmod por si el archivo ya
-  // existía con permisos más laxos (defensa en profundidad; el dir ya es 0700).
-  try { fs.chmodSync(p(name), 0o600) } catch (_) {}
+  // `ipcWrite` hace las tres cosas: cifra en reposo, escribe en tmp y renombra, y deja
+  // el archivo en 0600 (el `mode` de `writeFileSync` solo aplica al CREAR, así que
+  // re-chmodea por si ya existía con permisos más laxos).
+  ipcWrite(p(name), body)
   return id
 }