@dotrino/vaultd 0.113.0 → 0.115.0

package/README.md

@@ -778,10 +778,31 @@ dotrino-env run --ns claude -- node mi-script.js     # el proceso espera el sí
 ```
 
 …la bóveda apunta el pedido, avisa al teléfono (cola del proxio → aviso nativo en la app de
-Dotrino), y solo su firma entrega las claves — **al proceso que pidió, en memoria**. Pide en
-**cada petición**, que para un servicio bien hecho es **una por arranque**: pide al iniciar,
-se queda las claves en memoria y no vuelve a pedir. Lo denegado corta sin reintentos; lo que
-nadie atiende vence a los 5 min; todo queda en `dotrino-vault activity`.
+Dotrino), y solo su firma entrega las claves — **al proceso que pidió, en memoria**. Lo
+denegado corta sin reintentos; lo que nadie atiende vence a los 5 min; todo queda en
+`dotrino-vault activity`.
+
+**El pedido dice QUÉ COMANDO pide y DESDE QUÉ CARPETA** (2026-09-11). «El aparato 904C-1002
+pide el cajón claude» no alcanza para decidir: no distingue el arranque que acabas de lanzar
+de cualquier otra cosa de esa máquina. Dos cosas que conviene tener claras:
+
+- **Se mide, no se cree.** Si quien pide corre en la misma máquina que la bóveda, ella lee el
+  comando, la carpeta y el binario del propio proceso (`/proc/<pid>`) y los compara con lo
+  que dijo; si no cuadra, deniega (`ctx-mismatch`). Desde otra máquina no hay nada que leer y
+  la pantalla lo marca como *sin comprobar*. Y el dato **no autoriza nada**: cualquier proceso
+  del mismo usuario puede leer el `service-identity.json` y pedir con esa llave. La frontera
+  es el usuario, no el proceso; esto es para decidir mirando y para dejar rastro.
+- **Va cifrado hasta el teléfono.** El comando y la carpeta son del dueño y el camino es el
+  proxio, que no cifra (CONVENCIONES §4.1): viajan sellados a la llave de cifrado del aparato
+  que aprueba. Por eso `dotrino-env` **solo lo manda por el mostrador local** — mandarlo por
+  el proxio enseñaría las rutas del disco a quien lo opere.
+
+**Aprobar vale una hora, y se renueva con cada uso.** Ese mismo comando desde esa misma
+carpeta entra sin volver a timbrar; cada petición vuelve a poner el reloj en una hora, así
+que un servicio que sigue pidiendo la mantiene viva. Cambia un argumento o la carpeta y es
+otro comando: pregunta otra vez. Las concesiones vivas se ven y se quitan en
+`vault.dotrino.com/approvals`, viven **en memoria** (reiniciar la bóveda las borra) y un
+pedido que no dijo qué ejecutaba no deja ninguna.
 
 ### La llave SSH como un secreto más (`dotrino-env ssh-agent`)
 

package/lib/src/proc.js

@@ -0,0 +1,192 @@
+/**
+ * proc.js — QUIÉN ESTÁ PIDIENDO LOS SECRETOS: qué comando, desde qué carpeta.
+ *
+ * Hasta ahora un pedido de aprobación decía «el aparato 904C-1002 pide el cajón proxy» y
+ * nada más. Con eso no se puede decidir: el dueño no sabe si es el arranque que acaba de
+ * lanzar o cualquier otra cosa de la misma máquina. Lo que hace falta es el **comando** y
+ * el **path** (dueño, 2026-09-11).
+ *
+ * DOS FUENTES, Y NO VALEN LO MISMO:
+ *
+ *   · `selfContext()` — lo que un proceso dice de sí mismo. Es lo que viaja en el pedido.
+ *   · `readProcContext(pid)` — lo que el KERNEL dice de ese pid, leyendo `/proc`. Solo la
+ *     puede usar quien está en la misma máquina, y es la que manda.
+ *
+ * Cuando el pedido entra por el mostrador local, la bóveda lee la segunda y la compara con
+ * la primera: si no cuadran, no es un matiz, es una mentira, y se deniega. Cuando entra por
+ * el proxio (un servicio en otra máquina) no hay nada que leer, y entonces lo declarado se
+ * marca como declarado — que es distinto de comprobado, y se enseña distinto.
+ *
+ * EL LÍMITE, DICHO EN VOZ ALTA: esto no es una credencial. Cualquier proceso del MISMO
+ * usuario puede leer `service-identity.json` y pedir los secretos con esa llave, y también
+ * puede llamarse como quiera (`exec -a`) y arrancar desde donde quiera. La frontera de
+ * verdad es el usuario, no el proceso. Esto existe para que quien aprueba decida con lo que
+ * está pasando delante, y para que quede rastro — no para parar a quien ya tiene la llave.
+ *
+ * En `dotrino-env run -- node server.js` el comando de destino ya va DENTRO de la línea de
+ * comandos del propio `dotrino-env`, así que se mide igual que todo lo demás: no hay que
+ * creerle nada aparte.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import crypto from 'node:crypto'
+
+/** Topes. Un `argv` puede ser enorme y esto viaja en cada pedido y se pinta en un teléfono. */
+export const MAX_ARGV_BYTES = 4096
+export const MAX_PATH_BYTES = 1024
+/** Cuántos argumentos como mucho: más que esto no lo lee nadie. */
+export const MAX_ARGV_ITEMS = 64
+
+const clip = (s, max) => {
+  if (typeof s !== 'string') return ''
+  return Buffer.byteLength(s) <= max ? s : Buffer.from(s).subarray(0, max).toString('utf8')
+}
+
+/** ¿Hay `/proc`? Es lo que separa poder medir de tener que creer. */
+export const hasProc = () => { try { return fs.statSync('/proc/self').isDirectory() } catch (_) { return false } }
+
+/** `/proc/<pid>/cmdline` viene separado por NUL y termina en NUL. */
+function readCmdline (pid) {
+  const raw = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8')
+  const parts = raw.split('\0')
+  if (parts.length && parts[parts.length - 1] === '') parts.pop()
+  return parts
+}
+
+/**
+ * Recorta el `argv` a lo que se puede enseñar y transportar. Devuelve también si sobró
+ * algo: un comando cortado que no dice que está cortado se lee como otro comando.
+ */
+function trimArgv (argv) {
+  const list = (Array.isArray(argv) ? argv : []).map((a) => String(a))
+  let cut = list.length > MAX_ARGV_ITEMS
+  const kept = list.slice(0, MAX_ARGV_ITEMS)
+  let total = 0
+  const out = []
+  for (const a of kept) {
+    const b = Buffer.byteLength(a)
+    if (total + b > MAX_ARGV_BYTES) { cut = true; break }
+    total += b
+    out.push(a)
+  }
+  return { argv: out, truncated: cut }
+}
+
+/**
+ * LA HORA DE ARRANQUE del proceso (campo 22 de `/proc/<pid>/stat`, en ticks). Sirve para
+ * saber que el pid no se recicló entre que pidió y que se miró: el nombre del proceso va
+ * entre paréntesis y puede llevar espacios, así que se corta por el ÚLTIMO `)`.
+ */
+function readStart (pid) {
+  try {
+    const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8')
+    const campos = stat.slice(stat.lastIndexOf(')') + 2).split(' ')
+    const t = Number(campos[19])
+    return Number.isFinite(t) ? t : null
+  } catch (_) { return null }
+}
+
+/**
+ * Lo que el KERNEL dice del proceso `pid`. `null` si no hay `/proc`, si el proceso ya no
+ * está o si no se puede mirar (otro usuario). No se inventa nada: no poder medir se
+ * contesta como no poder medir.
+ */
+export function readProcContext (pid) {
+  if (!hasProc() || !Number.isInteger(pid) || pid <= 0) return null
+  try {
+    const st = fs.statSync(`/proc/${pid}`)
+    const { argv, truncated } = trimArgv(readCmdline(pid))
+    return {
+      pid,
+      uid: st.uid,
+      exe: clip(fs.readlinkSync(`/proc/${pid}/exe`), MAX_PATH_BYTES),
+      cwd: clip(fs.readlinkSync(`/proc/${pid}/cwd`), MAX_PATH_BYTES),
+      argv,
+      truncated,
+      start: readStart(pid)
+    }
+  } catch (_) { return null }
+}
+
+/**
+ * Lo que ESTE proceso dice de sí mismo. En Linux sale de `/proc/self`, o sea de la misma
+ * fuente que va a leer la bóveda: así lo declarado y lo medido coinciden byte a byte y una
+ * diferencia significa lo que tiene que significar. Fuera de Linux se arma con lo que da
+ * Node, y entonces no hay nada que comprobar al otro lado.
+ */
+export function selfContext () {
+  const medido = readProcContext(process.pid)
+  if (medido) return { ...medido, user: userName(), host: os.hostname() }
+  const { argv, truncated } = trimArgv([process.execPath, ...process.argv.slice(1)])
+  return {
+    pid: process.pid,
+    uid: typeof process.getuid === 'function' ? process.getuid() : null,
+    exe: clip(process.execPath, MAX_PATH_BYTES),
+    cwd: clip(safeCwd(), MAX_PATH_BYTES),
+    argv,
+    truncated,
+    start: null,
+    user: userName(),
+    host: os.hostname()
+  }
+}
+
+const safeCwd = () => { try { return process.cwd() } catch (_) { return '' } }
+const userName = () => { try { return os.userInfo().username } catch (_) { return '' } }
+
+/**
+ * LO QUE LLEGA POR LA RED NO SE CREE NI EN LA FORMA. Este dato lo manda otro proceso, se
+ * guarda en memoria y se pinta en un teléfono: se recorta a lo que cabe y se tira lo que no
+ * tiene el tipo que debería. Devuelve `null` si no queda nada que enseñar — que no es lo
+ * mismo que un contexto vacío, y por eso no se devuelve un objeto a medias.
+ */
+export function sanitizeContext (raw) {
+  if (!raw || typeof raw !== 'object') return null
+  const argvRaw = Array.isArray(raw.argv) ? raw.argv.filter((a) => typeof a === 'string') : []
+  const { argv, truncated } = trimArgv(argvRaw)
+  const exe = clip(typeof raw.exe === 'string' ? raw.exe : '', MAX_PATH_BYTES)
+  const cwd = clip(typeof raw.cwd === 'string' ? raw.cwd : '', MAX_PATH_BYTES)
+  if (!exe && !argv.length) return null
+  return {
+    pid: Number.isInteger(raw.pid) && raw.pid > 0 ? raw.pid : null,
+    uid: Number.isInteger(raw.uid) ? raw.uid : null,
+    exe,
+    cwd,
+    argv,
+    truncated: truncated || raw.truncated === true,
+    start: Number.isFinite(raw.start) ? raw.start : null,
+    user: clip(typeof raw.user === 'string' ? raw.user : '', 64),
+    host: clip(typeof raw.host === 'string' ? raw.host : '', 64)
+  }
+}
+
+/**
+ * LA HUELLA DEL COMANDO: qué binario, desde qué carpeta y con qué argumentos. Es la llave
+ * de la concesión por tiempo — aprobar `node server.js` en `/srv/app` no aprueba otra cosa
+ * ni la misma cosa en otro sitio.
+ *
+ * El pid NO entra: cambia en cada arranque y la gracia es justamente que el mismo comando
+ * se reconozca la próxima vez.
+ */
+export function commandFingerprint (ctx) {
+  if (!ctx || typeof ctx !== 'object') return null
+  const argv = Array.isArray(ctx.argv) ? ctx.argv : []
+  if (!ctx.exe && !argv.length) return null
+  const material = [ctx.exe || '', ctx.cwd || '', ...argv].join('\0')
+  return crypto.createHash('sha256').update(material).digest('hex')
+}
+
+/** ¿Son el mismo comando? Mismo binario, misma carpeta, mismos argumentos. */
+export const sameCommand = (a, b) => {
+  const fa = commandFingerprint(a)
+  return !!fa && fa === commandFingerprint(b)
+}
+
+/** El comando en una línea, para un log o una pantalla estrecha. */
+export function commandLine (ctx, max = 160) {
+  const argv = Array.isArray(ctx?.argv) ? ctx.argv : []
+  const linea = argv.length ? argv.join(' ') : (ctx?.exe || '')
+  return linea.length > max ? linea.slice(0, max - 1) + '…' : linea
+}
+
+export default { selfContext, readProcContext, sanitizeContext, commandFingerprint, sameCommand, commandLine, hasProc }

package/lib/src/service.js

@@ -32,6 +32,7 @@ import { makeEphemeralKey, openSealed } from './sealed.js'
 import { parseInvite } from './invite.js'
 import { atRestFor } from './atrest.js'
 import { connectLocal, hasLocalVault } from './localdesk.js'
+import { selfContext } from './proc.js'
 
 const IDENTITY_FILE = 'service-identity.json'
 const FRESH_WINDOW_MS = 5 * 60 * 1000
@@ -611,9 +612,24 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     }
 
     const eph = await makeEphemeralKey()
+    /**
+     * QUÉ COMANDO Y DESDE QUÉ CARPETA — pero SOLO por el mostrador local.
+     *
+     * Quien aprueba necesita saber qué está pidiendo las claves: «el aparato 904C-1002 pide
+     * el cajón proxy» no alcanza para decidir nada (dueño, 2026-09-11). Así que el pedido
+     * lleva el comando y el path, y la bóveda los comprueba contra `/proc`.
+     *
+     * POR EL PROXIO NO VA, y no es un olvido: el pedido de secretos viaja firmado pero EN
+     * CLARO (CONVENCIONES §4.1 — el transporte no cifra), así que meter ahí el `argv` y el
+     * `cwd` le enseñaría al proxio las rutas de tu disco y los argumentos de tus comandos,
+     * que es justo lo que este ecosistema promete que no pasa. Sin contexto no hay huella,
+     * y sin huella no hay ventana: un servicio que pide desde otra máquina sigue pidiendo
+     * aprobación cada vez. Se abrirá cuando el pedido vaya sellado (la deuda del §4.1).
+     */
+    const ctx = client.local ? selfContext() : null
     // `publicOnly` VIAJA FIRMADO (va dentro de `data`), así que nadie lo puede quitar ni
     // poner por el camino. Quien decide qué se manda es la bóveda; esto solo es la petición.
-    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, ...(publicOnly ? { publicOnly: true } : {}) }
+    const data = { op: 'secrets', ns, ek: eph.ek, publickey: device.publickey, ts: Date.now(), v: MY_VERSION, ...(ctx ? { ctx } : {}), ...(publicOnly ? { publicOnly: true } : {}) }
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     // A QUIÉN SE LE PREGUNTA: primero a la bóveda, y si no contesta, a los REPLICADORES
     // que el acta nombraba la última vez que la vimos (`docs/replicas.md` §8: «el servicio

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.113.0",
+  "version": "0.115.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": {
@@ -26,6 +26,7 @@
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.18.2",
     "@dotrino/roadmap": "0.2.0",
+    "@dotrino/store": "0.11.0",
     "ws": "^8.18.0"
   },
   "license": "MIT",

package/src/approvals.js

@@ -1,23 +1,59 @@
 /**
- * PEDIDOS DE APROBACIÓN (puro: sin red ni disco).
+ * PEDIDOS DE APROBACIÓN Y CONCESIONES (puro: sin red ni disco).
  *
  * Un aparato marcado con `approval on` no recibe claves privadas solo por tener el cert: el
  * vault apunta el pedido, avisa a los aparatos con `approve` (el teléfono), y solo su firma
- * libera los secretos. No hay ventana: cada petición es un pedido, y para un servicio bien
- * hecho eso es UNA por arranque (pide al iniciar, se queda las claves en memoria). Lo que
- * nadie aprueba vence solo a los 5 min.
+ * libera los secretos. Lo que nadie aprueba vence solo a los 5 min.
  *
- * Lo que se guarda de cada pedido es lo justo para contestar después: el cajón, quién pide
- * y su llave efímera `ek` (a la que se sella la respuesta). Nunca un valor.
+ * Lo que se guarda de cada pedido es lo justo para contestar después: el cajón, quién pide,
+ * su llave efímera `ek` (a la que se sella la respuesta) y **qué comando está corriendo y
+ * desde dónde**. Nunca un valor.
+ *
+ * LA CONCESIÓN POR COMANDO (dueño, 2026-09-11). Antes no había ventana: cada petición era un
+ * pedido, y para un servicio bien hecho eso era una por arranque. Dejó de alcanzar en cuanto
+ * los pedidos empezaron a decir QUÉ comando piden: si el dueño ya dijo que sí a ese comando
+ * exacto desde esa carpeta exacta, volver a timbrarle por lo mismo es ruido. Así que aprobar
+ * concede **una hora, contada desde el último uso** — o sea que un servicio que sigue
+ * pidiendo la mantiene viva indefinidamente, que es lo que se pidió. Lo que la corta: que
+ * cambie el comando o la carpeta (otra huella, otro pedido), una hora entera sin usarla,
+ * revocarla a mano, o reiniciar la bóveda (viven en memoria y no se escriben en ningún
+ * sitio: un permiso que sobrevive a un reinicio es un permiso que nadie recuerda haber dado).
+ *
+ * SIN COMANDO NO HAY CONCESIÓN. Un pedido que no dice qué está corriendo —porque vino de
+ * otra máquina por el proxio, donde mandarlo en claro filtraría las rutas del dueño— no
+ * tiene huella con la que emparejarse, y entonces se pide aprobación cada vez. No se
+ * inventa una huella «vacía» que valdría para todo: eso sería exactamente un repliegue.
+ *
+ * Y PARA EL GESTOR DE CONTRASEÑAS ESO ES LO QUE SE QUIERE, no una carencia que arreglar
+ * (dueño, 2026-09-11: «para el gestor de contraseñas es perfecto»). La extensión es un
+ * navegador hablando por el proxio, no un proceso con línea de comandos, así que nunca va a
+ * traer huella — y así cada acceso a una credencial vuelve a pasar por tu mano, que es la
+ * protección por la que esto existe. No se le busque un sustituto del comando para que
+ * entre en la ventana.
  */
+import { commandFingerprint } from '../lib/src/proc.js'
+
 const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join('')
 
+/** Separador de la llave compuesta. Es un byte que no puede aparecer en un cajón ni en una pubkey. */
+const SEP = String.fromCharCode(0)
+
 export const PENDING_TTL_MS = 5 * 60 * 1000
+/** Lo que dura una concesión SIN USARSE. Cada uso la vuelve a poner en una hora. */
+export const GRANT_TTL_MS = 60 * 60 * 1000
 
 export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS } = {}) {
-  /** id → { id, ns, device, deviceId, label, ek, ts, exp } */
+  /** id → { id, ns, device, deviceId, label, ek, ctx, ts, exp, from } */
   const pending = new Map()
-  const publicOf = (p) => ({ id: p.id, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp })
+  /**
+   * EL CONTEXTO VA EN LA LISTA, Y QUIEN LA SACA POR LA RED LO ENVUELVE.
+   *
+   * `ctx` es el comando y el path del dueño: por el mostrador local y en la consola de su
+   * propia máquina se enseña tal cual, pero al teléfono viaja por el proxio y ahí va dentro
+   * de un sobre (`handleApproval`). Si mañana aparece otro sitio que publique esta lista,
+   * esto es lo que hay que recordar.
+   */
+  const publicOf = (p) => ({ id: p.id, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ctx: p.ctx || null })
 
   return {
     /** Apunta un pedido. Uno por cajón y aparato: pedir otra vez reemplaza al anterior. */
@@ -26,10 +62,10 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
      * apruebe— y tiene que volver por el mismo sitio: desde que la bóveda atiende también
      * por un socket local, mandarla siempre por el proxio la dejaba en el vacío.
      */
-    request ({ ns, device, deviceId, label = '', ek, from = null }) {
+    request ({ ns, device, deviceId, label = '', ek, ctx = null, from = null }) {
       for (const [id, p] of pending) if (p.ns === ns && p.device === device) pending.delete(id)
       const ts = now()
-      const p = { id: rnd(), ns, device, deviceId, label, ek, ts, exp: ts + pendingTtlMs, from }
+      const p = { id: rnd(), ns, device, deviceId, label, ek, ctx, ts, exp: ts + pendingTtlMs, from }
       pending.set(p.id, p)
       return publicOf(p)
     },
@@ -51,4 +87,75 @@ export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS
   }
 }
 
-export default { createApprovals, PENDING_TTL_MS }
+/**
+ * LAS CONCESIONES VIVAS: «este comando, desde esta carpeta, ya está aprobado».
+ *
+ * La llave es cajón + aparato + huella del comando. Nada de esto se escribe en disco.
+ */
+export function createGrants ({ now = Date.now, ttlMs = GRANT_TTL_MS } = {}) {
+  /** key → { id, ns, device, deviceId, fp, ctx, by, grantedAt, lastAt, exp, uses } */
+  const grants = new Map()
+  const keyOf = (ns, device, fp) => ns + SEP + device + SEP + fp
+  const publicOf = (g) => ({
+    id: g.id, ns: g.ns, deviceId: g.deviceId, fp: g.fp, ctx: g.ctx,
+    by: g.by, grantedAt: g.grantedAt, lastAt: g.lastAt, exp: g.exp, uses: g.uses
+  })
+
+  const api = {
+    /**
+     * Anota que este comando quedó aprobado. Devuelve la concesión, o `null` si el pedido no
+     * traía comando: sin huella no hay nada que recordar, y el próximo pedido volverá a
+     * timbrar. Que eso se diga en el log es cosa de quien llama.
+     */
+    grant ({ ns, device, deviceId = null, ctx = null, by = null }) {
+      const fp = commandFingerprint(ctx)
+      if (!fp) return null
+      const t = now()
+      const g = { id: rnd(), ns, device, deviceId, fp, ctx, by, grantedAt: t, lastAt: t, exp: t + ttlMs, uses: 0 }
+      grants.set(keyOf(ns, device, fp), g)
+      return publicOf(g)
+    },
+    /**
+     * ¿Está este comando ya aprobado? Si lo está, **la concesión se estira**: la hora cuenta
+     * desde el último uso, no desde que se dio. Devuelve la concesión (ya refrescada) o `null`.
+     */
+    allows ({ ns, device, ctx }) {
+      api.sweep()
+      const fp = commandFingerprint(ctx)
+      if (!fp) return null
+      const g = grants.get(keyOf(ns, device, fp))
+      if (!g) return null
+      const t = now()
+      g.lastAt = t
+      g.exp = t + ttlMs
+      g.uses += 1
+      return publicOf(g)
+    },
+    /** Las concesiones vivas. */
+    list () { api.sweep(); return [...grants.values()].map(publicOf) },
+    /** Corta una por su id. `true` si existía. */
+    revoke (id) {
+      for (const [k, g] of grants) if (g.id === id) { grants.delete(k); return true }
+      return false
+    },
+    /** Corta todas, o las de un cajón / un aparato. Devuelve cuántas se fueron. */
+    revokeAll ({ ns = null, device = null } = {}) {
+      let n = 0
+      for (const [k, g] of grants) {
+        if (ns && g.ns !== ns) continue
+        if (device && g.device !== device) continue
+        grants.delete(k); n++
+      }
+      return n
+    },
+    /** Tira lo vencido; devuelve lo que se fue, para anotarlo. */
+    sweep () {
+      const t = now(); const gone = []
+      for (const [k, g] of grants) if (g.exp <= t) { grants.delete(k); gone.push(publicOf(g)) }
+      return gone
+    }
+  }
+  return api
+}
+
+export default { createApprovals, createGrants, PENDING_TTL_MS, GRANT_TTL_MS }

package/src/threadStore.js

@@ -14,10 +14,14 @@
  * que el ecosistema promete que no queda en claro en ningún disco.
  */
 import path from 'node:path'
+import * as core from '@dotrino/store/core'
 import { readJson, writeJson } from './paths.js'
 import { atRestFor } from './atrest.js'
 
-const MAX_PER_THREAD = 1000
+// El MISMO tope que acepta la página del almacén. Era 1000: una app que guarda más en un
+// hilo (los compradores de facturero, por ejemplo) perdía aquí lo más viejo sin decir nada,
+// y el navegador lo volvía a subir en cada sincronización.
+const MAX_PER_THREAD = core.MAX_PER_THREAD_LIMIT
 
 // DATOS SENSIBLES (F4): topes para que un dispositivo con `vault:store` no pueda
 // llenar el disco de la bóveda. Son generosos para el uso real (unas contraseñas,
@@ -33,24 +37,31 @@ export function openThreadStore (dir) {
   if (!data.threads) data.threads = {}
   if (!data.opens) data.opens = {}
   if (!data.secure) data.secure = {}
+  // Lápidas de lo borrado (`@dotrino/store/core`): sin ellas un borrado vuelve desde el
+  // primer aparato que todavía tenga la entrada.
+  if (!data.tombs) data.tombs = {}
+  core.pruneTombs(data.tombs, Date.now())
   const save = () => writeJson(file, data, atRest)
   save() // reescribe al abrir: cifra lo que venía en claro
-  const trim = (arr) => { if (arr.length > MAX_PER_THREAD) arr.splice(0, arr.length - MAX_PER_THREAD) }
+  const budget = (n) => Math.min(Math.max(Number(n) || core.PAGE_BYTES, 1024), core.PAGE_BYTES)
+  const needKeys = (keys) => {
+    if (!Array.isArray(keys) || !keys.every((k) => typeof k === 'string')) throw new Error('keys must be a list of thread keys')
+    return keys
+  }
+  const needMap = (value, what) => {
+    if (value == null) return {}
+    if (typeof value !== 'object' || Array.isArray(value)) throw new Error(`${what} must be an object`)
+    return value
+  }
 
   const methods = {
     appendMessage ({ threadKey, entry }) {
-      if (!threadKey || typeof threadKey !== 'string') throw new Error('threadKey required')
-      if (!entry || typeof entry !== 'object') throw new Error('entry required')
-      if (!entry.id) entry.id = crypto.randomUUID()
-      if (!entry.ts) entry.ts = Date.now()
-      const arr = data.threads[threadKey] || (data.threads[threadKey] = [])
-      const i = arr.findIndex((e) => e.id === entry.id)
-      if (i >= 0) arr[i] = { ...arr[i], ...entry }; else arr.push(entry)
-      trim(arr); save(); return entry
+      core.writeEntry(data.threads, data.tombs, threadKey, entry, { max: MAX_PER_THREAD, now: Date.now(), newId: () => crypto.randomUUID() })
+      save(); return entry
     },
     listThread ({ threadKey, limit, before }) {
-      if (!threadKey) return []
-      let arr = data.threads[threadKey] || []
+      if (!core.validKey(threadKey) || !Object.hasOwn(data.threads, threadKey)) return []
+      let arr = data.threads[threadKey]
       if (typeof before === 'number') arr = arr.filter((e) => (e.ts || 0) < before)
       if (typeof limit === 'number' && limit > 0) arr = arr.slice(-limit)
       return arr
@@ -62,14 +73,14 @@ export function openThreadStore (dir) {
       return out
     },
     removeThread ({ threadKey }) {
-      const removed = data.threads[threadKey]?.length || 0
-      delete data.threads[threadKey]; save(); return { removed }
+      const removed = core.removeWholeThread(data.threads, data.tombs, threadKey, Date.now())
+      if (removed) save()
+      return { removed }
     },
     removeMessage ({ threadKey, id }) {
-      const arr = data.threads[threadKey] || []; const before = arr.length
-      data.threads[threadKey] = arr.filter((e) => e.id !== id)
-      if (data.threads[threadKey].length === 0) delete data.threads[threadKey]
-      save(); return { removed: before - (data.threads[threadKey]?.length || 0) }
+      const removed = core.removeEntry(data.threads, data.tombs, threadKey, id, Date.now())
+      if (removed) save()
+      return { removed }
     },
     recordOpen ({ appId }) {
       if (!appId || typeof appId !== 'string') throw new Error('appId required')
@@ -79,17 +90,38 @@ export function openThreadStore (dir) {
     },
     getOpens () { return { ...data.opens } },
     clearOpens () { data.opens = {}; save(); return { ok: true } },
+    /** Mezcla el contador de un aparato (el mayor de cada lado) y devuelve el resultado. */
+    mergeOpens ({ opens }) {
+      if (core.mergeOpens(data.opens, needMap(opens, 'opens'))) save()
+      return { ...data.opens }
+    },
     exportThreads () { return { threads: data.threads } },
-    importThreads ({ threads, mode = 'merge' }) {
+    // ----- SINCRONIZAR POR PARTES (@dotrino/store ≥ 0.11) -----
+    // `exportThreads`/`importThreads` a secas mueven TODO en un mensaje, y el proxio corta
+    // los frames en 1 MB: con unos cientos de KB de datos la sincronización dejaba de caber.
+    // Con esto el aparato pregunta qué hilos difieren (una huella por hilo), baja su índice
+    // (id y ts) y pide solo las entradas que le faltan, todo por páginas con tope de bytes.
+    // Las reglas —huella, mezcla, lápidas— son las de `@dotrino/store/core`, las mismas que
+    // aplica el navegador: si cada lado llevara las suyas, las huellas no coincidirían nunca.
+    getThreadDigests ({ keys } = {}) {
+      return core.digestsOf(data.threads, keys == null ? undefined : needKeys(keys))
+    },
+    getThreadIndexes ({ keys, cursor, maxBytes }) {
+      return core.indexPage(data.threads, data.tombs, needKeys(keys), cursor || null, budget(maxBytes))
+    },
+    getEntries ({ refs, maxBytes }) {
+      return core.entriesPage(data.threads, needMap(refs, 'refs'), budget(maxBytes))
+    },
+    importThreads ({ threads, tombs, mode = 'merge' }) {
       if (!threads || typeof threads !== 'object') throw new Error('threads required')
       if (mode === 'replace') { data.threads = threads; save(); return { mode, count: Object.keys(threads).length } }
-      for (const [k, arr] of Object.entries(threads)) {
-        const cur = data.threads[k] || (data.threads[k] = [])
-        const byId = new Map(cur.map((e) => [e.id, e]))
-        for (const e of arr) { if (!e?.id) continue; const pr = byId.get(e.id); if (!pr || (e.ts || 0) > (pr.ts || 0)) byId.set(e.id, e) }
-        data.threads[k] = Array.from(byId.values()).sort((a, b) => (a.ts || 0) - (b.ts || 0)); trim(data.threads[k])
-      }
-      save(); return { mode, count: Object.keys(data.threads).length }
+      if (mode !== 'merge' && mode !== 'upsert') throw new Error(`unknown import mode: ${mode}`)
+      const now = Date.now()
+      const buried = core.applyTombs(data.threads, data.tombs, needMap(tombs, 'tombs'), now)
+      const merged = core.mergeEntries(data.threads, data.tombs, threads, { mode, max: MAX_PER_THREAD })
+      core.pruneTombs(data.tombs, now)
+      if (buried.tombsChanged || buried.changed.size || merged.size) save()
+      return { mode, count: Object.keys(data.threads).length, changed: [...new Set([...buried.changed, ...merged])] }
     },
     // ----- PERFIL del usuario (me): el vault es la copia AUTORITATIVA -----
     // Cada dispositivo emparejado lo empuja al editarlo y lo jala al arrancar →
@@ -182,7 +214,8 @@ export function openThreadStore (dir) {
  * dispositivo al que solo le diste «leer» no lee tus contraseñas.
  */
 export const STORE_READ_METHODS = new Set([
-  'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet'
+  'listThread', 'listThreadKeys', 'getThreadSummaries', 'getOpens', 'exportThreads', 'getStats', 'profileGet',
+  'getThreadDigests', 'getThreadIndexes', 'getEntries'
 ])
 
 /**

package/src/vault.js

@@ -36,7 +36,9 @@ import { loadManifest, brokenOf } from '@dotrino/roadmap'
 // espera reventaba con un ReferenceError y la aprobación del mostrador de contraseñas no
 // llegaba a existir. Solo se veía por ese camino —el único que lo usa—, y no había prueba
 // que lo recorriera hasta que la hubo (dotrino-test, smoke:demonio, 2026-08-30).
-import { createApprovals, PENDING_TTL_MS } from './approvals.js'
+import { createApprovals, createGrants, PENDING_TTL_MS, GRANT_TTL_MS } from './approvals.js'
+import { readProcContext, sanitizeContext, commandFingerprint, commandLine } from '../lib/src/proc.js'
+import { makeContentKey, encryptWithCek, wrapForMember } from '@dotrino/identity/content'
 import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { openCommKey, COMM_CN, COMM_CAPS } from './commKey.js'
@@ -44,6 +46,7 @@ import { seal } from '../lib/src/sealed.js'
 import { localSocketPath, socketDir } from '../lib/src/localdesk.js'
 import { dataDir, ensureDir } from './paths.js'
 import net from 'node:net'
+import os from 'node:os'
 import { atRestFor, kekFor, migrateFile, encryptText, decryptText } from './atrest.js'
 import { MSG, SCOPE, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
 
@@ -113,6 +116,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   const store = openStore(dir)
   const threads = openThreadStore(dir)
   const approvals = createApprovals()
+  /**
+   * LO QUE YA SE APROBÓ: comando + carpeta, por una hora desde el último uso.
+   *
+   * En memoria a propósito. Reiniciar la bóveda las borra todas, que es lo correcto: un
+   * permiso que sobrevive a un reinicio es un permiso que nadie recuerda haber dado.
+   */
+  const grants = createGrants()
 
   /**
    * Pedidos de aprobación que NO son de un cajón de secretos: quien espera es una
@@ -143,6 +153,47 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!record) return true          // sin acta no se decide que sí: se pide permiso
     return !Acta.memberCan(record, pub, 'unattended')
   }
+
+  /**
+   * QUÉ COMANDO ESTÁ PIDIENDO LAS CLAVES, Y DESDE QUÉ CARPETA — medido, no creído.
+   *
+   * Quien aprueba no puede decidir con «el aparato 904C-1002 pide el cajón proxy»: necesita
+   * ver qué se está ejecutando (dueño, 2026-09-11). El que pide lo cuenta en el pedido, pero
+   * contar no es probar, así que **si dice estar en esta misma máquina la bóveda lo lee del
+   * kernel** (`/proc/<pid>`) y lo compara. Si no cuadra, no es un matiz: es una mentira, y se
+   * deniega con un código que se puede buscar.
+   *
+   * SE MIRA EL PEDIDO, NUNCA EL CANAL. Sería más cómodo comprobar «vino por el socket local»,
+   * y está prohibido: el día que un handler decide algo por dónde entró el mensaje, el atajo
+   * local deja de ser un atajo y pasa a ser una puerta de atrás (`test/mostrador-local.test.mjs`).
+   * El `host` es un dato del pedido como cualquier otro, y mentirlo no consigue nada: lo que
+   * se gana es quedar marcado como no comprobado, que es exactamente lo que se quería evitar.
+   *
+   * Tres resultados, y son tres cosas distintas:
+   *   · `null` — no dijo nada. Se pide aprobación como siempre y no hay concesión posible.
+   *   · `verified: 'proc'` — lo leyó el kernel de esta máquina. Es lo que hay que enseñar.
+   *   · `verified: 'declared'` — lo dice quien pide y no hay forma de comprobarlo (otra
+   *     máquina, o un sistema sin `/proc`). Vale para decidir, pero la pantalla lo marca.
+   *
+   * Y EL LÍMITE, QUE NO SE ESCONDE: esto no autoriza nada. Cualquier proceso del mismo
+   * usuario puede leer el `service-identity.json` del servicio y pedir con esa llave, y puede
+   * llamarse como quiera. La frontera es el usuario, no el proceso: esto existe para que
+   * quien aprueba decida mirando lo que pasa, y para que quede rastro.
+   */
+  function contextoDelPedido (declarado) {
+    const dicho = sanitizeContext(declarado)
+    if (!dicho) return null
+    // Otra máquina: aquí no hay ningún `/proc` que hable de ese proceso.
+    if (!dicho.host || dicho.host !== os.hostname()) return { ...dicho, verified: 'declared' }
+    const medido = sanitizeContext(readProcContext(dicho.pid))
+    // El proceso ya no está, o no se puede mirar: no se sabe, y no saber se dice como no
+    // saber. Inventar un «comprobado» aquí sería el repliegue de siempre.
+    if (!medido) return { ...dicho, verified: 'declared' }
+    if (commandFingerprint(medido) !== commandFingerprint(dicho)) {
+      throw new Error(`ctx — it says it is running "${commandLine(dicho, 60)}" but pid ${dicho.pid} is "${commandLine(medido, 60)}"`)
+    }
+    return { ...medido, user: dicho.user, host: dicho.host, verified: 'proc' }
+  }
   // LA BÓVEDA DE CONTRASEÑAS: entradas y su llave, en el dir del perfil y cifradas en
   // reposo como todo lo demás. QUIÉN PUEDE PEDIR LO DICE EL ACTA (capacidad
   // `passwords`), como cualquier otro permiso: aquí no hay una segunda lista de
@@ -201,7 +252,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return key
   }
 
-  const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit('secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId }) }, 30 * 1000); approvalsSweeper.unref?.()
+  const approvalsSweeper = setInterval(() => {
+    for (const g of approvals.sweep()) audit('secrets.expired', { id: g.id, ns: g.ns, device: g.deviceId })
+    // Las concesiones vencidas también se anotan: si un servicio vuelve a timbrar el
+    // teléfono, esta línea es la que explica por qué (estuvo una hora sin pedir).
+    for (const g of grants.sweep()) audit('secrets.grant.expired', { id: g.id, ns: g.ns, device: g.deviceId })
+  }, 30 * 1000); approvalsSweeper.unref?.()
   const secrets = openSecretsStore(dir, {
     sealer: makeSealer(),
     // A QUIÉN se le envuelve la llave de cada cajón: los servicios de ese namespace (o el
@@ -880,7 +936,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // `method: 'toString'` (o cualquier miembro heredado de Object) pasaba el filtro y
     // se llamaba como si fuera del store.
     if (!d || typeof d.method !== 'string' || !Object.hasOwn(threads.methods, d.method)) {
-      return reply(from, { type: MSG.ERROR, error: 'store: invalid method' })
+      // Con `code`: un aparato más nuevo que esta bóveda pide métodos que aquí no existen, y
+      // tiene que poder decir «actualiza la bóveda» en vez de enseñar la frase.
+      return reply(from, { type: MSG.ERROR, error: 'store: invalid method', code: 'store-unknown-method' })
     }
     if (!isFresh(d)) return staleReply(from)
     // EL PERFIL VA POR OTRO CAMINO, y por eso se atiende antes que nada
@@ -1226,7 +1284,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // da acceso a nada por sí solo. Quien firma esta petición ya tiene la llave de firma
     // del servicio y su cert, o sea que ya lee ese namespace. No hay escalada.
     if (p.data?.op === 'enckey') return handleEncKey(from, p)
-    if (['approvals', 'approve', 'deny'].includes(p.data?.op)) return handleApproval(from, p)
+    if (['approvals', 'approve', 'deny', 'grants', 'grant-revoke'].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)' })
@@ -1263,6 +1321,27 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!publicOnly && needsApproval(chk.device, record)) {
       const deviceId = await deviceIdOf(chk.device).catch(() => null)
       const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
+      // QUÉ COMANDO, DESDE QUÉ CARPETA — medido contra `/proc` si se puede.
+      let ctx = null
+      try { ctx = contextoDelPedido(p.data?.ctx) } catch (e) {
+        audit('rejected', { what: 'secrets', ns, reason: 'ctx-mismatch' })
+        log(`[vault] ${ns}: refused ${deviceId || '????-????'} — ${e.message}`)
+        return reply(from, { type: MSG.ERROR, code: 'ctx-mismatch', error: 'unauthorized: ' + e.message })
+      }
+      // ¿YA DIJISTE QUE SÍ A ESTE COMANDO? Entonces no se vuelve a timbrar: la concesión
+      // dura una hora DESDE EL ÚLTIMO USO, así que un servicio que sigue pidiendo la
+      // mantiene viva. Cambia el comando o la carpeta y esto ya no encaja: otro pedido.
+      const vigente = grants.allows({ ns, device: chk.device, ctx })
+      if (vigente) {
+        try {
+          const res = await resultFor(ns, chk.device, p.data.ek, record, { publicOnly: false })
+          audit('secrets', { device: deviceId, ns, grant: vigente.id })
+          log(`[vault] ${ns}: ${deviceId || '????-????'} served without ringing (approved command, ${vigente.uses} use(s))`)
+          return reply(from, { type: MSG.SECRETS_RESULT, ...res })
+        } catch (e) {
+          return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
+        }
+      }
       // NADIE PUEDE APROBAR = SE DICE AHORA, no se deja esperando cinco minutos.
       //
       // La bóveda ya lo sabía —lo escribía en su propio log, «rang 0 approver(s)»— y aun
@@ -1288,9 +1367,10 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       // volver POR DONDE VINO. Si la pregunta entró por el mostrador local, mandarla por el
       // proxio la deja en el vacío: quien preguntó está escuchando en el socket, no ahí.
       // Lo cazó el E2E de aprobación, que se quedó esperando cinco minutos.
-      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek, from })
+      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek, ctx, from })
       audit('secrets.pending', { device: deviceId, ns, id: pend.id })
-      log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
+      log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})` +
+        (ctx ? ` — ${commandLine(ctx, 80)}  [${ctx.cwd || '?'}]` : ' — it does not say what it is running'))
       const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
       // El acta viaja también aquí: es con lo que el agente sabe qué llave podía firmar
       // esto. En `secrets.result` va dentro del sobre; en un «pendiente» no hay sobre.
