@dotrino/vaultd 0.64.0 → 0.73.0

package/lib/src/admin.js

@@ -7,12 +7,14 @@
  *
  * QUÉ SE DELEGA Y QUÉ NO — esto es el módulo entero, el resto es plomería:
  *
- *   sí  · ver el acta y la bitácora · iniciar un emparejamiento (mostrar el QR)
- *       · APROBAR o rechazar a quien entra · REVOCAR a un miembro
+ *   sí  · ver el acta y la bitácora · REVOCAR a un miembro
  *       · VARIABLES DE ENTORNO: crearlas y darles valor (de un scope o de un aparato),
  *         y ver el valor de las marcadas PÚBLICAS
- *   no  · cambiar permisos · traspasar el mando · conceder `admin`
+ *   no  · AGREGAR UN APARATO (quitado 2026-08-31, ver abajo)
+ *       · cambiar permisos · traspasar el mando · conceder `admin`
  *       · ver el valor de una variable PRIVADA · borrar variables
+ *       · NADA que cambie algo mientras el perfil está CERRADO (ver
+ *         `ADMIN_OPS_WHILE_LOCKED`): el candado es de la consola, y esto es la consola.
  *
  * SOBRE LAS VARIABLES, que es la rendija más nueva: lo que cruza la frontera no es «los
  * secretos» sino los que su dueño MARCÓ como mostrables. Una privada se puede reescribir
@@ -26,16 +28,25 @@
  * fuera de su propia cuenta, que no tiene vuelta atrás. Las operaciones que no se
  * delegan **no existen como mensaje**: no hay nada que autorizar mal.
  *
