@dotrino/vaultd 0.6.0

package/src/tui/term.js

@@ -0,0 +1,278 @@
+/**
+ * term.js — toolkit de terminal a pantalla completa, SIN dependencias.
+ *
+ * Dibuja con escapes ANSI y lee el teclado en raw mode (mismo enfoque que el
+ * lector de contraseña de la CLI, `ctl.js`). No usamos librerías de terceros: el
+ * vault custodia la maestra y su superficie de dependencias se mantiene mínima
+ * (regla de cadena de suministro, CONVENCIONES §1.1).
+ *
+ * API:
+ *   const term = createTerm()
+ *   term.size() -> { cols, rows }
+ *   await term.readKey() -> { name, ch? }   (up/down/left/right/enter/backspace/
+ *                                            escape/tab/char/ctrl-c/…/resize)
+ *   term.render(lines)   // lines: string[]; posiciona, recorta y limpia el resto
+ *   term.close()         // restaura el terminal SIEMPRE (idempotente)
+ *   term.t              // helpers de estilo/ancho (ver `theme`)
+ */
+
+import { StringDecoder } from 'node:string_decoder'
+
+const ESC = '\x1b'
+const CSI = ESC + '['
+
+const supportsColor = () =>
+  process.stdout.isTTY && process.env.NO_COLOR == null && process.env.TERM !== 'dumb'
+
+// -------- ancho visible (ignora escapes ANSI, cuenta emojis/CJK como 2) --------
+
+const ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]/g
+export const stripAnsi = (s) => String(s).replace(ANSI_RE, '')
+
+function charWidth (cp) {
+  if (cp === 0) return 0
+  if (cp < 32 || (cp >= 0x7f && cp < 0xa0)) return 0
+  if (cp >= 0x300 && cp <= 0x36f) return 0 // combinantes
+  if (cp === 0x200d || cp === 0xfe0f || cp === 0xfe0e) return 0 // ZWJ + selectores de variación
+  if (
+    (cp >= 0x1100 && cp <= 0x115f) ||
+    (cp >= 0x231a && cp <= 0x231b) || // ⌚⌛
+    (cp >= 0x23e9 && cp <= 0x23fa) || // ⏩…⏺ (incluye ⏳ reloj de arena)
+    (cp >= 0x2e80 && cp <= 0xa4cf && cp !== 0x303f) ||
+    (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) ||
+    (cp >= 0xfe30 && cp <= 0xfe6f) ||
+    (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) ||
+    (cp >= 0x1f000 && cp <= 0x1faff) ||
+    (cp >= 0x2600 && cp <= 0x27bf) // símbolos misc + dingbats (✓ ✗ ⚠ …)
+  ) return 2
+  return 1
+}
+
+/** Ancho visible de una string (sin contar escapes ANSI). */
+export function widthOf (s) {
+  let w = 0
+  for (const ch of stripAnsi(s)) w += charWidth(ch.codePointAt(0))
+  return w
+}
+
+/** Recorta a `max` columnas visibles, preservando escapes y cerrando color. */
+export function trunc (s, max) {
+  if (max <= 0) return ''
+  let out = ''
+  let w = 0
+  let hadStyle = false
+  let i = 0
+  const str = String(s)
+  while (i < str.length) {
+    if (str[i] === '\x1b') {
+      const m = str.slice(i).match(/^\x1b\[[0-9;?]*[A-Za-z]/)
+      if (m) { out += m[0]; hadStyle = true; i += m[0].length; continue }
+    }
+    const cp = str.codePointAt(i)
+    const ch = String.fromCodePoint(cp)
+    const cw = charWidth(cp)
+    if (w + cw > max) { out += hadStyle ? CSI + '0m' : ''; return out }
+    out += ch; w += cw; i += ch.length
+  }
+  return out
+}
+
+/** Rellena con espacios hasta `width` columnas visibles (para barras sólidas). */
+export function padEnd (s, width) {
+  const w = widthOf(s)
+  return w >= width ? trunc(s, width) : s + ' '.repeat(width - w)
+}
+
+// ------------------------------- tema/estilos -------------------------------
+
+export function makeTheme () {
+  const on = supportsColor()
+  const sgr = (...c) => (on ? CSI + c.join(';') + 'm' : '')
+  const R = on ? CSI + '0m' : ''
+  const wrap = (open) => (s) => on ? open + s + R : s
+  return {
+    on,
+    reset: R,
+    bold: wrap(sgr(1)),
+    dim: wrap(sgr(2)),
+    accent: wrap(sgr(38, 5, 44)), // cian
+    ok: wrap(sgr(38, 5, 114)), // verde
+    warn: wrap(sgr(38, 5, 214)), // ámbar
+    danger: wrap(sgr(38, 5, 203)), // rojo
+    muted: wrap(sgr(38, 5, 244)), // gris
+    title: wrap(sgr(1) + sgr(38, 5, 81)),
+    /**
+     * Barra sólida a todo lo ancho (header/ayuda). Se le quita el color interno:
+     * un `\x1b[0m` intermedio cortaría el fondo a media línea.
+     */
+    bar: (text, cols) => {
+      const body = padEnd(' ' + stripAnsi(text), cols) // padEnd RECORTA si excede (ancho visible)
+      return on ? sgr(48, 5, 236) + sgr(38, 5, 252) + body + R : body
+    },
+    /**
+     * Fila seleccionada de una lista: fondo uniforme a todo lo ancho. Se quita el
+     * color interno del texto para que ningún reset intermedio corte el resaltado.
+     */
+    sel: (text, cols) => {
+      const body = padEnd(stripAnsi(text), cols)
+      return on ? sgr(48, 5, 24) + sgr(38, 5, 231) + body + R : CSI + '7m' + body + CSI + '0m'
+    }
+  }
+}
+
+// --------------------------------- teclado ----------------------------------
+
+function parseChunk (s, push) {
+  let i = 0
+  const arrow = { A: 'up', B: 'down', C: 'right', D: 'left', H: 'home', F: 'end' }
+  while (i < s.length) {
+    const c = s[i]
+    if (c === '\x1b') {
+      const n = s[i + 1]
+      if ((n === '[' || n === 'O')) {
+        const third = s[i + 2]
+        if (arrow[third]) { push({ name: arrow[third] }); i += 3; continue }
+        if (/[0-9]/.test(third)) {
+          let j = i + 2; let num = ''
+          while (j < s.length && /[0-9;]/.test(s[j])) { num += s[j]; j++ }
+          const fin = s[j]
+          const seq = { 3: 'delete', 5: 'pageup', 6: 'pagedown', 1: 'home', 4: 'end' }
+          if (fin === '~' && seq[num]) { push({ name: seq[num] }); i = j + 1; continue }
+          i = (fin ? j + 1 : s.length); continue
+        }
+        i += 3; continue
+      }
+      push({ name: 'escape' }); i += 1; continue
+    }
+    if (c === '\r' || c === '\n') { push({ name: 'enter' }); i += 1; if (c === '\r' && s[i] === '\n') i += 1; continue }
+    if (c === '\x7f' || c === '\b') { push({ name: 'backspace' }); i += 1; continue }
+    if (c === '\t') { push({ name: 'tab' }); i += 1; continue }
+    if (c === '\x03') { push({ name: 'ctrl-c' }); i += 1; continue }
+    if (c === '\x04') { push({ name: 'ctrl-d' }); i += 1; continue }
+    if (c === '\x15') { push({ name: 'ctrl-u' }); i += 1; continue }
+    if (c === '\x17') { push({ name: 'ctrl-w' }); i += 1; continue }
+    if (c.charCodeAt(0) < 32) { i += 1; continue }
+    const cp = s.codePointAt(i)
+    const ch = String.fromCodePoint(cp)
+    push({ name: 'char', ch }); i += ch.length
+  }
+}
+
+// -------------------------------- terminal ----------------------------------
+
+export function createTerm () {
+  const out = process.stdout
+  const inp = process.stdin
+  const t = makeTheme()
+
+  // Cola de teclas + notificador. Las teclas SIEMPRE se encolan (no se pierden
+  // aunque venza un tick): `readKey(ms)` drena la cola o despierta por timeout.
+  const queue = []
+  let notify = null
+  const push = (k) => { queue.push(k); if (notify) { const n = notify; notify = null; n() } }
+
+  // Entrada de teclado robusta ante fragmentación (SSH / ptys lentas):
+  //  · StringDecoder reensambla caracteres UTF-8 multibyte partidos entre chunks.
+  //  · Una secuencia de escape incompleta al final del chunk se GUARDA y se
+  //    antepone al siguiente; un ESC solitario se emite tras un breve timeout.
+  const decoder = new StringDecoder('utf8')
+  let pendingEsc = ''
+  let escTimer = null
+  const clearEscTimer = () => { if (escTimer) { clearTimeout(escTimer); escTimer = null } }
+  // Devuelve el índice donde empieza una secuencia de escape INCOMPLETA al final
+  // de `s` (para retenerla), o -1 si no hay nada que retener.
+  const incompleteTailStart = (s) => {
+    const k = s.lastIndexOf('\x1b')
+    if (k < 0) return -1
+    const tail = s.slice(k)
+    if (tail === '\x1b') return k // ESC pelado
+    if (tail[1] === '[') return /[A-Za-z~]/.test(tail.slice(2)) ? -1 : k // CSI sin byte final
+    if (tail[1] === 'O') return tail.length >= 3 ? -1 : k // SS3 sin byte final
+    return -1 // ESC + otra cosa: que lo maneje parseChunk ya mismo
+  }
+  const handleInput = (str) => {
+    clearEscTimer()
+    let s = pendingEsc + str
+    pendingEsc = ''
+    const hold = incompleteTailStart(s)
+    if (hold >= 0) { pendingEsc = s.slice(hold); s = s.slice(0, hold) }
+    if (s) parseChunk(s, push)
+    if (pendingEsc) {
+      // Si nada más llega pronto, era un ESC de verdad (tecla Escape).
+      escTimer = setTimeout(() => { escTimer = null; if (pendingEsc) { pendingEsc = ''; push({ name: 'escape' }) } }, 50)
+      escTimer.unref?.()
+    }
+  }
+
+  const onData = (buf) => handleInput(decoder.write(buf))
+  const onResize = () => push({ name: 'resize' })
+
+  let closed = false
+  const write = (s) => { try { out.write(s) } catch (_) {} }
+
+  function open () {
+    write(CSI + '?1049h') // pantalla alterna
+    write(CSI + '?25l') // ocultar cursor
+    write(CSI + '2J' + CSI + 'H')
+    if (inp.isTTY) inp.setRawMode(true)
+    inp.resume()
+    inp.on('data', onData)
+    out.on('resize', onResize)
+  }
+
+  function close () {
+    if (closed) return
+    closed = true
+    clearEscTimer()
+    try { inp.off('data', onData) } catch (_) {}
+    try { out.off('resize', onResize) } catch (_) {}
+    if (inp.isTTY) { try { inp.setRawMode(false) } catch (_) {} }
+    try { inp.pause() } catch (_) {}
+    write(CSI + '?25h') // mostrar cursor
+    write(CSI + '?1049l') // salir de pantalla alterna
+  }
+
+  // Red de seguridad: restaurar el terminal pase lo que pase (salida normal,
+  // señales de terminación y cierre del terminal —SIGHUP—). En raw mode Ctrl-C
+  // llega como \x03 y lo maneja el loop; el manejador de SIGINT es un respaldo.
+  const onExit = () => close()
+  process.on('exit', onExit)
+  const onKill = (sig, code) => { close(); process.exit(code) }
+  process.on('SIGTERM', () => onKill('SIGTERM', 0))
+  process.on('SIGHUP', () => onKill('SIGHUP', 129))
+  process.on('SIGINT', () => onKill('SIGINT', 130))
+
+  open()
+
+  return {
+    t,
+    size () { return { cols: out.columns || 80, rows: out.rows || 24 } },
+    /**
+     * Espera la próxima tecla. Con `ms`, despierta también por timeout devolviendo
+     * `{ name: 'tick' }` (para refrescar pantallas que esperan un evento externo).
+     */
+    async readKey (ms = 0) {
+      if (queue.length) return queue.shift()
+      let timer = null
+      await new Promise((res) => {
+        notify = res
+        if (ms > 0) timer = setTimeout(() => { if (notify) { notify = null; res() } }, ms)
+      })
+      if (timer) clearTimeout(timer)
+      return queue.length ? queue.shift() : { name: 'tick' }
+    },
+    /** Dibuja `lines` desde arriba; recorta al ancho y limpia lo que sobre. */
+    render (lines) {
+      const { cols } = this.size()
+      let s = CSI + 'H'
+      for (let i = 0; i < lines.length; i++) {
+        s += CSI + (i + 1) + ';1H' + trunc(lines[i] ?? '', cols) + t.reset + CSI + 'K'
+      }
+      s += CSI + 'J' // limpia de la última línea hacia abajo
+      write(s)
+    },
+    close
+  }
+}

package/src/vault.js

@@ -0,0 +1,303 @@
+/**
+ * dotrino-vault — núcleo del certificador personal (daemon headless).
+ *
+ * Custodia la clave MAESTRA del usuario (vía `@dotrino/identity`) y la expone como
+ * CA propia. EMPAREJAMIENTO ENDURECIDO (ver docs/pairing-protocol.md): el token de
+ * 5 min ya NO es autoridad suficiente — para obtener un cert el dispositivo debe
+ * (1) PROBAR posesión de su llave D firmando el ENROLL, y (2) el dueño debe APROBAR
+ * en el PC tras comparar un SAS (código de 6 dígitos) entre las dos pantallas. La
+ * maestra solo firma el cert DESPUÉS de esa aprobación humana.
+ *
+ * Toda la cripto es de `@dotrino/identity`. Este módulo solo orquesta.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { Identity } from '@dotrino/identity/node'
+import { verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
+import * as Acta from '@dotrino/identity/acta'
+import { createEnrollDesk, deviceIdOf } from '../lib/src/enroll.js'
+import { createTransport, masterPubkeyOf } from './transport.js'
+import { openStore } from './store.js'
+import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
+import { openSecretsStore } from './secretsStore.js'
+import { seal } from '../lib/src/sealed.js'
+import { dataDir, ensureDir } from './paths.js'
+import { atRestFor, machineKey, migrateFile } from './atrest.js'
+import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
+
+/**
+ * Abre UN perfil del vault (una maestra, un dir, una conexión al proxy). El
+ * daemon multi-perfil (`manager.js`) levanta uno de estos por perfil.
+ *
+ * @param {Object} [opts]
+ * @param {string} [opts.dir]        Dir de datos de ESTE perfil.
+ * @param {() => boolean} [opts.isLocked]  Candado del perfil (contraseña opcional).
+ *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
+ *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
+ */
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false } = {}) {
+  ensureDir(dir)
+  // CIFRADO EN REPOSO ligado a esta máquina: `identity.json` deja de estar en claro, así
+  // que copiarlo a otro equipo no sirve de nada. No protege contra quien ya tiene ESTA
+  // máquina (puede leer el mismo material); es subir el listón, no una imposibilidad.
+  // La migración verifica antes de reemplazar: si algo falla, el original queda intacto.
+  try {
+    const r = migrateFile(path.join(dir, 'identity.json'), machineKey(dir))
+    if (r === 'migrado') log('[vault] identidad cifrada en reposo (ligada a esta máquina)')
+  } catch (e) { log('[vault] no se pudo cifrar la identidad en reposo:', e.message) }
+  const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
+  if (!identity.me?.publickey) await identity.setMyNickname('')
+
+  const store = openStore(dir)
+  const threads = openThreadStore(dir)
+  const secrets = openSecretsStore(dir)
+  const master = await masterPubkeyOf(identity)
+  const fp = (await pubkeyId(master)).slice(0, 16)
+
+  const { client } = await createTransport({ identity, dir, url: proxyUrl })
+
+  async function revocationSet () {
+    const { revoked } = await identity.listDelegations()
+    return new Set(revoked.map((r) => r.nonce))
+  }
+
+  const reply = (to, obj) => {
+    try { client.send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) }
+  }
+
+  // FRESCURA anti-replay: toda petición firmada debe traer `data.ts` dentro de una
+  // ventana de ±5 min (mismo criterio que el identify del proxy). Sin esto, un
+  // relay malicioso podía REPRODUCIR mensajes firmados viejos (re-pedir firmas,
+  // abrir renovaciones…) durante toda la vida del cert.
+  // 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.
+  const activityFile = path.join(dir, 'activity.log')
+  const audit = (op, info = {}) => {
+    try {
+      fs.appendFileSync(activityFile, JSON.stringify({ ts: Date.now(), op, ...info }) + '\n')
+      // 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'))
+      }
+    } catch (_) {}
+  }
+
+  const FRESH_WINDOW_MS = 5 * 60 * 1000
+  const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
+  const staleReply = (from) => reply(from, { type: MSG.ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
+
+  // --- ENROLL / aprobación / revocación: núcleo COMPARTIDO (lib/src/enroll.js) ---
+  // El mismo módulo lo usan «este dispositivo es bóveda» (@dotrino/vault) y la copia
+  // vendorizada del iframe de identidad: un solo sitio donde vive el flujo, y por lo
+  // tanto un solo sitio donde se comprueba el código antes de firmar el cert.
+  const desk = createEnrollDesk({
+    identity,
+    iss: master,
+    proxy: client.url,
+    send: (to, obj) => reply(to, obj),
+    sendByPubkey: (pub, obj) => client.sendByPubkey(pub, obj),
+    audit,
+    log,
+    defaultScope: [SCOPE.READ],
+    onChallenge ({ deviceId, scope }) {
+      log(`\n[vault] Un dispositivo quiere conectarse:`)
+      log(`        deviceId: ${deviceId}`)
+      log(`        Ingresa el código que MUESTRA el dispositivo:`)
+      log(`          dotrino-vault approve <código>    (o rechaza: dotrino-vault reject ${deviceId})\n`)
+      try { onEnrollChallenge?.({ deviceId, scope }) } catch (_) {}
+    }
+  })
+
+  // --- handleSign / handleGet: idénticos (verifyChain de la cadena D←maestra) ---
+  async function handleSign (from, p) {
+    if (!isFresh(p.data)) { audit('rejected', { what: 'sign', reason: 'stale' }); return staleReply(from) }
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: SCOPE.SIGN, trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) { audit('rejected', { what: 'sign', reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason }) }
+    const toSign = p.data?.payload
+    if (toSign == null) return reply(from, { type: MSG.ERROR, error: 'data.payload requerido' })
+    const { signature, publickey } = await identity.signData(toSign)
+    audit('sign', { device: await deviceIdOf(chk.device) })
+    reply(from, { type: MSG.SIGNED, signature, publickey, device: chk.device })
+  }
+
+  async function handleGet (from, p) {
+    if (!isFresh(p.data)) return staleReply(from)
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: SCOPE.READ, trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    const id = p.data?.id || 'root'
+    reply(from, { type: MSG.DATA, id, node: store.getNode(id) })
+  }
+
+  // Store de hilos+aperturas (Fase 3): escrituras requieren vault:store; lecturas
+  // aceptan vault:store o vault:read. Cada op va firmada por D + cert (cadena D←maestra).
+  async function handleStore (from, p) {
+    const d = p.data
+    if (!d || typeof d.method !== 'string' || !threads.methods[d.method]) {
+      return reply(from, { type: MSG.ERROR, error: 'store: método inválido' })
+    }
+    if (!isFresh(d)) return staleReply(from)
+    // CANDADO del perfil (contraseña opcional): solo frena EDITAR el perfil. Un
+    // dispositivo enrolado puede seguir firmando, leyendo y guardando contenido;
+    // lo que no puede es reescribir quién sos mientras el perfil está bloqueado.
+    if (PROFILE_EDIT_METHODS.has(d.method) && isLocked()) {
+      audit('rejected', { what: 'store', method: d.method, reason: 'locked' })
+      return reply(from, { type: MSG.ERROR, error: 'perfil bloqueado: desbloquéalo en el PC del vault (dotrino-vault unlock) para editarlo' })
+    }
+    const revoked = await revocationSet()
+    let chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.STORE, trustedIssuer: master, revoked })
+    if (!chk.ok && STORE_READ_METHODS.has(d.method)) {
+      chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, expectedScope: SCOPE.READ, trustedIssuer: master, revoked })
+    }
+    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    try {
+      // CIFRADO de punta a punta con la clave de contenido del perfil: el proxy transporta
+      // pero no ve nada de lo que el usuario guarda. Si el dispositivo mandó `enc`, se abre
+      // aquí con la clave de la bóveda (que también es miembro) y la respuesta vuelve igual.
+      let args = d.args || {}
+      let cek = null
+      if (d.enc) {
+        cek = await identity.contentKey?.().catch(() => null)
+        if (!cek) return reply(from, { type: MSG.ERROR, error: 'store: esta bóveda no tiene la clave de contenido del perfil' })
+        args = JSON.parse(await identity.openContent(d.enc))
+      }
+      const result = await threads.methods[d.method](args)
+      if (cek) {
+        const enc = await identity.sealContent(JSON.stringify(result ?? null))
+        return reply(from, { type: MSG.STORE_RESULT, method: d.method, result: { __enc: enc } })
+      }
+      reply(from, { type: MSG.STORE_RESULT, method: d.method, result })
+    } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
+  }
+
+  // Lista (solo lectura) de dispositivos enrolados, para un panel en el navegador.
+  // Cualquier cert válido tuyo puede verla; REVOCAR sigue siendo solo desde el PC.
+  async function handleDevices (from, p) {
+    if (!isFresh(p.data)) return staleReply(from)
+    const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, trustedIssuer: master, revoked: await revocationSet() })
+    if (!chk.ok) return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason })
+    const { issued, revoked } = await identity.listDelegations()
+    // 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.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    // 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
+    // de tragarse un salto a ciegas. Si se salió de la ventana, llega vacía y toca
+    // re-emparejar — que es justo lo que debe pasar.
+    const chain = typeof p.data?.sinceSeq === 'number'
+      ? (await identity.actaHistory({ sinceSeq: p.data.sinceSeq }).catch(() => null))?.chain || null
+      : null
+    // `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
+    // 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
+    })))
+    reply(from, { type: MSG.DEVICES_RESULT, devices, revoked, acta, chain })
+  }
+
+  // RENOVACIÓN automática: un dispositivo con cert VIGENTE y no revocado pide un
+  // cert fresco (misma sub-clave y scope) sin QR ni aprobación — sigue siendo el
+  // mismo dispositivo enrolado, solo extiende la ventana. Un cert vencido o
+  // revocado NO puede renovarse (ahí sí toca re-emparejar con aprobación).
+  const RENEW_TTL_MS = 30 * 24 * 60 * 60 * 1000
+  async function handleRenew (from, p) {
+    if (!isFresh(p.data)) { audit('rejected', { what: 'renew', reason: 'stale' }); return staleReply(from) }
+    const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, trustedIssuer: master, revoked: await revocationSet() })
+    if (!chk.ok) { audit('rejected', { what: 'renew', reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason }) }
+    // Reusar el label del cert original (si sigue registrado en delegations).
+    const { issued } = await identity.listDelegations()
+    const prev = (issued || []).find((x) => x.nonce === p.cert.nonce)
+    const { cert } = await identity.signDelegation(p.cert.sub, p.cert.scope, { ttlMs: RENEW_TTL_MS, label: prev?.label || '' })
+    audit('renew', { device: await deviceIdOf(p.cert.sub), label: prev?.label || '' })
+    log(`[vault] cert renovado para ${await deviceIdOf(p.cert.sub)} (30 días)`)
+    reply(from, { type: MSG.RENEWED, cert })
+  }
+
+  // SECRETOS de servicios: un servicio enrolado (cert `vault:secrets:<ns>`)
+  // pide el bundle de su namespace. La respuesta va SELLADA a la llave ECDH
+  // efímera `ek` que vino en el sobre firmado (el proxy transporta pero no
+  // puede leer los valores) y el cuerpo va FIRMADO por la maestra (el
+  // servicio verifica contra su iss pineada — un relay no puede inyectar
+  // secretos falsos). Replay inerte: cada petición usa una ek nueva.
+  //   data: { op:'secrets', ns, ek, publickey, ts }
+  async function handleSecrets (from, p) {
+    if (!isFresh(p.data)) { audit('rejected', { what: 'secrets', reason: 'stale' }); return staleReply(from) }
+    const ns = p.data?.ns
+    if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: namespace inválido' })
+    if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: falta ek (llave efímera del solicitante)' })
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: secretsScope(ns), trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) { audit('rejected', { what: 'secrets', ns, reason: chk.reason }); return reply(from, { type: MSG.ERROR, error: 'no autorizado: ' + chk.reason }) }
+    // FRONTERA DEL CN (acta): además del scope del cert, el acta tiene que decir que este
+    // miembro es el servicio `ns`. Así el límite no depende solo de qué cert se emitió: la
+    // llave del proxy no ve nada que no sea del proxy, y está escrito donde se puede comprobar.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta
+    if (acta && !Acta.memberCanReadSecrets(acta, chk.device, ns)) {
+      audit('rejected', { what: 'secrets', ns, reason: 'cn' })
+      return reply(from, { type: MSG.ERROR, error: `no autorizado: cn — el acta no reconoce a este miembro como el servicio «${ns}»` })
+    }
+    let enc
+    try {
+      enc = await seal({ ek: p.data.ek, payload: { secrets: secrets.get(ns) } })
+    } catch (e) {
+      return reply(from, { type: MSG.ERROR, error: 'secrets: ek inválida' })
+    }
+    const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
+    const { signature } = await identity.signData(body)
+    audit('secrets', { device: await deviceIdOf(chk.device), ns })
+    reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+  }
+
+  client.on('message', async (from, payload) => {
+    if (!payload || typeof payload !== 'object') return
+    try {
+      if (payload.type === MSG.ENROLL) return await desk.handleEnroll(from, payload)
+      if (payload.type === MSG.SIGN) return await handleSign(from, payload)
+      if (payload.type === MSG.GET) return await handleGet(from, payload)
+      if (payload.type === MSG.STORE) return await handleStore(from, payload)
+      if (payload.type === MSG.DEVICES) return await handleDevices(from, payload)
+      if (payload.type === MSG.RENEW) return await handleRenew(from, payload)
+      if (payload.type === MSG.SECRETS) return await handleSecrets(from, payload)
+    } catch (e) {
+      reply(from, { type: MSG.ERROR, error: e.message })
+    }
+  })
+
+  log(`[vault] listo · id ${fp} · ${store.getTree().children.length} nodos`)
+
+  // ----- API local (CLI/UI de control) -----
+  // Emparejar / aprobar / rechazar / revocar viven en el núcleo compartido (`desk`).
+
+  // API local de secretos (solo CLI/UI del dueño; audita cada cambio).
+  function setSecret (ns, key, value) { secrets.set(ns, key, value); audit('secret.set', { ns, key }) }
+  function deleteSecret (ns, key) { const ok = secrets.delete(ns, key); if (ok) audit('secret.rm', { ns, key }); return ok }
+  function listSecrets () { return secrets.list() }
+
+  return {
+    identity, client, store, threads, secrets, master, fingerprint: fp,
+    startPairing: desk.startPairing,
+    stopPairing: desk.stopPairing,
+    listPending: desk.listPending,
+    approveDevice: (code) => desk.approve(code),
+    rejectDevice: (deviceId) => desk.reject(deviceId),
+    setSecret, deleteSecret, listSecrets,
+    listDevices: () => identity.listDelegations(),
+    // Acta del perfil (quién es del perfil y qué puede cada uno): lo que muestran
+    // `dotrino-vault members` y la consola de vault.dotrino.com.
+    profileMembers: () => identity.profileMembers(),
+    setCaps: (pub, caps) => identity.setCaps(pub, caps),
+    revokeDevice: (nonce) => desk.revoke(nonce),
+    close () { try { client.close() } catch (_) {} identity.destroy() }
+  }
+}