@@ -1381,7 +1461,20 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       body = { ...body, ts: Date.now() }
       reply(from, { type: MSG.SECRETS_RESULT, body, seal: await sealOrFail(body) })
     }
-    if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
+    if (op === 'approvals') return answer({ op: 'approvals', items: await conContextoSellado(approvals.list(), chk.device, record) })
+    // LO QUE YA ESTÁ APROBADO SE VE Y SE CORTA DESDE DONDE SE APROBÓ. Una concesión que se
+    // 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 })
+    if (op === 'grant-revoke') {
+      const gid = typeof p.data?.id === 'string' ? p.data.id : ''
+      const ok = gid ? grants.revoke(gid) : false
+      if (ok) {
+        audit('secrets.grant.revoked', { id: gid, by })
+        log(`[vault] grant ${gid} revoked by ${by} — that command will ring again`)
+      }
+      return answer({ op: 'grant-revoke.result', id: gid, ok })
+    }
     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' })
@@ -1413,8 +1506,16 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     try { res = await resultFor(pend.ns, pend.device, pend.ek, record) } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'approval: could not seal the reply: ' + e.message })
     }
-    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by })
+    // LA HORA EMPIEZA AQUÍ, y se estira con cada uso: decir que sí a este comando vale para
+    // las siguientes veces que lo pida ESE MISMO comando desde ESA MISMA carpeta. Un pedido
+    // que no dijo qué corría no deja nada anotado, y se dice por qué: si no, el dueño vería
+    // que unos pedidos dejan de timbrar y otros no, sin ninguna explicación a mano.
+    const grant = grants.grant({ ns: pend.ns, device: pend.device, deviceId: pend.deviceId, ctx: pend.ctx, by })
+    audit('secrets.approved', { device: pend.deviceId, ns: pend.ns, id, by, ...(grant ? { grant: grant.id } : {}) })
     log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by}`)
+    log(grant
+      ? `[vault] ${pend.ns}: "${commandLine(pend.ctx, 80)}" approved for ${Math.round(GRANT_TTL_MS / 60000)} min from its last use (grant ${grant.id})`
+      : `[vault] ${pend.ns}: no grant — this request did not say what it is running, so the next one will ring again`)
     // Va por `sendByPubkey`: si el que pedía ya no está conectado, lo recoge al volver.
     // EL FALLO NO SE TRAGA. Tragarlo era lo peor de este mostrador: la bóveda apuntaba
     // «aprobado», el que pedía no recibía nada, y no quedaba una sola línea que mirar —
@@ -1429,6 +1530,43 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     return answer({ op: 'approve.result', id, ok: true })
   }
 
+  /**
+   * EL COMANDO Y EL PATH VIAJAN DENTRO DE UN SOBRE, no en claro.
+   *
+   * La lista de pedidos sale hacia el teléfono por el proxio, que no cifra (CONVENCIONES
+   * §4.1): mandar ahí el `argv` y el `cwd` le enseñaría al que opera el proxio las rutas del
+   * disco del dueño y los argumentos de sus comandos, que es justo lo que este ecosistema
+   * promete que no pasa. Así que el contexto se cifra **para el aparato que está
+   * preguntando** —con la misma cripto de los secretos sellados: una llave de una vez,
+   * envuelta a su `encPub` del acta— y él lo abre con `openSealedValue`, con una privada que
+   * no sale de su dispositivo.
+   *
+   * Un aparato sin `encPub` en el acta no recibe el contexto, y se dice (`ctxSealed: false`)
+   * en vez de mandárselo en claro «para que al menos lo vea»: eso sería cambiar la promesa
+   * por comodidad, y encima sin avisar a nadie.
+   */
+  async function conContextoSellado (items, aprobador, record) {
+    const encPub = (record?.members || []).find((m) => m.pub === aprobador)?.encPub || null
+    const salida = []
+    for (const it of items) {
+      const { ctx, ...resto } = it
+      if (!ctx) { salida.push({ ...resto, ctx: null }); continue }
+      if (!encPub) { salida.push({ ...resto, ctx: null, ctxSealed: false, ctxReason: 'no-enc-key' }); continue }
+      try {
+        const cek = await makeContentKey()
+        const envelope = await encryptWithCek({ cek, gen: 0, plaintext: JSON.stringify(ctx) })
+        const wrap = await wrapForMember({ cek, memberEncPub: encPub })
+        salida.push({ ...resto, ctx: null, ctxSealed: true, ctxWrap: wrap, ctxEnvelope: envelope })
+      } catch (e) {
+        // NO SE TRAGA: sin esto, un fallo al sellar se vería en el teléfono igual que un
+        // pedido que no dice nada, y nadie sabría que hay algo que arreglar.
+        log(`[vault] could not seal the command of ${it.id} for ${aprobador.slice(0, 24)}…: ${e.message}`)
+        salida.push({ ...resto, ctx: null, ctxSealed: false, ctxReason: 'seal-failed' })
+      }
+    }
+    return salida
+  }
+
   /**
    * Aviso a los aparatos que aprueban (cola del proxio → timbre nativo si están apagados).
    *
@@ -3235,6 +3373,11 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     passwordDevices,
     passwordsVault: () => passwords?.vault || null,
     listApprovals: () => approvals.list(),
+    // LAS CONCESIONES VIVAS, para verlas y para cortarlas. Se enseñan en la máquina del
+    // dueño (TUI/CLI), donde el contexto ya es suyo y no hay nada que sellar.
+    listGrants: () => grants.list(),
+    revokeGrant: (id) => grants.revoke(id),
+    revokeGrants: (filtro) => grants.revokeAll(filtro || {}),
     // Aprobar desde el PC avisa igual que aprobar a distancia: el resto de tus
     // dispositivos se entera de que entró alguien, venga de donde venga.
     approveDevice: async (code, adminKey) => {