- * POR QUÉ APROBAR A DISTANCIA NO DEBILITA EL EMPAREJAMIENTO: el código de 6 dígitos es
- * un COMPROMISO (`enroll.js`) — lo genera y lo MUESTRA el aparato que entra, y la bóveda
- * solo firma si el código tecleado lo recompone. Aprobar exige haber leído la pantalla
- * del aparato nuevo, se haga desde el PC o desde el teléfono. Lo que cambia es dónde
- * está el humano, no qué tiene que demostrar.
+ * POR QUÉ AGREGAR APARATOS YA NO SE HACE DESDE AQUÍ (dueño, 2026-08-31). Existía para
+ * ahorrarse ir hasta la máquina de la bóveda. El **multivault** quita esa fricción de raíz
+ * —cualquier otra selladora abierta admite el aparato— así que esto dejó de comprar nada y
+ * se quedaba pidiendo lo caro: que la maestra pudiera firmar a distancia.
+ *
+ * Y era incompatible con la regla dura del acta: la maestra solo sella el acta y reenvuelve
+ * sobres, y con la bóveda cerrada no firma nada. Admitir a alguien es emitir un certificado
+ * Y sellar el acta: las dos cosas son de una selladora abierta, y esta consola no lo es.
+ *
+ * **Quitado de raíz, no escondido**: no existe la operación, ni el mensaje, ni el botón.
+ * Una funcionalidad escondida sigue siendo superficie de ataque y vuelve sola en el
+ * siguiente refactor.
  */
 
 /** Las únicas operaciones que existen a distancia. Lista cerrada, como las capacidades. */
 export const ADMIN_OPS = Object.freeze([
-  'pending', 'pair', 'approve', 'reject', 'revoke', 'audit',
+  // `pending`, `pair`, `approve` y `reject` NO están, y no es un olvido: agregar aparatos
+  // a distancia se quitó (ver la cabecera). Lo que queda es mirar, quitar y configurar.
+  'status', 'revoke', 'audit',
   // Variables de entorno: verlas (nombres siempre; valor solo de las públicas) y
   // ponerles valor (de las dos). Borrar NO está, y es a propósito: un aparato robado
   // no debe poder dejar sin configuración a los servicios.
@@ -48,6 +59,21 @@ export const ADMIN_OPS = Object.freeze([
   'vars', 'var.set', 'var.setMany'
 ])
 
+/**
+ * LO ÚNICO QUE SE ATIENDE CON EL CANDADO ECHADO: mirar. Ni una operación que cambie algo.
+ *
+ * El candado ES de la consola —los aparatos ya emparejados siguen leyendo, guardando y
+ * firmando con SU llave— así que cerrar el perfil tiene que cerrar exactamente esto. No
+ * estaba: `admin.pair` y `admin.approve` pasaban con el perfil bloqueado, y `approve`
+ * firmaba un certificado de 30 días CON LA MAESTRA. Esas dos ya no existen —agregar
+ * aparatos se quitó de aquí—, pero la regla se queda para las que quedan: revocar reescribe
+ * el acta y configurar toca los secretos.
+ *
+ * Se dejan las de LEER a propósito: si se cortaran todas, la consola no podría ni
+ * enterarse de por qué no funciona y parecería rota. Así puede decir «está cerrada».
+ */
+export const ADMIN_OPS_WHILE_LOCKED = Object.freeze(['status', 'audit', 'vars'])
+
 /** Cuánto se recuerda un nonce ya usado (el doble de la ventana de frescura). */
 export const ADMIN_NONCE_TTL_MS = 10 * 60 * 1000
 
@@ -56,7 +82,8 @@ export const AUDIT_MAX = 500
 
 /**
  * @param {Object} o
- * @param {Object} o.desk                mostrador de emparejamiento (`createEnrollDesk`).
+ * @param {Object} o.desk                `createEnrollDesk`, del que aquí solo se usa REVOCAR
+ *   (`revoke`/`revokeDevice`). Emparejar y aprobar ya no se atienden a distancia.
  * @param {(scope:string[])=>Promise<any>} o.verify  verifica cadena+cert; devuelve `{ok, device, reason}`.
  * @param {(limit:number)=>any[]} o.readActivity     últimas entradas de la bitácora.
  * @param {(pub:string)=>Promise<string>} o.deviceIdOf
@@ -67,19 +94,19 @@ export const AUDIT_MAX = 500
  *   bóveda no las atiende, en vez de fingir que se aplicaron.
  * @param {(ev:string, info?:object)=>Promise<void>} [o.notify]  aviso a todos los miembros.
  * @param {(op:string, info?:object)=>void} [o.audit]
- * @param {string[]} [o.defaultScope]    lo que recibe un dispositivo emparejado a distancia.
- * @param {number} [o.ttlMs]             vida del cert que se emita.
+ * @param {()=>boolean} [o.isLocked]  candado del perfil. Cerrado, solo se atiende
+ *   `ADMIN_OPS_WHILE_LOCKED`; lo demás responde con el código `vault-locked`.
  */
 export function createAdminDesk ({
   desk, verify, readActivity = () => [], deviceIdOf, vars = null,
-  notify = async () => {}, audit = () => {},
-  defaultScope = ['vault:sign', 'vault:read', 'vault:store'],
-  ttlMs, now = () => Date.now()
+  notify = async () => {}, audit = () => {}, isLocked = () => false,
+  now = () => Date.now()
 }) {
   const ops = new Set(ADMIN_OPS)
+  const mientrasCerrada = new Set(ADMIN_OPS_WHILE_LOCKED)
 
   // NONCE de un solo uso. `sign`/`get` son idempotentes y les basta la ventana de ±5
-  // min; `approve` y `revoke` CAMBIAN ESTADO, así que reproducir uno dentro de esa
+  // min; `revoke` y `var.set` CAMBIAN ESTADO, así que reproducir uno dentro de esa
   // ventana sí importa (re-aprobar un enrolamiento que el dueño ya rechazó, por
   // ejemplo). Por eso el nonce, y por eso es obligatorio en todas las ops: una lista
   // de excepciones es una invitación a equivocarse.
@@ -109,6 +136,21 @@ export function createAdminDesk ({
     }
     const by = await deviceIdOf(chk.device).catch(() => null)
 
+    // CERRADA NO SE ADMINISTRA. Va después de autorizar (el candado es estado del perfil,
+    // y a un desconocido no se le cuenta) y ANTES de quemar el nonce: quien reintente
+    // tras abrir la bóveda no tiene por qué generar otro.
+    //
+    // El código va aparte del texto porque el texto se traduce y el código no: quien
+    // llama distingue «está cerrada, ábrela» de «no tienes permiso» sin leer la frase.
+    if (isLocked() && !mientrasCerrada.has(data.op)) {
+      audit('rejected', { what: 'admin', op: data.op, by, reason: 'locked' })
+      return {
+        ok: false,
+        code: 'vault-locked',
+        error: 'vault locked: unlock the profile on the vault machine (dotrino-vault unlock) to administer it'
+      }
+    }
+
     // El nonce se marca DESPUÉS de autorizar: si no, cualquiera podría quemarle los
     // nonces a un admin legítimo mandando basura firmada por nadie.
     if (nonceAlreadyUsed(data.nonce)) {
@@ -117,41 +159,16 @@ export function createAdminDesk ({
     }
 
     try {
-      if (data.op === 'pending') return { ok: true, result: { pending: desk.listPending() } }
+      // Lo mínimo que la consola necesita saber de la bóveda para explicarse: si está
+      // cerrada, lo que queda (revocar, configurar) no se puede, y hay que decir por qué en
+      // vez de dejar pulsar un botón para recibir un error.
+      if (data.op === 'status') return { ok: true, result: { locked: !!isLocked() } }
 
       if (data.op === 'audit') {
         const limit = Math.min(Math.max(Number(data.limit) || 100, 1), AUDIT_MAX)
         return { ok: true, result: { entries: readActivity(limit) } }
       }
 
-      if (data.op === 'pair') {
-        // Un admin NO empareja servicios ni crea otros admins. Se corta aquí, en la
-        // bóveda, no en la interfaz: una pantalla no es un control de seguridad.
-        const scope = Array.isArray(data.scope) && data.scope.length ? data.scope : defaultScope
-        const forbidden = scope.find((s) => s === 'vault:admin' || String(s).startsWith('vault:secrets:'))
-        if (forbidden) {
-          audit('rejected', { what: 'admin', op: 'pair', by, reason: 'forbidden-scope', scope: forbidden })
-          return { ok: false, error: 'admin: cannot grant admin or service secrets from here; do that on the vault machine' }
-        }
-        const label = String(data.label || '').slice(0, 60) || 'remoto'
-        const r = await desk.startPairing({ scope, label, ...(ttlMs ? { ttlMs } : {}) })
-        audit('admin.pair', { by })
-        return { ok: true, result: r }
-      }
-
-      if (data.op === 'approve') {
-        const r = await desk.approve(String(data.code || ''), { deviceId: data.deviceId })
-        audit('admin.approve', { by, device: data.deviceId || null })
-        await notify('enrolled', { deviceId: r?.deviceId || data.deviceId || null, by })
-        return { ok: true, result: r || { ok: true } }
-      }
-
-      if (data.op === 'reject') {
-        desk.reject(data.deviceId)
-        audit('admin.reject', { by, device: data.deviceId || null })
-        return { ok: true, result: { ok: true } }
-      }
-
       // VARIABLES DE ENTORNO. El módulo solo enruta y audita: qué valor puede salir y con
       // qué se cifra lo decide la bóveda (`vars`), que es la que tiene la clave y el disco.
       if (data.op === 'vars' || data.op === 'var.set' || data.op === 'var.setMany') {
@@ -249,4 +266,4 @@ export function createAdminDesk ({
   return { handle, get nonceCount () { return seen.size } }
 }
 
-export default { createAdminDesk, ADMIN_OPS, ADMIN_NONCE_TTL_MS }
+export default { createAdminDesk, ADMIN_OPS, ADMIN_OPS_WHILE_LOCKED, ADMIN_NONCE_TTL_MS }

package/lib/src/index.js

@@ -26,14 +26,13 @@
  * No reimplementa nada del ecosistema.
  */
 import { verifyChain, verifyDeviceSig } from '@dotrino/identity/capabilities'
-import { memberCanScope } from '@dotrino/identity/acta'
+import { memberCanScope, sealersOf, memberScopes } from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS, FRESH_WINDOW_MS } from './enroll.js'
 // Las constantes del protocolo salen del MISMO módulo que usa el daemon: si la lista
 // local se queda corta, el dispositivo deja de handle mensajes sin que nadie lo note.
 import { MSG, SCOPE } from './protocol.js'
 
 const SIGN_SCOPE = SCOPE.SIGN
-const SELFCERT_TTL_MS = 24 * 60 * 60 * 1000    // el self-cert P←P se regenera cada 24 h
 const RENEW_TTL_MS = DEVICE_TTL_MS             // la renovación extiende la misma ventana (30 días)
 
 /** deviceId legible (p. ej. `C440-AC0E`) desde una pubkey JWK. */
@@ -58,10 +57,24 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
 
   // ----- self-cert P ← P (para que este dispositivo pueda además actuar de cliente
   // de sus propias máquinas: lo firma la propia P y verifyChain lo acepta) -----
+  /**
+   * Con qué se juzga un papel: el acta que tiene esta bóveda. Sustituye a `trustedIssuer`,
+   * que fijaba UNA llave y por eso los papeles de una segunda selladora no valían.
+   * Sin acta van nulos y `verifyDelegation` contesta `no-acta`: no hay con qué decidir, así
+   * que no se decide que sí.
+   */
+  async function contextoActa () {
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!acta) return { actaSeq: null, sealers: null }
+    return { actaSeq: acta.seq, sealers: sealersOf(acta) }
+  }
+
   let _selfCert = null
   const getSelfCert = async () => {
-    if (_selfCert && _selfCert.exp > Date.now() + 60_000) return _selfCert
-    const { cert } = await identity.signDelegation(iss, SIGN_SCOPE, { ttlMs: SELFCERT_TTL_MS })
+    // Se rehace cuando el acta cambia, no cuando pasa el tiempo: el papel ya no caduca.
+    const { actaSeq } = await contextoActa()
+    if (_selfCert && _selfCert.seq === actaSeq) return _selfCert
+    const { cert } = await identity.signDelegation(iss, SIGN_SCOPE)
     _selfCert = cert
     return cert
   }
@@ -138,13 +151,20 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) {
       return send(from, { type: MSG.ERROR, error: 'stale request: ts outside the ±5 min window (possible replay, or the device clock is off)' })
     }
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss, revoked: await revocationSet() })
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + 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 || '' })
-    send(from, { type: MSG.RENEWED, cert })
+    // EL SCOPE SALE DEL ACTA, no del papel viejo: el papel dice a qué se comprometió esta
+    // bóveda al conectar el aparato; el acta, lo que puede HOY.
+    const acta = (await identity.profileActa?.().catch(() => null))?.acta || null
+    if (!acta) return send(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
+    const scope = memberScopes(acta, p.cert.sub)
+    if (!scope.length) return send(from, { type: MSG.ERROR, error: 'unauthorized: the record no longer lists this device' })
+    const { cert } = await identity.signDelegation(p.cert.sub, scope, { label: prev?.label || '' })
+    // El acta viaja con el papel: sin ella quien lo recibe no puede comprobar quién lo firmó.
+    send(from, { type: MSG.RENEWED, cert, acta })
   }
 
   // Consulta de revocaciones (igual que `vault.devices` del daemon): responde la lista
@@ -154,12 +174,12 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     const d = p?.data
     if (!d || !p.signature || !p.cert) return send(from, { type: MSG.ERROR, error: 'invalid request' })
     if (typeof d.ts !== 'number' || Math.abs(Date.now() - d.ts) > FRESH_WINDOW_MS) return
-    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, trustedIssuer: iss })
+    const chk = await verifyChain({ data: d, signature: p.signature, cert: p.cert, ...(await contextoActa()) })
     if (!chk.ok) return send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
     const { issued, revoked, revokedCerts } = await identity.listDelegations()
     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
