@dotrino/vaultd 0.141.0 → 0.142.0

package/README.md

@@ -237,6 +237,7 @@ dotrino-vault devices              # lista dispositivos enrolados / revocados
 dotrino-vault members              # el acta del perfil: qué llaves son tuyas y qué puede cada una
 dotrino-vault caps <ID> ±permiso   # cambia lo que puede un dispositivo (+firma -guarda +lee +administra +aprueba …)
 dotrino-vault revoke  <nonce>      # revoca un dispositivo (le ordena autoborrarse)
+dotrino-vault block   <ID>         # lo deja fuera sin quitarlo del acta; unblock <ID> lo deshace (solo aquí o por el admin)
 dotrino-vault activity [n]         # bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
 dotrino-vault pair --service <ns>  # empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
 dotrino-vault pair --scope <lista>  # los PERMISOS con los que entra (cualquiera de caps: firma,lee,guarda,administra,aprueba…

package/lib/src/admin.js

@@ -47,6 +47,9 @@ export const ADMIN_OPS = Object.freeze([
   // `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.
   'revoke', 'audit',
+  // Los BLOQUEADOS por un aprobador (`src/blocked.js`): verlos y desbloquearlos. Bloquear a
+  // distancia también, por si el administrador llega antes que el teléfono. No toca el acta.
+  'blocked', 'block', 'unblock',
   // 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.
@@ -96,6 +99,8 @@ export const ADMIN_OPS = Object.freeze([
  */
 export const ADMIN_OPS_WHILE_LOCKED = Object.freeze([
   'audit', 'vars', 'var.set', 'var.setMany', 'var.recipients',
+  // Bloquear no sella nada: la lista es de la bóveda, no del acta.
+  'blocked', 'block', 'unblock',
   // Las dos de abrir, obviamente: son las únicas que solo tienen sentido con el candado
   // echado. Que estén aquí NO las deja pasar sin más — siguen exigiendo cert, acta, nonce
   // y frescura como todas, y además la contraseña dentro del sobre.
@@ -147,6 +152,8 @@ export function createAdminDesk ({
   // este módulo es puro a propósito. `null` en una bóveda que no lo soporte: entonces la
   // operación existe y contesta que no, en vez de romper con un TypeError.
   unlockDesk = null,
+  // La lista de bloqueados, inyectada como `vars`: `{ list(), set(pub, on, { by }) }`.
+  blocked = null,
   now = () => Date.now()
 }) {
   const ops = new Set(ADMIN_OPS)
@@ -333,6 +340,14 @@ export function createAdminDesk ({
       // 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 === 'blocked' || data.op === 'block' || data.op === 'unblock') {
+        if (!blocked) return { ok: false, error: 'admin: this vault cannot block devices' }
+        if (data.op === 'blocked') return { ok: true, result: { items: blocked.list() } }
+        if (typeof data.sub !== 'string' || !data.sub) return { ok: false, error: `admin: ${data.op} needs the device key (sub)` }
+        const r = await blocked.set(data.sub, data.op === 'block', { by })
+        audit(`admin.${data.op}`, { by, device: await deviceIdOf(data.sub).catch(() => null) })
+        return { ok: true, result: { ok: true, was: r } }
+      }
       if (data.op === 'revoke') {
         if (data.sub) {
           const deviceId = await deviceIdOf(String(data.sub)).catch(() => null)

package/lib/src/protocol.js

@@ -103,6 +103,13 @@ export const MSG = Object.freeze({
   // una forma de echar a alguien de su cuenta.
   LOGIN_CLOSE: 'vault.login.close',           // aparato → vault: { data:{op,user,sid,publickey,ts}, signature }
   LOGIN_CLOSED: 'vault.login.closed',         // vault → aparato: { ok }
+  // INCIDENTE: un agente de la cuenta (la terminal) avisa de que OTRO aparato de la cuenta
+  // se equivocó de clave tres veces seguidas. La bóveda lo apunta como un pedido más
+  // (`kind: 'incident'`), timbra a quien aprueba, y el aprobador bloquea o ignora. Bloquear
+  // no toca el acta: es una lista de la bóveda (`blocked.json`) que viaja a los agentes con
+  // `vault.devices.result` (`blocked`) y se deshace con `dotrino-vault unblock <ID>`.
+  INCIDENT: 'vault.incident',                 // agente → vault: { data:{op:'incident',kind,about,tries,publickey,ts}, signature, cert }
+  INCIDENT_RESULT: 'vault.incident.result',   // vault → agente: { id, approvers, blocked }
   ERROR: 'vault.error'                        // vault → dispositivo: { error }
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.141.0",
+  "version": "0.142.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": {
@@ -50,7 +50,7 @@
     "!lib/src/types.d.ts"
   ],
   "devDependencies": {
-    "@dotrino/remote-agent": "0.10.0",
+    "@dotrino/remote-agent": "0.13.0",
     "@types/node": "^22.0.0",
     "typescript": "5.9.3"
   },

package/src/blocked.js

@@ -0,0 +1,71 @@
+/**
+ * LOS APARATOS BLOQUEADOS: la lista que un aprobador decide y solo la bóveda deshace.
+ *
+ * Un agente (la terminal, por ahora) reporta un INCIDENTE cuando un aparato de la cuenta se
+ * equivoca de clave tres veces seguidas. El aprobador lo ve en su teléfono y elige: bloquear
+ * o ignorar. Bloquear NO es revocar: el aparato sigue en el acta —no hace falta la maestra, y
+ * la bóveda vive cerrada—, pero la bóveda deja de atenderle y los agentes, que reciben esta
+ * lista con el acta, le cierran la puerta. Se deshace aquí (`dotrino-vault unblock <ID>`) o
+ * desde la consola de administración; un aprobador solo bloquea.
+ *
+ * Va en el disco cifrado en reposo como las contraseñas: es parte del mapa de la cuenta.
+ * Se carga UNA vez: un archivo que existe y no se puede leer NO es «nadie bloqueado» — se
+ * lanza, y la bóveda no arranca con una lista que no puede saber.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+
+export const BLOCKED_FILE = 'blocked.json'
+
+const fail = (code, message) => Object.assign(new Error(message), { code })
+
+/**
+ * @param {{ dir: string, atRest: { encrypt: (s: string) => string, decrypt: (s: string) => string }, now?: () => number }} opts
+ */
+export function openBlocked ({ dir, atRest, now = Date.now }) {
+  const file = path.join(dir, BLOCKED_FILE)
+  /** pub → { deviceId, label, since, by, reason } */
+  let items = load()
+
+  function load () {
+    let raw
+    try { raw = fs.readFileSync(file, 'utf8') } catch (e) {
+      if (e.code === 'ENOENT') return new Map()
+      throw fail('blocked-unreadable', `cannot read ${BLOCKED_FILE}: ${e.message}`)
+    }
+    let d
+    try { d = JSON.parse(atRest.decrypt(raw)) } catch (e) { throw fail('blocked-unreadable', `${BLOCKED_FILE} cannot be opened: ${e.message}`) }
+    if (d?.v !== 1 || !d.items || typeof d.items !== 'object') throw fail('blocked-unreadable', `${BLOCKED_FILE} has an unknown shape`)
+    return new Map(Object.entries(d.items))
+  }
+
+  function save () {
+    const tmp = file + '.tmp'
+    fs.writeFileSync(tmp, atRest.encrypt(JSON.stringify({ v: 1, items: Object.fromEntries(items) })), { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  }
+
+  const publicOf = (pub, b) => ({ pub, deviceId: b.deviceId || null, label: b.label || '', since: b.since, by: b.by || null, reason: b.reason || null })
+
+  return {
+    has: (pub) => items.has(pub),
+    pubs: () => [...items.keys()],
+    list: () => [...items].map(([pub, b]) => publicOf(pub, b)),
+    /** Bloquea. Devuelve la entrada; si ya estaba, la que había (no se pisa el «desde cuándo»). */
+    block ({ pub, deviceId = null, label = '', by = null, reason = null }) {
+      if (typeof pub !== 'string' || !pub) throw fail('bad-pub', 'block: a device key is required')
+      if (items.has(pub)) return publicOf(pub, items.get(pub))
+      const b = { deviceId, label, since: now(), by, reason }
+      items.set(pub, b)
+      save()
+      return publicOf(pub, b)
+    },
+    /** Desbloquea. `true` si estaba. */
+    unblock (pub) {
+      if (!items.has(pub)) return false
+      items.delete(pub)
+      save()
+      return true
+    }
+  }
+}

package/src/ctl.js

@@ -140,7 +140,7 @@ function cmdStatus () {
   // corriendo es más viejo que el CLI, avisar (nos mordió 3 veces).
   if (s.version && s.version !== VERSION) {
     console.log('  ⚠ el servicio corre la versión %s (binario instalado: %s).', s.version, VERSION)
-    console.log('    Reinicia para actualizarlo:  %s', RESTART_HINT)
+    console.log('    Si acabas de actualizar, se pone al día solo en uno o dos minutos. Si no:  %s', RESTART_HINT)
   }
   console.log('  fingerprint : %s', s.fingerprint)
   console.log('  proxy       : %s', s.proxy)
@@ -598,7 +598,11 @@ async function cmdMembers () {
   console.log('\n%sPerfil%s %s · acta #%d\n', B, Z, profileId, record.seq)
   for (const m of record.members) {
     const who = m.label || m.id
+    const bloqueo = (record.blocked || []).find((b) => b.pub === m.pub)
     const marks = [
+      // BLOQUEADO va primero y resaltado: es lo que hay que ver antes que ningún permiso,
+      // porque mientras dure ningún permiso cuenta.
+      bloqueo ? `${B}BLOQUEADO${Z} desde el ${fechaCorta(bloqueo.since)} (dotrino-vault unblock ${m.id})` : null,
       // Ya no hay UN master: la marca dice quién puede sellar, y pueden ser varios. El
       // permiso también sale abajo en la lista, pero aquí se ve de un vistazo — que es
       // justo lo que se busca al mirar quién es quién.
@@ -667,6 +671,33 @@ async function cmdLabel (args = []) {
   console.log('Listo: %s ahora se llama «%s». Compruébalo con: dotrino-vault members', m.id, name.slice(0, 60))
 }
 
+/**
+ * BLOQUEAR / DESBLOQUEAR un aparato de la cuenta. Lo normal es que bloquee el aprobador desde
+ * el teléfono, al recibir el incidente de un agente (la terminal: tres claves mal seguidas);
+ * desbloquear SOLO se hace aquí o desde la consola de administración (dueño, 2026-10-07).
+ * No toca el acta: el aparato sigue siendo miembro, pero la bóveda y los agentes no le
+ * atienden hasta que se le quite el bloqueo.
+ */
+async function cmdBlock (on, args = []) {
+  const [id] = args
+  const verb = on ? 'block' : 'unblock'
+  if (!id) { console.error(`uso: dotrino-vault ${verb} <ID>`); process.exit(2) }
+  const s = requireDaemon()
+  const m = await findMember(id)
+  const resFile = path.join(dataDir(), 'block.json')
+  try { fs.rmSync(resFile, { force: true }) } catch (_) {}
+  const reqId = Math.random().toString(36).slice(2)
+  writeReq('block-request.json', { id: reqId, pub: m.pub, on })
+  sendSignal(s.pid, 'SIGUSR2')
+  let r = null
+  for (let i = 0; i < 50; i++) { await sleep(100); const a = ipcRead(resFile, null); if (a?.at && a.req === reqId) { r = a; break } }
+  if (!r) { console.error('El daemon no respondió.'); process.exit(1) }
+  if (!r.ok) { console.error('No se pudo %s: %s', on ? 'bloquear' : 'desbloquear', r.error); process.exit(1) }
+  if (on) console.log('Bloqueado %s. La bóveda y tus agentes no le atienden hasta: dotrino-vault unblock %s', m.id, m.id)
+  else if (r.was) console.log('Desbloqueado %s. Compruébalo con: dotrino-vault members', m.id)
+  else console.log('%s no estaba bloqueado.', m.id)
+}
+
 /** Busca un miembro del acta por su identificador (AB12-CD34) o se rinde con un mensaje claro. */
 async function findMember (id) {
   const s = requireDaemon()
@@ -1732,6 +1763,30 @@ async function cmdLogins (rest) {
  * Instalar no reinicia nada a mano: el daemon vigila su propio binario y, al cambiar, se
  * va para que systemd lo levante con el nuevo (`src/selfupdate.js`).
  */
+/**
+ * ESPERA A QUE EL SERVICIO CORRA LA VERSIÓN INSTALADA, y lo dice. El servicio se reinicia
+ * solo cuando ve el binario nuevo (`selfupdate.js`), pero espera a verlo quieto dos minutos
+ * seguidos: decir «se reinicia solo, compruébalo con status» y que `status` contestara un
+ * minuto después «reinicia para actualizarlo» era mandar a hacer a mano lo que ya iba a pasar.
+ */
+async function waitForService (version, { timeoutMs = 4 * 60_000 } = {}) {
+  const s0 = ipcRead(stateFile, null)
+  if (!s0 || !alive(s0.pid)) {
+    console.log('El servicio no está corriendo: arráncalo y ya será la %s.  %s', version, START_HINT)
+    return false
+  }
+  process.stdout.write('El servicio la arranca solo en uno o dos minutos. Esperando… ')
+  const t0 = Date.now()
+  while (Date.now() - t0 < timeoutMs) {
+    const s = ipcRead(stateFile, null)
+    if (s?.version === version && alive(s.pid)) { console.log('✓ ya corre la %s', version); return true }
+    await sleep(3000)
+  }
+  console.log('')
+  console.error('El servicio sigue sin correr la %s después de %d min. Reinícialo:  %s', version, Math.round(timeoutMs / 60000), RESTART_HINT)
+  return false
+}
+
 async function cmdUpdate (args = []) {
   const { latestRelease, assetFor, download, verifyArtifact, isNewer, isUserInstall, installUserRelease } = await import('./update.js')
   const soloMirar = args.includes('--check')
@@ -1763,7 +1818,8 @@ async function cmdUpdate (args = []) {
       process.exit(1)
     }
     console.log('firmada por el release de %s ✓', 'imdotrino/dotrino-vault')
-    console.log('Instalada la %s. El servicio se reinicia solo; compruébalo con:  dotrino-vault status', res.version)
+    console.log('Instalada la %s.', res.version)
+    if (!args.includes('--no-wait')) await waitForService(res.version)
     return
   }
 
@@ -2110,6 +2166,8 @@ function help () {
 
   tui                 interfaz de terminal a pantalla completa (bóvedas, pares, secretos)
   status | info       estado del servicio + fingerprint + el id de cada perfil
+  update [--check]   trae la versión nueva (verificando la firma) y espera a que el
+                     servicio la arranque · --check solo mira · --no-wait no espera
   pair [--save <f>]   inicia un emparejamiento (QR + espera); --save escribe la invitación (.dpair)
   pair --kms <config.json>
                       el sitio que se cree (--adopt o --new-account) NACE con su clave
@@ -2182,6 +2240,10 @@ function help () {
                       +sella = OTRA BÓVEDA que puede sellar el acta de esta cuenta, para
                       que perder una máquina no se la lleve. No es un traspaso
   revoke <ID|nonce>   quita un dispositivo (con el ID, todos sus certificados)
+  block <ID>          bloquea un aparato sin quitarlo: la bóveda y tus agentes dejan de
+                      atenderle. Lo normal es bloquear desde el teléfono al recibir el
+                      incidente (la terminal: tres claves mal seguidas)
+  unblock <ID>        le quita el bloqueo (solo desde aquí o desde la consola de admin)
   logins              los aparatos que se abren con usuario y contraseña (para un equipo
                       prestado, donde no puedes emparejar nada)
   logins add <usuario> [nombre del equipo] [±permiso …]
@@ -2320,6 +2382,10 @@ async function cmdReplica (args) {
 
 export async function runCtl (argv) {
   const [cmd, ...rest] = takeProfileFlag(argv)
+  // `--help` EN CUALQUIER COMANDO ENSEÑA LA AYUDA Y NO HACE NADA. Ningún subcomando lo miraba,
+  // así que se ejecutaban igual: `pair --help` lanzaba una invitación real y `update --help`
+  // instalaba la versión nueva (2026-10-05). Mirar cómo se usa algo no puede cambiar nada.
+  if (rest.includes('--help') || rest.includes('-h')) return help()
   switch (cmd) {
     case 'tui': return cmdTui()
     case 'profile': return cmdProfile(rest)
@@ -2340,6 +2406,8 @@ export async function runCtl (argv) {
     case 'label': return cmdLabel(rest)
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])
+    case 'block': return cmdBlock(true, rest)
+    case 'unblock': return cmdBlock(false, rest)
     case 'logins': return cmdLogins(rest)
     case 'update': return cmdUpdate(rest)
     case 'secret': return cmdSecret(rest)

package/src/daemon.js

@@ -638,6 +638,25 @@ export async function runDaemon () {
           console.log('[vault] device renamed: %s', labelReq.label || '(no name)')
         } catch (e) { console.error('[vault] could not rename the device:', e.message) }
       }
+      // BLOQUEAR / DESBLOQUEAR un aparato (`dotrino-vault block|unblock <ID>`). No toca el
+      // acta, así que funciona con el perfil cerrado; se contesta en `block.json`.
+      const blockReq = readJsonSafe(path.join(dir, 'block-request.json'))
+      if (blockReq?.pub && typeof blockReq.on === 'boolean') {
+        rm(path.join(dir, 'block-request.json'))
+        const answer = (extra) => ipcWrite(path.join(dir, 'block.json'), { v: 1, at: Date.now(), req: blockReq.id || null, ...extra })
+        try {
+          // Con el perfil CERRADO también: bloquear no sella nada, y un aparato que está
+          // probando claves no espera a que el dueño abra la bóveda.
+          const vault = resolveTarget(blockReq)?.vault
+          if (!vault) throw Object.assign(new Error('no vault for that profile'), { code: 'NO_PROFILE' })
+          const r = await vault.setBlocked(blockReq.pub, blockReq.on, { by: 'vault' })
+          console.log('[vault] device %s', blockReq.on ? 'blocked' : (r ? 'unblocked' : 'was not blocked'))
+          answer({ ok: true, on: blockReq.on, was: r })
+        } catch (e) {
+          console.error('[vault] could not %s the device: %s', blockReq.on ? 'block' : 'unblock', e.message)
+          answer({ ok: false, error: e.message, code: e.code || 'BLOCK_FAILED' })
+        }
+      }
       const capsReq = readJsonSafe(path.join(dir, 'caps-request.json'))
       // VARIOS APARATOS, UNA ACTA (el borrador de la TUI). Se contesta con el `id` de la
       // petición, para que quien espera sepa si se firmó de verdad.
@@ -894,7 +913,7 @@ export async function runDaemon () {
         lastSecretHistory = null
         ipcWrite(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
         // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
-        try { ipcWrite(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()) }) } catch (_) {}
+        try { ipcWrite(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()), blocked: t.vault.listBlocked?.() || [] }) } catch (_) {}
       }
 
       // PERFIL del usuario (apodo, foto, datos) tal como lo tiene la bóveda: `dotrino-vault me`.

package/src/vault.js

@@ -29,6 +29,7 @@ import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar, RECOVERY as RECOVERY_WRAP, PROFILE_OWNER } from './secretsStore.js'
 import { openSubacta } from './subacta.js'
+import { openBlocked } from './blocked.js'
 import { makeEphemeralKey, openSealed } from '../lib/src/sealed.js'
 import { VERSION } from './version.js'
 import { declare as compatDeclare, check as compatCheck, annotate as compatAnnotate } from '@dotrino/compat'
@@ -259,6 +260,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   // además un emparejamiento paralelo al del ecosistema.
   const passwordsFile = path.join(dir, 'passwords.json')
   const passwordsAtRest = atRestFor(dir)
+  // Los aparatos BLOQUEADOS por un aprobador (`src/blocked.js`). Cifrado en reposo como lo demás.
+  const blocked = openBlocked({ dir, atRest: passwordsAtRest })
   const readPasswordsFile = () => {
     try { return JSON.parse(passwordsAtRest.decrypt(fs.readFileSync(passwordsFile, 'utf8'))) } catch (_) { return null }
   }
@@ -603,6 +606,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const verifyChain = async (args) => {
     const chk = await verifyChainRaw(args)
     if (chk.ok && args?.data?.v) apuntarVersion(chk.device, args.data.v)
+    // UN BLOQUEADO NO PASA POR NINGÚN MOSTRADOR. Sigue en el acta —bloquear no la toca,
+    // porque la bóveda vive cerrada y eso lo decide un aprobador desde el teléfono—, así que
+    // el papel verifica; la puerta se cierra aquí, que es por donde entra todo, y con su
+    // propio `reason` para que el otro lado sepa qué le pasa y no lo confunda con un papel
+    // viejo (que se arregla renovando) ni con una revocación (que se arregla emparejando).
+    if (chk.ok && blocked.has(chk.device)) return { ok: false, reason: 'blocked', device: chk.device }
     return chk
   }
 
@@ -1281,7 +1290,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
         return reply(from, { type: MSG.ERROR, error: 'unauthorized: this vault has no record to decide with' })
       }
       audit('devices', { device: await deviceIdOf(chk.device).catch(() => null), solo: 'revocaciones' })
-      return reply(from, { type: MSG.DEVICES_RESULT, devices: [], revoked, acta: record })
+      return reply(from, { type: MSG.DEVICES_RESULT, devices: [], revoked, blocked: blocked.pubs(), acta: record })
     }
     // 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.
@@ -1313,7 +1322,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // LA SUBACTA VIAJA CON EL ACTA. Es la mitad de «se comparte entre todos los
     // dispositivos»: sin esto, una renuncia sin sellar solo la respeta esta máquina.
     // Cada entrada va firmada por su sujeto, así que quien la recibe la verifica sola.
-    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, acta: record, chain, vault: MI_VERSION, subacta: subacta.entries() }))
+    reply(from, fitChain({ type: MSG.DEVICES_RESULT, devices, revoked, blocked: blocked.pubs(), acta: record, chain, vault: MI_VERSION, subacta: subacta.entries() }))
   }
 
   /**
@@ -1580,7 +1589,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (p.data?.op === 'enckey') return handleEncKey(from, p)
     if (p.data?.op === 'store.recipients' || p.data?.op === 'store') return handleVarStore(from, p)
     if (p.data?.op === 'digest') return handleDigest(from, p)
-    if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke'].includes(p.data?.op)) return handleApproval(from, p)
+    if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke', 'block', 'blocked'].includes(p.data?.op)) return handleApproval(from, p)
     const ns = p.data?.ns
     if (!isValidSecretsNs(ns)) return reply(from, { type: MSG.ERROR, error: 'secrets: invalid namespace' })
     if (typeof p.data?.ek !== 'string') return reply(from, { type: MSG.ERROR, error: 'secrets: missing ek (requester ephemeral key)' })
@@ -1759,6 +1768,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // renueva con cada uso puede durar indefinidamente: si no se puede mirar ni quitar desde
     // el mismo sitio donde se dio, es un permiso invisible, y eso no lo damos por bueno.
     if (op === 'grants') return answer({ op: 'grants', items: await conContextoSellado(grants.list(), chk.device, record), ttlMs: GRANT_TTL_MS })
+    // LOS BLOQUEADOS SE VEN desde donde se bloquean. Desbloquear no: eso es de la bóveda
+    // (`dotrino-vault unblock <ID>`) o del administrador, que es lo que pidió el dueño.
+    if (op === 'blocked') return answer({ op: 'blocked', items: blocked.list() })
     if (op === 'grant-revoke') {
       const gid = typeof p.data?.id === 'string' ? p.data.id : ''
       const ok = gid ? grants.revoke(gid) : false
@@ -1771,6 +1783,31 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     const id = typeof p.data?.id === 'string' ? p.data.id : ''
     const pend = approvals.take(id)
     if (!pend) return reply(from, { type: MSG.ERROR, error: 'approval: unknown or expired request' })
+    // UN INCIDENTE no entrega nada: se contesta BLOQUEAR (`block`) o IGNORAR (`deny`).
+    // `approve` no significa nada aquí y se rechaza en voz alta: el pedido vuelve a la mesa
+    // para que lo conteste con la palabra correcta.
+    if (pend.kind === 'incident') {
+      if (op !== 'block' && op !== 'deny') {
+        approvals.request({ ...pend, ttlMs: Math.max(1000, pend.exp - Date.now()) })
+        return reply(from, { type: MSG.ERROR, error: 'approval: an incident is answered with block or deny' })
+      }
+      if (op === 'deny') {
+        audit('incident.ignored', { device: pend.deviceId, kind: pend.ctx?.kind || null, id, by })
+        log(`[vault] incident ${id} about ${pend.deviceId} ignored by ${by}`)
+        return answer({ op: 'deny.result', id, ok: true })
+      }
+      const b = blocked.block({ pub: pend.device, deviceId: pend.deviceId, label: pend.label, by, reason: pend.ctx?.kind || 'incident' })
+      // Lo que ya tenía concedido se corta en el acto: bloquear y dejarle pasar la hora que
+      // le quedaba sería un bloqueo de mentira.
+      const cut = grants.revokeAll({ device: pend.device })
+      audit('blocked', { device: pend.deviceId, kind: pend.ctx?.kind || null, id, by, grants: cut })
+      log(`[vault] BLOCKED ${pend.deviceId}${pend.label ? ` (${pend.label})` : ''} by ${by} after incident ${id} · unblock with: dotrino-vault unblock ${pend.deviceId}`)
+      // Se avisa a todos: los agentes (la terminal) traen la lista con el acta al recibirlo
+      // y le cierran la sesión que tenga abierta. Sin esto el bloqueo esperaba al tic de 5 min.
+      await notifyMembers('blocked', { deviceId: pend.deviceId, by })
+      return answer({ op: 'block.result', id, ok: true, deviceId: pend.deviceId, since: b.since })
+    }
+    if (op === 'block') return reply(from, { type: MSG.ERROR, error: 'approval: only an incident can be blocked' })
     // PEDIDOS QUE NO ENTREGAN UN CAJÓN (la bóveda de contraseñas, guardar variables). Se
     // resuelven ANTES de tocar `resultFor`, que asume un cajón y una `ek`: aquí no hay nada
     // que sellar, solo una promesa esperando un sí o un no.
@@ -1903,6 +1940,57 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     } catch (e) { log('[vault] could not notify approvers:', e.message) }
   }
 
+  /**
+   * UN INCIDENTE: un agente de la cuenta dice que OTRO aparato de la cuenta se equivocó de
+   * clave tres veces seguidas (la terminal, `dotrino-terminal lock`). No se decide aquí
+   * nada: se apunta como un pedido más, de tipo `incident`, y se timbra a quien aprueba,
+   * que es quien bloquea o ignora desde el teléfono. Sin nadie que apruebe no hay a quién
+   * preguntar: se anota en la bitácora y se dice, y el agente se queda con su freno local.
+   *
+   * Quien reporta tiene que ser un miembro con `sign` (es lo que lo hace agente), y el
+   * señalado tiene que estar en el acta: un incidente sobre un desconocido no es un incidente.
+   * Y si el señalado ya está bloqueado no se vuelve a timbrar: se contesta que lo está.
+   */
+  async function handleIncident (from, p) {
+    if (!isFresh(p.data)) return staleReply(from)
+    const chk = await verifyChain({ data: p.data, signature: p.signature, cert: p.cert, ...(await contextoActa()), revoked: await revocationSet() })
+    if (!chk.ok) return denyChain(from, chk, p, 'incident')
+    const record = await refreshActa()
+    if (!record || !Acta.memberCan(record, chk.device, 'sign')) {
+      audit('rejected', { what: 'incident', reason: record ? 'acta' : 'sin-acta' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member cannot report incidents' })
+    }
+    const d = p.data || {}
+    const kind = typeof d.kind === 'string' ? d.kind.slice(0, 32) : ''
+    const about = typeof d.about === 'string' ? d.about : ''
+    const tries = Number.isInteger(d.tries) ? d.tries : null
+    if (d.op !== 'incident' || !kind || !about) return reply(from, { type: MSG.ERROR, error: 'incident: op, kind and about are required' })
+    const target = (record.members || []).find((m) => m.pub === about)
+    if (!target) return reply(from, { type: MSG.ERROR, code: 'unknown-device', error: 'incident: that device is not in the record' })
+    const by = await deviceIdOf(chk.device).catch(() => null)
+    const byLabel = (record.members || []).find((m) => m.pub === chk.device)?.label || ''
+    const deviceId = await deviceIdOf(about).catch(() => null)
+    audit('incident', { device: deviceId, by, kind, tries })
+    if (blocked.has(about)) {
+      log(`[vault] incident (${kind}) about ${deviceId} reported by ${by}: already blocked`)
+      return reply(from, { type: MSG.INCIDENT_RESULT, id: null, approvers: 0, blocked: true })
+    }
+    const approvers = (record.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).length
+    if (!approvers) {
+      log(`[vault] incident (${kind}) about ${deviceId} reported by ${by}: nobody can approve, so nobody is asked (grant it with: dotrino-vault caps <ID> +aprueba)`)
+      return reply(from, { type: MSG.INCIDENT_RESULT, id: null, approvers: 0, blocked: false })
+    }
+    // `ns` es el que reporta: la pantalla dice «X falló la clave de la terminal de Y». El
+    // contexto va sellado al aprobador como el de cualquier pedido.
+    const pend = approvals.request({
+      ns: by || 'incident', kind: 'incident', device: about, deviceId, label: target.label || '', ek: '',
+      ctx: { kind, tries, reporter: by, reporterLabel: byLabel }, from, ttlMs: UPDATE_TTL_MS
+    })
+    log(`[vault] incident (${kind}) about ${deviceId}${target.label ? ` (${target.label})` : ''} reported by ${by}: asking ${approvers} approver(s) (${pend.id})`)
+    await notifyApprovers(pend, record)
+    reply(from, { type: MSG.INCIDENT_RESULT, id: pend.id, approvers, blocked: false })
+  }
+
   client.on('message', (from, payload) => onMessage(from, payload))
 
   // EL MOSTRADOR LOCAL, siempre que se pueda. Si no se puede abrir (un sistema sin sockets
@@ -1933,6 +2021,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       if (payload.type === MSG.ADMIN) return await handleAdmin(from, payload)
       if (payload.type === MSG.RENOUNCE) return await handleRenounce(from, payload)
       if (payload.type === MSG.ADMIN_EVENT) return await handleAdminEvent(payload)
+      if (payload.type === MSG.INCIDENT) return await handleIncident(from, payload)
       if (payload.type === MSG.REPLICA_ACK) return await handleReplicaAck(from, payload)
       if (payload.type === MSG.LOGIN_START) return await handleLoginStart(from, payload)
       if (payload.type === MSG.LOGIN_FINISH) return await handleLoginFinish(from, payload)
@@ -2611,10 +2700,37 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return pend.id
   }
 
+  /**
+   * BLOQUEAR O DESBLOQUEAR A MANO, desde la bóveda (CLI/TUI) o desde la consola de
+   * administración. El camino normal para bloquear es el aprobador (`handleApproval`,
+   * `block`); desbloquear solo pasa por aquí, que es lo que pidió el dueño.
+   */
+  async function setBlocked (pub, on, { by = 'vault' } = {}) {
+    const deviceId = await deviceIdOf(pub).catch(() => null)
+    if (on) {
+      const record = await refreshActa()
+      const label = (record?.members || []).find((m) => m.pub === pub)?.label || ''
+      const b = blocked.block({ pub, deviceId, label, by, reason: 'manual' })
+      grants.revokeAll({ device: pub })
+      audit('blocked', { device: deviceId, by, kind: 'manual' })
+      log(`[vault] BLOCKED ${deviceId} by ${by}`)
+      await notifyMembers('blocked', { deviceId, by })
+      return b
+    }
+    const was = blocked.unblock(pub)
+    if (was) {
+      audit('unblocked', { device: deviceId, by })
+      log(`[vault] unblocked ${deviceId} by ${by}`)
+      await notifyMembers('unblocked', { deviceId, by })
+    }
+    return was
+  }
+
   const admin = createAdminDesk({
     desk,
     deviceIdOf,
     audit,
+    blocked: { list: () => blocked.list(), set: setBlocked },
     // Abrir a distancia. Va inyectado porque `admin.js` es puro y esto necesita cripto y
     // disco; `null` si este perfil no lo soporta, y entonces la operación contesta que no.
     unlockDesk,
@@ -4058,6 +4174,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // rotar su llave). Lo enseñan `secret list` y la consola: si no se ve, no se salda.
     rotationsDue,
     secretDebts,
+    // LOS BLOQUEADOS, y quitarlos de la lista (`dotrino-vault block|unblock <ID>`).
+    listBlocked: () => blocked.list(),
+    setBlocked,
     /**
      * QUIÉN tiene envoltura de la generación vigente de un cajón (llaves de firma, más
      * `#recovery`). Es diagnóstico: saber a cuántos se les envolvió no ayuda a abrir nada,