@dotrino/vaultd 0.25.0 → 0.26.0

package/lib/src/admin.js

@@ -127,13 +127,22 @@ export function createAdminDesk ({
         return { ok: true, result: { ok: true } }
       }
 
-      // Quitar un dispositivo: por `sub` se le retiran TODOS sus certificados. Con
-      // `certNonce` a secas solo cae ese papel, y el aparato puede tener otro vigente.
+      // QUITAR UN DISPOSITIVO se hace por `sub` (su llave): sale del acta Y se le retiran
+      // todos los certificados. Las dos cosas o ninguna.
+      //
+      // `certNonce` retira UN PAPEL y nada más — el aparato sigue siendo miembro. Sirve
+      // para eso y solo para eso, y se conserva por compatibilidad, pero no es «quitar»:
+      // usarlo para quitar dejaba un miembro sin certificados al que la bóveda ya nunca le
+      // mandaba el aviso de expulsión (mientras siga en el acta, un papel retirado
+      // significa «renueva»). Ese era el dispositivo fantasma.
       if (data.op === 'revoke') {
         if (data.sub) {
+          const deviceId = await deviceIdOf(String(data.sub)).catch(() => null)
           const r = await desk.revokeDevice(String(data.sub))
-          audit('admin.revoke-device', { by, certs: r?.nonces?.length ?? null })
-          await notify('revoked', { by })
+          audit('admin.revoke-device', { by, device: deviceId, certs: r?.nonces?.length ?? null })
+          // Con el `deviceId`: el aviso a los demás dispositivos tiene que decir a QUIÉN
+          // quitaron, o no se puede saber si el que sobra eres tú.
+          await notify('revoked', { deviceId, by })
           return { ok: true, result: r || { ok: true } }
         }
         const r = await desk.revoke(String(data.certNonce || ''))

package/lib/src/env.js

@@ -172,7 +172,7 @@ export function applyEnv (secrets, override = overrideByDefault()) {
  * @param {Object} [opts]
  * @param {string} [opts.ns]
  * @param {string} [opts.dir]
- * @param {(info:{ns:string, ts:number, motivo:'cambio'|'revocado'})=>void} [opts.onUpdate]
+ * @param {(info:{ns:string, ts:number, reason:'changed'|'revoked'})=>void} [opts.onUpdate]
  *   Reemplaza la salida por defecto. Úsalo cuando terminar el proceso no sea una
  *   opción — el caso del proxio, cuyo reinicio corta el transporte de todos.
  * @param {number} [opts.exitCode=0]  Salida LIMPIA: systemd con `Restart=on-failure`
@@ -183,24 +183,24 @@ export function applyEnv (secrets, override = overrideByDefault()) {
 export async function watchEnv ({ ns, dir, onUpdate, exitCode = 0, quiet = false, ...resto } = {}) {
   ns = resolveNs(ns)
   dir = dir || serviceDir(ns)
-  const decir = (m) => { if (!quiet) console.error(m) }
+  const say = (m) => { if (!quiet) console.error(m) }
 
-  const salir = (motivo) => {
-    decir(`[dotrino-env] ${motivo === 'revocado'
+  const exitNow = (reason) => {
+    say(`[dotrino-env] ${reason === 'revoked'
       ? 'la bóveda REVOCÓ este agente: terminando (no volverá a arrancar)'
       : 'configuración nueva en la bóveda: terminando para que el supervisor lo levante limpio'}`)
-    process.exit(motivo === 'revocado' ? 1 : exitCode)
+    process.exit(reason === 'revoked' ? 1 : exitCode)
   }
 
   return watchSecretsChanges({
     dir,
     ns,
-    log: decir,
-    onChange: ({ ts }) => (onUpdate ? onUpdate({ ns, ts, motivo: 'cambio' }) : salir('cambio')),
+    log: say,
+    onChange: ({ ts }) => (onUpdate ? onUpdate({ ns, ts, reason: 'changed' }) : exitNow('changed')),
     // Un cert revocado sale con código de FALLO a propósito: si el supervisor lo
     // levanta, va a morir otra vez al no poder leer sus secretos, y el contador de
     // reinicios fallidos es lo que hace que se note en vez de girar en silencio.
-    onRevoked: () => (onUpdate ? onUpdate({ ns, ts: Date.now(), motivo: 'revocado' }) : salir('revocado')),
+    onRevoked: () => (onUpdate ? onUpdate({ ns, ts: Date.now(), reason: 'revoked' }) : exitNow('revoked')),
     ...resto
   })
 }

package/lib/src/index.js

@@ -206,8 +206,14 @@ export async function startDeviceVault (identity, { proxyUrl, client: injectedCl
     reject: (deviceId) => desk.reject(deviceId),
     listPending: desk.listPending,
     listMachines,
-    // Revoca y AVISA a la máquina con un REVOKED firmado para que se auto-borre (ahora si
-    // está online, o al reaparecer vía handleDevices).
+    // QUITA LA MÁQUINA entera (por su llave): fuera del acta y sin ningún certificado
+    // vigente, que son las dos caras del mismo acto. Y AVISA con un REVOKED firmado para
+    // que se auto-borre (ahora si está online, o al reaparecer vía handleDevices).
+    revokeDevice: (sub) => desk.revokeDevice(sub),
+    // Retira UN certificado. No es quitar la máquina: sigue siendo miembro del acta, y
+    // quien queda así ya no recibe el aviso de expulsión (mientras siga en el acta, un
+    // papel retirado significa «renueva»). Usar `revokeDevice` salvo que quieras
+    // exactamente esto.
     revoke: (nonce) => desk.revoke(nonce),
     getSelfCert,
     onPendingChange (fn) { _onPendingChange = fn || (() => {}) },

package/lib/src/revocation.js

@@ -0,0 +1,67 @@
+/**
+ * revocation.js — CUÁNDO se le dice a un aparato que ya no es de casa.
+ *
+ * Módulo PURO (sin red, sin disco, sin `node:*`), como `enroll.js` y `admin.js`: la regla
+ * vive en un solo sitio, se lee entera y se prueba sin levantar nada.
+ *
+ * EL PROBLEMA QUE RESUELVE. Un dispositivo al que quitaron del perfil no se entera por su
+ * cuenta: lo único que le borra la cuenta es un aviso FIRMADO por la maestra
+ * (`vault.revoked`). Un «unauthorized» suelto no vale y no debe valer — no va firmado, así
+ * que cualquiera podría destruir datos ajenos con un mensaje (el wipe-DoS de
+ * `docs/pairing-protocol.md §2.3`). Por eso la bóveda tiene que **atender** la conexión de
+ * un aparato que fue suyo, aunque su papel ya no sirva, precisamente para poder mandarlo a
+ * paseo. Si no lo hace, el aparato se queda enseñando una cuenta que ya no existe.
+ *
+ * LA REGLA, en una línea: papel nuestro + ya no está en el acta ⇒ se le avisa.
+ */
+
+/**
+ * Motivos de rechazo de `verifyChain` que significan «este papel ya no sirve».
+ *
+ * Los tres se producen DESPUÉS de que `verifyChain` haya comprobado la firma del propio
+ * aparato y la del certificado, así que quien llega hasta aquí demostró tener la llave que
+ * el certificado nombra. El resto de motivos (`shape`, `bad-signature`,
+ * `bad-action-signature`, `cert-device-mismatch`, `untrusted-issuer`…) son ruido o gente
+ * ajena: ahí no hay a quién avisar de nada.
+ */
+export const STALE_PAPER = Object.freeze(['revoked', 'expired', 'scope'])
+const STALE = new Set(STALE_PAPER)
+
+/** ¿El motivo del rechazo es «tu papel ya no sirve»? */
+export const isStalePaper = (reason) => STALE.has(reason)
+
+/**
+ * ¿Hay que mandarle el aviso firmado de expulsión?
+ *
+ * @param {Object} o
+ * @param {string} o.reason      por qué falló `verifyChain`.
+ * @param {string} o.pubkey      la llave del aparato que acaba de escribir.
+ * @param {string} o.master      la maestra de ESTA bóveda.
+ * @param {string|null} [o.certIss]  quién firmó el certificado que presentó.
+ * @param {Array<{pub:string}>|null} [o.members]  miembros del acta; `null` = no hay acta.
+ * @param {boolean} [o.knownRevoked]  consta explícitamente como revocado en las
+ *   delegaciones. Es el único criterio que queda cuando no hay acta.
+ * @returns {boolean}
+ */
+export function shouldNotifyRevoked ({ reason, pubkey, master, certIss = null, members = null, knownRevoked = false } = {}) {
+  if (typeof pubkey !== 'string' || !pubkey) return false
+  if (!isStalePaper(reason)) return false
+  // Que el papel sea NUESTRO. No hace falta que siga siendo válido —justo por eso estamos
+  // aquí— pero sí que lo haya firmado esta maestra: es lo que separa a un aparato que fue
+  // de casa de uno que pasaba por ahí.
+  if (certIss && master && certIss !== master) return false
+  // El aparato no puede echarse a sí mismo, y la maestra tampoco se echa.
+  if (master && pubkey === master) return false
+
+  // EL ACTA MANDA, y es lo único que manda. Un certificado retirado o vencido NO significa
+  // «estás fuera»: renovar retira el anterior y cambiar permisos obliga a renovar, así que
+  // un aparato de casa con un papel viejo solo tiene que renovar. Decirle «estás fuera»
+  // ahí lo borraba solo: dabas «administra» y el dispositivo desaparecía.
+  if (Array.isArray(members)) return !members.some((m) => m?.pub === pubkey)
+
+  // Sin acta (bóveda anterior al acta) no se puede saber quién es del perfil: solo se
+  // avisa a quien conste explícitamente como revocado.
+  return !!knownRevoked
+}
+
+export default { STALE_PAPER, isStalePaper, shouldNotifyRevoked }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.25.0",
+  "version": "0.26.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": {
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.45.0",
+    "@dotrino/identity": "^0.47.0",
     "@dotrino/proxy-client": "^0.10.0",
     "ws": "^8.18.0"
   },

package/src/tui/app.js

@@ -88,6 +88,36 @@ function groupByDevice (issued) {
   return [...by.values()]
 }
 
+/**
+ * LA lista de dispositivos: el acta, con el certificado de cada uno pegado.
+ *
+ * El acta es quien dice de quién es el perfil; los certificados son el reflejo de esa
+ * decisión y pueden faltar (retirados, vencidos). Un miembro sin certificado sale igual,
+ * marcado como «sin acceso», porque es exactamente el que hay que poder quitar.
+ *
+ * Si todavía no hay acta (bóveda anterior al acta, o sin volcar), se cae a los
+ * certificados: peor lista, pero lista.
+ */
+function mergeMembersAndCerts (members, issued) {
+  const certs = new Map()
+  for (const d of groupByDevice(issued)) certs.set(d.sub || d.deviceId || d.nonce, d)
+  if (!Array.isArray(members) || !members.length) return [...certs.values()]
+  return members.map((m) => {
+    const cert = certs.get(m.pub)
+    return {
+      ...(cert || {}),
+      sub: m.pub,
+      deviceId: m.id || cert?.deviceId || '????-????',
+      label: m.label || cert?.label || '',
+      isMaster: !!m.isMaster,
+      cn: m.cn || null,
+      // El master es la propia bóveda: no tiene (ni necesita) certificado. Un servicio
+      // tampoco lleva uno de dispositivo. Marcarlos «sin acceso» sería una alarma falsa.
+      noAccess: !cert && !m.isMaster && !m.cn
+    }
+  })
+}
+
 function activeProfile (st) {
   const list = st.profiles?.profiles || []
   return list.find((p) => p.current) || list[0] || null
@@ -193,15 +223,27 @@ function deviceRows (st, t) {
   // UNA FILA POR APARATO, no por certificado. Antes se pintaba `issued` tal cual y un
   // aparato con dos certs (el viejo + el de la renovación) salía dos veces: parecían dos
   // máquinas. Se agrupa por llave y se muestra el cert vigente más largo.
-  const issued = groupByDevice(st.devices?.issued || [])
-  if (!issued.length) {
+  //
+  // Y la lista sale del ACTA, no de los certificados: el acta dice quién es del perfil, y
+  // los certificados son su reflejo. Un miembro sin certificado vigente —porque le
+  // retiraron el papel pero no lo sacaron del acta, o porque se le venció— no salía en
+  // ninguna pantalla del PC: invisible aquí, presente en la del navegador, y sin forma de
+  // quitarlo más que adivinando su ID para el `revoke` de la línea de comandos.
+  const devices = mergeMembersAndCerts(st.members, st.devices?.issued || [])
+  if (!devices.length) {
     rows.push({ text: t.muted(i.noDevices), sel: false })
   }
-  for (const d of issued) {
+  for (const d of devices) {
     const label = d.label || t.muted(i.noLabel)
     const extra = d.certCount > 1 ? t.muted(`  certs:${d.certCount}`) : ''
-    const line = ` ${t.bold(d.deviceId)}  ${label}  ${t.muted('scope:' + shortScope(d.scope))}  ${t.muted('exp:' + fmtExp(d.exp))}${extra}`
-    rows.push({ text: line, sel: true, meta: d })
+    // SIN ACCESO: está en el acta y no puede entrar. Es un aviso, no un adorno, así que va
+    // en el color de aviso y en el sitio donde estaría su vencimiento.
+    const estado = d.noAccess
+      ? t.warn(i.deviceNoAccess)
+      : d.isMaster
+        ? t.muted(i.thisVault)
+        : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp))
+    rows.push({ text: ` ${t.bold(d.deviceId)}  ${label}  ${estado}${extra}`, sel: true, meta: d })
   }
   const revoked = st.devices?.revoked || []
   if (revoked.length) {
@@ -342,9 +384,12 @@ async function guard (term, st, msg, fn) {
 async function refreshAll (term, st) {
   const r = await guard(term, st, L(st).loading, () => vc.snapshot(activeId(st)))
   if (!r.ok) return
-  const { devices, secrets, profiles } = r.v
+  const { devices, secrets, profiles, acta } = r.v
   if (profiles) st.profiles = profiles
   if (secrets) st.secrets = secrets.ns || {}
+  // El ACTA entra en el volcado normal: es de donde sale la lista de dispositivos (ver
+  // `mergeMembersAndCerts`). Antes solo se pedía al abrir la pantalla de permisos.
+  if (acta) st.members = acta.members || []
   if (devices) {
     const issued = (devices.issued || devices.active || devices.delegations || [])
     st.devices = { issued: await Promise.all(issued.map(async (d) => ({ ...d, deviceId: d.sub ? await vc.deviceIdOf(d.sub) : '????-????' }))), revoked: devices.revoked || [] }
@@ -353,7 +398,11 @@ async function refreshAll (term, st) {
 
 async function refreshDevices (term, st) {
   const r = await guard(term, st, L(st).loadingDevices, () => vc.listDevices(activeId(st)))
-  if (r.ok) st.devices = r.v
+  if (!r.ok) return
+  st.devices = r.v
+  // La lista se pinta desde el acta; traerla aparte dejaba la pantalla con los miembros de
+  // hace dos operaciones (quitar uno no lo quitaba de la vista).
+  if (Array.isArray(r.v.members)) st.members = r.v.members
 }
 async function refreshSecrets (term, st) {
   const r = await guard(term, st, L(st).loadingSecrets, () => vc.listSecrets(activeId(st)))
@@ -545,6 +594,10 @@ async function onKeyDevices (term, st, key) {
     if (!st.pending) { flash(st, i.noPendingToReject, 'warn'); return true }
     const r = await guard(term, st, i.rejecting, () => vc.rejectPending(st.pending.deviceId, activeId(st)))
     if (r.ok) { flash(st, i.deviceRejected); st.pending = null }
+  } else if ((ch === 'v' || key.name === 'delete') && cur?.isMaster) {
+    // La bóveda no se echa a sí misma: el acta la necesita para poder sellarse. Se dice
+    // en vez de mandar la orden y enseñar el error del daemon, que no explica nada.
+    flash(st, i.cantRemoveMaster, 'warn')
   } else if ((ch === 'v' || key.name === 'delete') && (cur?.sub || cur?.nonce != null)) { // quitar el aparato seleccionado
     setConfirm(st, {
       text: i.revokeConfirm(cur.deviceId),
@@ -1111,4 +1164,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, profileRows, deviceRows, secretRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang }
+export const __test = { render, profileRows, deviceRows, secretRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }

package/src/tui/i18n.js

@@ -128,13 +128,17 @@ const es = {
   pendingHint: '  — pulsa A para aprobar, X para rechazar',
   noDevices: '  (sin dispositivos enrolados — pulsa P para emparejar uno)',
   noLabel: '(sin etiqueta)',
+  // Está en el acta y no puede entrar: o le retiraron el certificado, o se le venció.
+  deviceNoAccess: 'SIN ACCESO — está en el acta pero no puede entrar',
+  thisVault: 'esta bóveda (manda ella)',
+  cantRemoveMaster: 'Esta bóveda es la que manda: no se quita a sí misma.',
   revokedCount: (n) => `  Revocados: ${n}`,
   startingPairing: 'Iniciando emparejamiento…',
   noPending: 'No hay ningún dispositivo pendiente',
   noPendingToReject: 'No hay ningún dispositivo pendiente para rechazar',
   rejecting: 'Rechazando…',
   deviceRejected: 'Dispositivo rechazado',
-  revokeConfirm: (id) => `¿Revocar ${id}? Se le ordena autoborrarse al reconectar.`,
+  revokeConfirm: (id) => `¿Quitar ${id} del perfil? Sale del acta, se le retiran los certificados y se le ordena autoborrarse al reconectar.`,
   revoking: 'Revocando…',
   deviceRevoked: (id) => `Revocado ${id}`,
   approveLabel: (id) => `Código que MUESTRA el dispositivo ${id}`,
@@ -351,13 +355,16 @@ const en = {
   pendingHint: '  — press A to approve, X to reject',
   noDevices: '  (no devices enrolled — press P to pair one)',
   noLabel: '(no label)',
+  deviceNoAccess: 'NO ACCESS — it is on the record but cannot get in',
+  thisVault: 'this vault (it is the Master)',
+  cantRemoveMaster: 'This vault is the Master: it does not remove itself.',
   revokedCount: (n) => `  Revoked: ${n}`,
   startingPairing: 'Starting pairing…',
   noPending: 'No device is waiting',
   noPendingToReject: 'No device is waiting to be rejected',
   rejecting: 'Rejecting…',
   deviceRejected: 'Device rejected',
-  revokeConfirm: (id) => `Revoke ${id}? It is told to erase itself on reconnect.`,
+  revokeConfirm: (id) => `Remove ${id} from the profile? It leaves the record, its certificates are withdrawn and it is told to erase itself on reconnect.`,
   revoking: 'Revoking…',
   deviceRevoked: (id) => `Revoked ${id}`,
   approveLabel: (id) => `Code SHOWN by device ${id}`,

package/src/vault.js

@@ -17,6 +17,7 @@ import { verifyChain, pubkeyId } from '@dotrino/identity/capabilities'
 import * as Acta from '@dotrino/identity/acta'
 import { createEnrollDesk, deviceIdOf, DEVICE_TTL_MS } from '../lib/src/enroll.js'
 import { createAdminDesk } from '../lib/src/admin.js'
+import { shouldNotifyRevoked } from '../lib/src/revocation.js'
 import { createTransport, masterPubkeyOf } from './transport.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
@@ -145,7 +146,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       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: 'unauthorized: ' + chk.reason }) }
+    if (!chk.ok) return denyChain(from, chk, p, 'sign')
     const toSign = p.data?.payload
     if (toSign == null) return reply(from, { type: MSG.ERROR, error: 'data.payload required' })
     const { signature, publickey } = await identity.signData(toSign)
@@ -159,7 +160,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       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: 'unauthorized: ' + chk.reason })
+    if (!chk.ok) return denyChain(from, chk, p, 'get')
     const id = p.data?.id || 'root'
     reply(from, { type: MSG.DATA, id, node: store.getNode(id) })
   }
@@ -187,7 +188,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     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: 'unauthorized: ' + chk.reason })
+    if (!chk.ok) return denyChain(from, chk, p, 'store')
     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
@@ -227,30 +228,55 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
    * — y hasta ahora el daemon no lo reemitía nunca. Si el aparato estaba apagado cuando lo
    * quitaste, no se enteraba jamás: seguía enseñando el perfil como si nada.
    */
-  async function avisarSiRevocado (pubkey) {
+  async function notifyIfRevoked (pubkey, nonce = null, certIss = null, reason = 'revoked') {
     if (typeof pubkey !== 'string') return
     try {
-      // OJO con dónde se buscan: desde identity 0.42 `issued` es «lo que HOY sirve para
-      // entrar», así que los retirados NO están ahí — viven en `revokedCerts`. Buscarlos
-      // en `issued` no daba error, daba una lista vacía y ningún aviso.
-      const dele = await identity.listDelegations()
-      const revocados = await revocationSet()
-      const candidatos = [...(dele.revokedCerts || []), ...(dele.issued || [])]
-      const suyas = candidatos.filter((x) => x.sub === pubkey && (x.revokedAt || revocados.has(x.nonce)))
-      if (suyas.length) {
-        await desk.emitRevoke(pubkey, suyas[0].nonce)
-        audit('revoke.notified', { device: await deviceIdOf(pubkey).catch(() => null) })
+      const record = (await identity.profileActa?.().catch(() => null))?.acta || null
+      // Sin acta (bóveda anterior al acta) hay que mirar las delegaciones, que es lo único
+      // que queda. OJO con dónde se buscan: desde identity 0.42 `issued` es «lo que HOY
+      // sirve para entrar», así que los retirados NO están ahí — viven en `revokedCerts`.
+      let knownRevoked = false
+      let fallbackNonce = null
+      if (!record) {
+        const delegations = await identity.listDelegations()
+        const revoked = await revocationSet()
+        const candidates = [...(delegations.revokedCerts || []), ...(delegations.issued || [])]
+        const theirs = candidates.filter((x) => x.sub === pubkey && (x.revokedAt || revoked.has(x.nonce)))
+        knownRevoked = theirs.length > 0
+        fallbackNonce = theirs[0]?.nonce || null
       }
+      if (!shouldNotifyRevoked({ reason, pubkey, master, certIss, members: record?.members || null, knownRevoked })) return
+      // El aviso nombra el certificado que el aparato ACABA de presentar: es el que tiene
+      // en la mano, y es contra ese contra el que comprueba antes de borrarse.
+      await desk.emitRevoke(pubkey, nonce || fallbackNonce)
+      audit('revoke.notified', { device: await deviceIdOf(pubkey).catch(() => null), reason })
     } catch (e) { log('[vault] could not re-emit the revocation:', e.message) }
   }
 
+  /**
+   * Rechaza una petición y, si el aparato ya no es del perfil, SE LO DICE con el aviso
+   * firmado — sea cual sea la operación que estuviera intentando.
+   *
+   * Un dispositivo que fue tuyo tiene que poder llegar hasta aquí precisamente para que se
+   * le pueda mandar a paseo: es el único mensaje que le borra la cuenta, porque es el único
+   * que va firmado por la maestra (un «unauthorized» suelto no borra nada y no debe: sería
+   * destruir datos ajenos con un mensaje, el wipe-DoS de `docs/pairing-protocol.md §2.3`).
+   *
+   * Antes esto solo pasaba en `devices` —la pantalla de dispositivos— y solo si el papel
+   * estaba REVOCADO. Un aparato quitado que estuviera guardando notas nunca preguntaba por
+   * ahí, y uno al que simplemente se le venció el certificado no entraba en el caso: los
+   * dos se quedaban enseñando la cuenta indefinidamente.
+   */
+  async function denyChain (from, chk, p, what) {
+    await notifyIfRevoked(p.data?.publickey, p.cert?.nonce || null, p.cert?.iss || null, chk.reason)
+    if (what) audit('rejected', { what, reason: chk.reason })
+    return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
+  }
+
   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) {
-      if (chk.reason === 'revoked') await avisarSiRevocado(p.data?.publickey)
-      return reply(from, { type: MSG.ERROR, error: 'unauthorized: ' + chk.reason })
-    }
+    if (!chk.ok) return denyChain(from, chk, p, null)
     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.
@@ -286,7 +312,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   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: 'unauthorized: ' + chk.reason }) }
+    if (!chk.ok) return denyChain(from, chk, p, 'renew')
     // 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)
@@ -327,7 +353,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       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: 'unauthorized: ' + chk.reason }) }
+    if (!chk.ok) return denyChain(from, chk, p, 'secrets')
     // 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.
@@ -480,7 +506,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         data, signature, cert,
         expectedScope: SCOPE.ADMIN, trustedIssuer: master, revoked: await revocationSet()
       })
-      if (!chk.ok) return chk
+      // Quitarse a UNO MISMO desde la consola remota entra por aquí: la segunda petición
+      // que mande el aparato ya llega con el certificado retirado. Que se entere con el
+      // aviso firmado, en vez de con un error suelto que no puede borrar nada.
+      if (!chk.ok) {
+        await notifyIfRevoked(data?.publickey, cert?.nonce || null, cert?.iss || null, chk.reason)
+        return chk
+      }
       const acta = (await identity.profileActa?.().catch(() => null))?.acta
       if (acta && !Acta.memberCan(acta, chk.device, 'admin')) return { ok: false, reason: 'acta' }
       return chk

package/src/vaultControl.js

@@ -179,13 +179,17 @@ export const removeProfilePassword = (profile) => profileOp('password-rm', { pro
  */
 export async function snapshot (profile) {
   requireAlive()
-  rm(F.devices); rm(F.secretsList); rm(F.profilesList)
+  rm(F.devices); rm(F.secretsList); rm(F.profilesList); rm(F.acta)
   writeReq(F.dumpReq, {}, profile)
   signalOrCleanup('SIGUSR2', [F.dumpReq])
-  const [devices, secrets, profiles] = await Promise.all([
-    waitFor(F.devices), waitFor(F.secretsList), waitFor(F.profilesList)
+  // El ACTA entra en el volcado normal: es la lista de dispositivos de verdad, y las
+  // delegaciones son su reflejo. Sin ella, un miembro sin certificados (revocado a medias,
+  // o con el papel caducado) no salía en ninguna pantalla del PC — invisible y, por lo
+  // tanto, imposible de quitar desde aquí.
+  const [devices, secrets, profiles, acta] = await Promise.all([
+    waitFor(F.devices), waitFor(F.secretsList), waitFor(F.profilesList), waitFor(F.acta)
   ])
-  return { devices, secrets, profiles }
+  return { devices, secrets, profiles, acta }
 }
 
 /**
@@ -193,14 +197,22 @@ export async function snapshot (profile) {
  * `issued` viene de identity.listDelegations(); el deviceId se deriva del `sub`.
  */
 export async function listDevices (profile) {
-  const { devices } = await snapshot(profile)
+  const { devices, acta } = await snapshot(profile)
   if (!devices) throw coded('the daemon did not reply', 'NO_REPLY')
   const issued = devices.issued || devices.active || devices.delegations || []
   const revoked = devices.revoked || []
   const withIds = await Promise.all(issued.map(async (d) => ({
     ...d, deviceId: d.sub ? await deviceIdOf(d.sub) : '????-????'
   })))
-  return { issued: agruparPorAparato(withIds, revoked), revoked, profile: devices.profile || null }
+  // Los MIEMBROS viajan con la lista: quién es del perfil lo dice el acta, y los
+  // certificados son su reflejo. Quien pinte la lista los necesita a la vez, o acaba
+  // enseñando solo a los que tienen papel — y el que hay que quitar es justo el que no.
+  return {
+    issued: agruparPorAparato(withIds, revoked),
+    revoked,
+    members: acta?.members || [],
+    profile: devices.profile || null
+  }
 }
 
 /**