+      label: x.label || '', scope: x.scope, seq: x.seq, nonce: x.nonce
     })))
     send(from, { type: MSG.DEVICES_RESULT, devices, revoked: (revoked || []).map((r) => r.nonce || r) })
     // ¿el que consulta es una máquina revocada que reapareció? → re-emite el REVOKED firmado.
@@ -189,7 +209,7 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     const chk = await verifyChain({
       data: d, signature: p.signature, cert: p.cert,
       ...(expectedScope ? { expectedScope } : {}),
-      trustedIssuer: iss, revoked: await revocationSet(),
+      ...(await contextoActa()), revoked: await revocationSet(),
     })
     if (!chk.ok) {
       send(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
@@ -314,13 +334,14 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
    */
   async function listMachines () {
     const { issued } = await identity.listDelegations()
-    const now = Date.now()
     const bySub = new Map()
     for (const x of (issued || [])) {
-      if (!x.sub || x.revokedAt || (x.exp && x.exp <= now)) continue // revocada = fuera de la lista
+      if (!x.sub || x.revokedAt) continue                       // revocada = fuera de la lista
       if (!Array.isArray(x.scope) || !x.scope.includes(SIGN_SCOPE)) continue
       if (!x.label || x.label === 'cli') continue
-      if (!bySub.has(x.sub) || (x.exp || 0) > (bySub.get(x.sub).exp || 0)) bySub.set(x.sub, x)
+      // Se queda el papel del acta MÁS NUEVA de esa llave: ya no hay «el que vence más
+      // tarde», porque ninguno vence.
+      if (!bySub.has(x.sub) || (x.seq || 0) > (bySub.get(x.sub).seq || 0)) bySub.set(x.sub, x)
     }
     return Promise.all([...bySub.values()].map(async (x) => ({ ...x, deviceId: await deviceIdOf(x.sub) })))
   }

package/lib/src/service.js

@@ -23,9 +23,9 @@ import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
   makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
-  verifyDeviceSig, makePairingCode, commitCode, pubkeyId, PEER_SKEW_MS } from '@dotrino/identity/capabilities'
+  verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
-import { verifyActa, sealKeyAt } from '@dotrino/identity/acta'
+import { verifyActa, sealKeyAt, sealersOf } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs } from './protocol.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
@@ -33,7 +33,6 @@ import { atRestFor } from './atrest.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
-const RENEW_BEFORE_MS = 7 * 24 * 60 * 60 * 1000 // renovar el cert si vence en <7 días
 
 let _globalsInstalled = false
 function installNodeGlobals () {
@@ -297,9 +296,22 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     const res = await enrolled
 
     if (res.code !== code) throw new Error('the vault echoed a code other than the one shown (possible malicious relay)')
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS, ...(expectedScope ? { expectedScope } : {}) })
+    // EL ACTA VIAJA CON EL PAPEL, y hace falta para juzgarlo: el certificado ya no vence
+    // por reloj, dice el `seq` del acta con el que se emitió, y quien lo emitió tiene que
+    // ser SELLADORA de ese acta. Sin acta no se puede comprobar nada de eso, y entrar a
+    // ciegas en un perfil es justo lo que no se hace.
+    const acta = res.acta
+    if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
+    // Y el acta tiene que ser la DEL PERFIL DEL QR. Antes esto se comprobaba mirando que el
+    // cert lo firmara `qr.iss`; con varias selladoras el emisor puede ser otra llave del
+    // mismo perfil, así que lo que se fija es el perfil, no la llave.
+    if (acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one in the QR')
+    const v = await verifyDelegation({
+      cert: res.cert, expectedSub: device.publickey,
+      actaSeq: acta.seq, sealers: sealersOf(acta),
+      ...(expectedScope ? { expectedScope } : {})
+    })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.iss !== qr.iss) throw new Error('cert signed by a master other than the one in the QR')
 
     return { device, enc: { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk }, cert: res.cert, iss: qr.iss, proxy: qr.proxy || 'wss://proxy.dotrino.com' }
   } finally { client.close() }
