@dotrino/vaultd 0.141.1 → 0.143.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.1",
+  "version": "0.143.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

@@ -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()
@@ -2209,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 …]
@@ -2371,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/tui/app.js

@@ -160,6 +160,9 @@ function mergeMembersAndCerts (members, issued) {
   })
 }
 
+/** La entrada de bloqueo de un aparato (por su llave), o `null` si no está bloqueado. */
+const blockedOf = (st, pub) => (pub && (st.blocked || []).find((b) => b.pub === pub)) || null
+
 function activeProfile (st) {
   const list = st.profiles?.profiles || []
   return list.find((p) => p.current) || list[0] || null
@@ -388,11 +391,15 @@ function deviceRows (st, t) {
       (debt ? t.warn(`  ${i.deviceDebt(debt)}`) : '')
     // 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 status = d.noAccess
+    // BLOQUEADO: sigue en el acta pero la bóveda y los agentes no le atienden. Es un
+    // aviso (lo decidió un aprobador o el dueño), así que va en el color de aviso y
+    // delante de todo lo demás: es lo primero que hay que ver de esa fila.
+    const bloq = blockedOf(st, d.sub)
+    const status = (bloq ? t.warn(i.deviceBlocked) + '  ' : '') + (d.noAccess
       ? t.warn(i.deviceNoAccess)
       : d.isMaster
         ? t.muted(i.thisVault)
-        : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp))
+        : t.muted('scope:' + shortScope(d.scope)) + '  ' + t.muted('exp:' + fmtExp(d.exp)))
     const marca = conCambios.has(d.sub) ? t.bold('*') : ' '
     rows.push({ text: `${marca}${t.bold(d.deviceId)}  ${label}${desde}  ${status}${extra}`, sel: true, meta: d })
   }
@@ -909,7 +916,7 @@ async function refreshAll (term, st, api = vc) {
   // Cerrada: no se pide su contenido, y tampoco se enseña un error por mirarla desde
   // fuera. Lo que hubiera cargado se suelta, para no dejar en pantalla lo de antes.
   if (activeLocked(st)) {
-    st.devices = null; st.secrets = null; st.members = []; st.me = undefined; st.capsDrafts = {}
+    st.devices = null; st.secrets = null; st.members = []; st.blocked = []; st.me = undefined; st.capsDrafts = {}
     return
   }
   const r = await guard(term, st, L(st).loading, () => api.snapshot(activeId(st)))
@@ -920,7 +927,7 @@ async function refreshAll (term, st, api = vc) {
   if (secrets) st.secrets = { ns: secrets.ns || {}, dev: Array.isArray(secrets.dev) ? secrets.dev : [] }
   // 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 (record) st.members = record.members || []
+  if (record) { st.members = record.members || []; st.blocked = Array.isArray(record.blocked) ? record.blocked : [] }
   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 api.deviceIdOf(d.sub) : '????-????' }))), revoked: devices.revoked || [] }
@@ -939,6 +946,7 @@ async function refreshAll (term, st, api = vc) {
 function applyDump (st, v) {
   st.devices = v
   if (Array.isArray(v?.members)) st.members = v.members
+  if (Array.isArray(v?.blocked)) st.blocked = v.blocked
 }
 
 async function refreshDevices (term, st) {
@@ -1257,6 +1265,20 @@ async function onKeyDevices (term, st, key) {
       },
       onNo: () => { st.confirm = null }
     })