@@ -430,8 +442,36 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
   try {
     await identifyAsService(client, device)
 
-    // Renovación de cert best-effort si vence pronto (mientras siga vigente).
-    if (typeof cert.exp === 'number' && cert.exp - Date.now() < RENEW_BEFORE_MS && cert.exp > Date.now()) {
+    // ¿Nos quedamos atrás? Lo sabemos porque la bóveda manda su acta con cada respuesta y
+    // apuntamos su `seq` al guardarla. Si esa acta es más nueva que el papel, puede que el
+    // dueño nos haya cambiado los permisos: se pide uno al día siguiente de enterarnos, no
+    // por calendario.
+  /**
+   * Guarda en disco lo que hemos aprendido, SIN pisar lo demás.
+   *
+   * `saved` se lee una vez al entrar, así que hay que actualizarlo en memoria además de
+   * escribirlo: si no, la segunda escritura parte de la foto vieja y deshace la primera.
+   * Eso pasó — renovar guardaba el papel nuevo y acto seguido apuntar el acta lo pisaba con
+   * el viejo, que ya estaba revocado. Al siguiente arranque: «unauthorized: revoked».
+   */
+  const recordar = (patch) => {
+    if (!saved) return
+    saved = { ...saved, ...patch }
+    if (dir) { try { writeServiceIdentity(dir, saved) } catch (_) {} }
+  }
+  /** Hasta qué acta hemos visto: es lo que dispara la renovación la próxima vez. */
+  const anotarActa = (acta) => {
+    if (typeof acta?.seq !== 'number' || saved?.actaSeq === acta.seq) return
+    recordar({ actaSeq: acta.seq })
+  }
+
+    const renovar = typeof saved?.actaSeq === 'number' && typeof cert?.seq === 'number' && saved.actaSeq > cert.seq
+
+    // RENOVAR YA NO ES UNA TAREA DE CALENDARIO. El papel no vence: lo único que obliga a
+    // pedir otro es que la bóveda diga que el nuestro se quedó atrás respecto del acta, y
+    // eso lo contesta ella cuando lo pide (`acta-vieja`). Aquí se intenta una vez y no se
+    // insiste: si falla, se sigue con el papel que hay — que probablemente valga.
+    if (renovar) {
       try {
         const data = { op: 'renew', publickey: device.publickey, ts: Date.now() }
         const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
@@ -439,8 +479,8 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
         client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
         const res = await pending
         if (res.type === MSG.RENEWED && res.cert?.sub === device.publickey) {
-          const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS, expectedScope: secretsScope(ns) })
-          if (v.ok) { cert = res.cert; if (dir && saved) writeServiceIdentity(dir, { ...saved, cert }) }
+          cert = res.cert
+          recordar({ cert })
         }
       } catch (_) { /* la renovación no bloquea el fetch */ }
     }
@@ -458,6 +498,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // sigue identificada. Se espera lo que dura el pedido; denegado o vencido es error.
     if (res.body?.op === 'secrets.pending' && res.body.ns === ns) {
       await verifyResponder({ body: res.body, seal: res.seal, acta: res.acta, masterPubkey })
+      anotarActa(res.acta)
       try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
       const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
       res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
@@ -479,6 +520,7 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     // dentro se usa hasta después de verificar.
     const payload = await openSealed({ privateKey: eph.privateKey, enc: body.enc })
     await verifyResponder({ body, seal: res.seal, acta: payload?.acta, masterPubkey })
+    anotarActa(payload?.acta)
 
     // DOS CAPAS DE SOBRE, y hacen cosas distintas:
     //   · la de fuera (`ek` efímera, recién abierta) tapa el TRAMO — el proxio no ve

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.64.0",
+  "version": "0.73.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": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.67.0",
+    "@dotrino/identity": "0.73.0",
     "@dotrino/passmanager": "^0.9.0",
     "@dotrino/proxy-client": "^0.13.1",
     "ws": "^8.18.0"
@@ -44,7 +44,7 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "^0.5.3",
+    "@dotrino/remote-agent": "0.6.0",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
   }

package/src/client.js

@@ -11,7 +11,18 @@
  * estrictamente (firmado por la maestra que vio en el QR, y para SU clave) antes de
  * guardarlo. La maestra nunca sale del vault.
  */