+  } else if (ch === 'b' && cur?.isMaster) {
+    flash(st, i.cantBlockMaster, 'warn')
+  } else if (ch === 'b' && cur?.sub) {
+    // BLOQUEAR / DESBLOQUEAR (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. Lo normal
+    // es que bloquee el aprobador desde el teléfono al recibir un incidente; desbloquear
+    // SOLO se hace aquí o desde la consola de administración. `b` = bloquear en Bóvedas
+    // también (k bloquea el perfil; esto es otro candado y otra tecla, para no confundir).
+    const on = !blockedOf(st, cur.sub)
+    const r = await guard(term, st, on ? i.blocking : i.unblocking, () => vc.setDeviceBlocked(cur.sub, on, activeId(st)))
+    if (r.ok) {
+      flash(st, on ? i.deviceBlockedMsg(cur.deviceId) : (r.v.was ? i.deviceUnblockedMsg(cur.deviceId) : i.deviceNotBlocked(cur.deviceId)))
+      await refreshDevices(term, st)
+    }
   } else if (ch === 'r' && cur) {
     // Renombrar: el nombre lo trae el aparato al emparejarse (y si no le diste uno, entra
     // con TU apodo de ese momento), así que a la semana ya no dice nada. `r` es renombrar
@@ -2298,8 +2320,11 @@ const helpSegs = (i, screen, st = {}) => {
   return segs({
     pending: !!st.pending,
     drafts: draftChanges(st).length > 0,
-    hasDevices: (st.devices?.issued || []).length > 0,
+    // Las filas salen del ACTA (miembros con o sin certificado), así que la ayuda mira
+    // la lista fundida: un miembro sin papel también se renombra, bloquea o quita.
+    hasDevices: devs.length > 0,
     isService: !!cur?.cn,
+    curBlocked: !!blockedOf(st, cur?.sub),
     hasSecrets: Object.keys(st.secrets?.ns || {}).length > 0,
     hasVars: devVarsOf(st, st.varsFor?.pub).length > 0,
     hasLogins: (st.logins || []).length > 0,
@@ -2528,6 +2553,7 @@ export async function runTui () {
     scroll: {},
     profiles: null,
     devices: null,
+    blocked: [],
     secrets: null,
     // Los inicios de sesión se piden al ENTRAR en su pestaña, no al arrancar.
     logins: null,

package/src/tui/i18n.js

@@ -280,6 +280,14 @@ const es = {
   revokeConfirm: (id) => `¿Quitar ${id} del perfil? Pierde el acceso ahora mismo. Lo que tenga guardado se le borra cuando se conecte: si está apagado, sigue ahí hasta entonces.`,
   revoking: 'Revocando…',
   deviceRevoked: (id) => `Revocado ${id}`,
+  // BLOQUEAR sin quitar: sigue en la cuenta, pero nadie le atiende hasta desbloquearlo.
+  deviceBlocked: 'BLOQUEADO',
+  blocking: 'Bloqueando…',
+  unblocking: 'Desbloqueando…',
+  deviceBlockedMsg: (id) => `Bloqueado ${id}: la bóveda y tus máquinas no le atienden hasta que lo desbloquees (b)`,
+  deviceUnblockedMsg: (id) => `Desbloqueado ${id}`,
+  deviceNotBlocked: (id) => `${id} no estaba bloqueado`,
+  cantBlockMaster: 'La bóveda no se bloquea a sí misma.',
   approveLabel: (id) => `Código que MUESTRA el dispositivo ${id}`,
   approveHint: 'el vault no lo conoce: compáralo en la otra pantalla',
   codeMissing: 'Falta el código',
@@ -411,13 +419,13 @@ const es = {
   // Anunciar teclas muertas confunde y además las quema para otros usos.
   // `e variables` solo en un SERVICIO: es el único que las lee, así que en un teléfono
   // era una tecla que solo sabía decir que no.
-  helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
+  helpDevices: ({ pending, hasDevices, isService, drafts, curBlocked } = {}) => [
     '←→ pestaña', '↑↓', 'p emparejar',
     ...(drafts ? ['g guardar permisos'] : []),
     ...(pending ? ['a aprobar', 'x rechazar'] : []),
     ...(hasDevices ? ['r renombrar', 'c permisos'] : []),
     ...(isService ? ['e variables'] : []),
-    ...(hasDevices ? ['v revocar'] : []),
+    ...(hasDevices ? [curBlocked ? 'b desbloquear' : 'b bloquear', 'v revocar'] : []),
     'F5 refrescar', 'Esc bóvedas', 'l English', 'q salir'
   ],
   renameDeviceLabel: (id) => `¿Cómo quieres llamar a ${id}?`,
@@ -718,6 +726,13 @@ const en = {
   revokeConfirm: (id) => `Remove ${id} from the profile? It loses access right away. What it has stored is erased when it connects: if it is switched off, it stays there until then.`,
   revoking: 'Revoking…',
   deviceRevoked: (id) => `Revoked ${id}`,
+  deviceBlocked: 'BLOCKED',
+  blocking: 'Blocking…',
+  unblocking: 'Unblocking…',
+  deviceBlockedMsg: (id) => `Blocked ${id}: the vault and your machines ignore it until you unblock it (b)`,
+  deviceUnblockedMsg: (id) => `Unblocked ${id}`,
+  deviceNotBlocked: (id) => `${id} was not blocked`,
+  cantBlockMaster: 'The vault does not block itself.',
   approveLabel: (id) => `Code SHOWN by device ${id}`,
   approveHint: 'the vault does not know it: compare it on the other screen',
   codeMissing: 'The code is missing',
@@ -827,13 +842,13 @@ const en = {
   helpConfirm: 'y confirm · n/Esc cancel',
 
   helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'y keys', 'u unlock', 'k lock', 'l Español', 'q quit'],
-  helpDevices: ({ pending, hasDevices, isService, drafts } = {}) => [
+  helpDevices: ({ pending, hasDevices, isService, drafts, curBlocked } = {}) => [
     '←→ tab', '↑↓', 'p pair',
     ...(drafts ? ['g save permissions'] : []),
     ...(pending ? ['a approve', 'x reject'] : []),
     ...(hasDevices ? ['r rename', 'c permissions'] : []),
     ...(isService ? ['e variables'] : []),
-    ...(hasDevices ? ['v revoke'] : []),
+    ...(hasDevices ? [curBlocked ? 'b unblock' : 'b block', 'v revoke'] : []),
     'F5 refresh', 'Esc vaults', 'l Español', 'q quit'
   ],
   renameDeviceLabel: (id) => `What do you want to call ${id}?`,

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,

package/src/vaultControl.js

@@ -44,6 +44,9 @@ const F = {
   approveReq: 'approve-request.json',
   rejectReq: 'reject-request.json',
   revokeReq: 'revoke-request.json',
+  // BLOQUEAR / DESBLOQUEAR un aparato (sin tocar el acta). Mismo par que usa la CLI.
+  blockReq: 'block-request.json',
+  blockRes: 'block.json',
   labelReq: 'label-request.json',
   capsReq: 'caps-request.json',
   capsRes: 'caps.json',
@@ -394,6 +397,8 @@ export async function listDevices (profile) {
     issued: groupCertsByDevice(withIds, revoked),
     revoked,
     members: record?.members || [],
+    // LOS BLOQUEADOS viajan con el acta: quien pinte la lista los marca en su fila.
+    blocked: Array.isArray(record?.blocked) ? record.blocked : [],
     profile: devices.profile || null
   }
 }
@@ -502,6 +507,25 @@ export async function revokeDevice (target, profile) {
   return listDevices(profile)
 }
 
+/**
+ * BLOQUEA o DESBLOQUEA un aparato por su llave `pub`. No toca el acta: sigue siendo
+ * miembro, pero la bóveda y los agentes dejan de atenderle (dueño, 2026-10-07). Funciona
+ * con el perfil cerrado, igual que `dotrino-vault block|unblock`. Devuelve `{ on, was }`:
+ * `was` dice si al desbloquear había algo que quitar.
+ */
+export async function setDeviceBlocked (pub, on, profile) {
+  requireAlive()
+  if (typeof pub !== 'string' || !pub) throw coded('a device key is required', 'BAD_PUB')
+  rm(F.blockRes)
+  const since = Date.now()
+  const id = await writeReq(F.blockReq, { pub, on: !!on }, profile)
+  signalOrCleanup('SIGUSR2', [F.blockReq])
+  const r = await waitFor(F.blockRes, { req: id, since, tries: 40 })
+  if (!r) throw coded('the daemon did not reply', 'NO_REPLY')
+  if (r.ok === false) throw coded(r.error || `could not ${on ? 'block' : 'unblock'} the device`, r.code || 'BLOCK_FAILED')
+  return { on: !!on, was: !!r.was }
+}
+
 // ---------------------------------------------------------------------------
 // Perfil del usuario (lo que sincronizan los dispositivos)
 // ---------------------------------------------------------------------------