-import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId, PEER_SKEW_MS } from '@dotrino/identity/capabilities'
+import { makeDeviceKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { sealersOf } from '@dotrino/identity/acta'
+
+/**
+ * Con qué se juzga un papel: el ACTA que la bóveda manda junto a él. Sustituye a comparar
+ * `cert.iss` con la maestra — con varias selladoras el emisor puede ser otra llave del mismo
+ * perfil, así que lo que se fija es el PERFIL, no la llave.
+ */
+function contexto (acta) {
+  if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
+  return { actaSeq: acta.seq, sealers: sealersOf(acta) }
+}
 import { installNodeGlobals } from './node-globals.js'
 import { MSG } from './protocol.js'
 
@@ -84,9 +95,9 @@ export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeout
     const res = await enrolled
 
     // VALIDACIÓN ESTRICTA antes de persistir (cierra inyección de cert / sustitución de maestra).
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS })
+    if (res.acta?.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw (possible malicious proxy)')
+    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...contexto(res.acta) })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.iss !== qr.iss) throw new Error('cert signed by a master other than the one you saw (possible malicious proxy)')
     if (res.cert.sub !== device.publickey) throw new Error('cert issued for a different device')
     // OJO: devolvemos qr.iss (la maestra que el usuario VIO), NO res.iss.
     return { device, cert: res.cert, iss: qr.iss }
@@ -151,9 +162,9 @@ export async function requestRenew ({ masterPubkey, proxyUrl, device, cert, dir
     if (res.type === MSG.ERROR) throw new Error(res.error)
     // Se valida antes de devolverlo, igual que en el enrolamiento: un cert que no está
     // firmado por la maestra que ya conocemos, o que no es para esta llave, no se guarda.
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, skewMs: PEER_SKEW_MS })
+    if (res.acta?.profileId !== masterPubkey) throw new Error('the record is from a profile other than the pinned one')
+    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...contexto(res.acta) })
     if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.iss !== masterPubkey) throw new Error('cert signed by a master other than the pinned one')
     return { cert: res.cert }
   } finally { client.close() }
 }

package/src/commKey.js

@@ -0,0 +1,71 @@
+/**
+ * commKey.js — LA LLAVE DE COMUNICACIÓN de esta bóveda.
+ *
+ * La maestra tiene dos trabajos y ninguno más: **sellar el acta y reenvolver los sobres**
+ * (dueño, 2026-08-31). Hablar por la red no es suyo. Todo lo demás —identificarse ante el
+ * proxio, firmar lo que se sirve— lo hace esta llave, y **su autoridad la dice el acta**,
+ * donde entra como un miembro más.
+ *
+ * Por qué eso importa y no es un rodeo: mientras la maestra fuera la que se identificaba,
+ * no podía vivir bajo llave — `identify` firma en cada conexión y en cada reconexión, así
+ * que una bóveda cerrada no habría existido en la red. Sacándola de ahí, la maestra solo
+ * sale con el perfil abierto y el candado deja de ser una bandera.
+ *
+ * Tres propiedades, y las tres son a propósito:
+ *
+ *   · **Firmar no es leer.** No abre ningún valor. Por eso puede vivir cifrada en reposo
+ *     con la llave de la máquina y usarse SIN la frase — que es lo que hace que la bóveda
+ *     siga sirviendo con el candado echado.
+ *   · **ESTABLE.** No rota con cada acta, al revés que la vieja `sealPub`: es un miembro,
+ *     y un miembro no cambia de llave cada vez que se toca el acta. Rota cuando se decide,
+ *     como cualquier aparato.
+ *   · **Acotada por `cn`.** Entra con `cn: 'vault'`, así que el acta la trata como un
+ *     SERVICIO: `memberCanSign` sin cajón le dice que no. Puede hablar por la bóveda, no
+ *     firmar por la persona. Si alguien se lleva el disco, se lleva eso y nada más.
+ */
+import path from 'node:path'
+import { readJson, writeJson } from './paths.js'
+import { atRestFor } from './atrest.js'
+import { signWithDevice } from '@dotrino/identity/capabilities'
+
+/** El `cn` con el que entra en el acta. Es un servicio del perfil, no un aparato tuyo. */
+export const COMM_CN = 'vault'
+/** Lo que puede: firmar (acotado por su `cn`). Nada de leer, guardar ni sellar. */
+export const COMM_CAPS = Object.freeze(['sign'])
+
+/** Abre (o estrena) la llave de comunicación del perfil. */
+export function openCommKey (dir) {
+  const file = path.join(dir, 'commkey.json')
+  const atRest = atRestFor(dir)
+  let data = readJson(file, null, atRest)
+  if (!data || typeof data !== 'object' || !data.pub) data = null
+
+  return {
+    /** La pública, o `null` si todavía no se ha estrenado. */
+    pub: () => data?.pub || null,
+
+    /**
+     * Estrena la llave si no existe y devuelve su pública. Idempotente: llamarla dos veces
+     * NO cambia de llave — cambiarla dejaría al acta nombrando una que ya no tenemos y a la
+     * bóveda sin poder identificarse hasta el siguiente sellado.
+     */
+    async ensure () {
+      if (data?.pub) return data.pub
+      const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify'])
+      const pub = JSON.stringify(await crypto.subtle.exportKey('jwk', pair.publicKey))
+      const priv = await crypto.subtle.exportKey('jwk', pair.privateKey)
+      data = { v: 1, pub, priv, createdAt: Date.now() }
+      writeJson(file, data, atRest)
+      return pub
+    },
+
+    /** Firma un cuerpo. `null` si aún no hay llave (no se estrena una al vuelo: ver `ensure`). */
+    async sign (body) {
+      if (!data?.priv) return null
+      const { signature } = await signWithDevice({ privateJwk: data.priv, publickey: data.pub, data: body })
+      return signature
+    }
+  }
+}
+
+export default { openCommKey, COMM_CN, COMM_CAPS }

package/src/daemon.js

@@ -323,7 +323,7 @@ export async function runDaemon () {
       // paga; el dueño no tiene que acordarse de un comando aparte.
       case 'unlock': {
         const id = ref()
-        await mgr.profiles.unlock(id, req.password)
+        await mgr.unlock(id, req.password)   // por el manager: mueve la maestra a memoria y la sella
         let note = ''
         let ak = null
         try {
@@ -345,7 +345,9 @@ export async function runDaemon () {
       // los 5 minutos de ABRIRLO aunque estuvieras delante trabajando. `ref()` ya estira
       // el plazo; esta op no hace nada más, y por eso no devuelve ningún volcado.
       case 'touch': { ref(); return { done: 'ok' } }
-      case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
+      // Por el manager, no por `profiles`: cerrar tiene que SOLTAR la maestra, no solo
+      // apuntar que está cerrada.
+      case 'lock': { await mgr.lock(ref()); return { done: 'perfil bloqueado' } }
       // PONER contraseña: los secretos pasan de abrirse con la llave de la máquina a
       // abrirse con la frase. Hay que volver a cerrar la copia maestra con la nueva, o
       // quedarían ilegibles. Si el perfil YA tenía contraseña, hace falta la vieja para

package/src/manager.js

@@ -51,8 +51,14 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     ...(autoLockMs === undefined ? {} : { autoLockMs }),
     // Que se cierre solo tiene que VERSE: si no, quien vuelve y encuentra la consola
     // pidiendo la contraseña otra vez cree que algo se rompió.
-    onAutoLock: (id) => log('[vault] profile %s locked itself after %d min idle (the console; devices keep working)',
-      id, Math.round(profiles.autoLockMs / 60000))
+    onAutoLock: (id) => {
+      log('[vault] profile %s locked itself after %d min idle (the console; devices keep working)',
+        id, Math.round(profiles.autoLockMs / 60000))
+      // Y la maestra se va con el candado. Cerrarse solo tiene que soltarla igual que
+      // cerrarla a mano: si no, bastaba con esperar a que se cerrara sola para tenerla
+      // descifrada en memoria sin candado que valga.
+      running.get(id)?.dropMasterKey?.().catch(() => {})
+    }
   })
   /**
    * ACUÑAR (o simplemente LEER) la llave de una carpeta, y cerrarla enseguida.
@@ -92,6 +98,10 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       // Para la consola remota: la contraseña llega dentro del sobre firmado y hay que
       // convertirla en la llave que abre la copia maestra de los secretos.
       deriveAdminKey: (password) => profiles.adminKey(id, password),
+      // La llave del perfil MIENTRAS esté abierto, o null. Con ella, enrolar un servicio
+      // con la bóveda abierta le envuelve su cajón en el acto en vez de dejarlo entrar
+      // sin poder leer nada (ver `profiles.js`, `llaves`).
+      openKey: () => profiles.openKey(id),
       // Camino A: nació para adoptar la cuenta de un aparato (ver profiles.add).
       forAdoption: !!p?.adopt,
       // Ya adoptó: la marca se consume (no vuelve a estar «a la espera»).
@@ -120,6 +130,27 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     return v
   }
 
+  /**
+   * ABRIR Y CERRAR EL PERFIL, con la maestra siguiendo al candado.
+   *
+   * Va aquí y no en `profiles.js` porque el registro de perfiles no sabe de bóvedas
+   * corriendo: sabe de contraseñas. Quien tiene las dos cosas delante es esto.
+   */
+  async function unlock (id, password) {
+    const r = await profiles.unlock(id, password)
+    // `takeMasterKey` además la deja SELLADA la primera vez: un perfil que ya tenía
+    // contraseña guardaba la maestra bajo la llave de máquina, y se migra aquí, que es el
+    // único momento en que la llave del perfil está en la mano.
+    try { await running.get(id)?.takeMasterKey?.() } catch (e) { log('[vault] could not take the master key: %s', e.message) }
+    return r
+  }
+
+  async function lock (id) {
+    const r = profiles.lock(id)
+    try { await running.get(id)?.dropMasterKey?.() } catch (_) {}
+    return r
+  }
+
   /** Resumen para state.json / `profile ls`: identidad + candado de cada perfil. */
   const summary = () => profiles.list().map((p) => {
     const v = running.get(p.id)
@@ -128,6 +159,10 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
 
   return {
     profiles,
+    // Abrir y cerrar pasan por AQUÍ, no por `profiles`: son las que mueven la maestra
+    // dentro y fuera de la memoria. Llamar a `profiles.lock` a secas deja la llave puesta.
+    unlock,
+    lock,
     running,
     get,
     list: () => profiles.list(),