@dotrino/vaultd 0.112.1 → 0.114.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.112.1",
+  "version": "0.114.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": {

package/src/approvals.js

@@ -1,23 +1,52 @@
 /**
- * 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.
  */
+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 +55,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 +80,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/ctl.js

@@ -155,7 +155,13 @@ function cmdStatus () {
 /** Una línea por perfil: nombre, id, huella y estado del candado. */
 function describeProfile (p) {
   const lock = !p.protected ? 'sin contraseña' : (p.locked ? `${B}🔒 bloqueado${Z}` : '🔓 desbloqueado')
-  return `${B}${p.name || '(sin nombre)'}${Z}  ${p.id}  ${p.fingerprint || '—'}  ${lock}`
+  // ALCANZABLE, Y SE DICE AQUÍ. Una bóveda puede estar corriendo y fuera de la red —si el
+  // proxio le rechazó el `identify`, nadie la alcanza por su pubkey— y desde fuera eso se ve
+  // igual que «no hay nada que aprobar»: el teléfono no timbra y no hay nada que mirar.
+  // `online` no viaja en las fotos de un daemon anterior, así que solo se enseña cuando el
+  // dato está y dice que no.
+  const red = p.online === false ? `  ${B}⚠ sin proxio (nadie puede alcanzarla)${Z}` : ''
+  return `${B}${p.name || '(sin nombre)'}${Z}  ${p.id}  ${p.fingerprint || '—'}  ${lock}${red}`
 }
 
 function showChallenge (pe) {

package/src/manager.js

@@ -195,7 +195,10 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
   /** Resumen para state.json / `profile ls`: identidad + candado de cada perfil. */
   const summary = () => profiles.list().map((p) => {
     const v = running.get(p.id)
-    return { ...p, fingerprint: v?.fingerprint || null, iss: v?.master || null }
+    // `online` es ALCANZABLE, no «corriendo»: la bóveda puede estar abierta y con el socket
+    // en pie y aun así fuera de la red, si el proxio le rechazó el `identify` (un reloj
+    // atrasado al arrancar, p. ej.). Sin esto, eso solo se veía en una línea del log.
+    return { ...p, fingerprint: v?.fingerprint || null, iss: v?.master || null, online: v ? !!v.isIdentified?.() : false }
   })
 
   return {

package/src/transport.js

@@ -36,7 +36,7 @@ export async function masterPubkeyOf (identity) {
  * @param {string} [opts.url] URL del proxy (default wss://proxy.dotrino.com).
  * @returns {Promise<{ client, token:string, identify():Promise<void> }>}
  */
-export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, commKey = null, log = () => {} }) {
+export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, commKey = null, log = () => {}, makeClient = null }) {
   installNodeGlobals(dir)
   // Import dinámico DESPUÉS de instalar los globals que el paquete usa.
   // `WebSocketProxyClient` (la clase) y NO el helper `getWebSocketProxyClient`:
@@ -44,7 +44,11 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
   // conexión POR PERFIL (cada maestra se identifica con su propia pubkey ante el
   // proxy). Con el singleton, el segundo perfil reusaba el cliente del primero y
   // su `identify` pisaba al anterior. Sigue siendo el cliente oficial del paquete.
-  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+  // `makeClient` es la costura de las PRUEBAS, y existe por una razón concreta: comprobar
+  // que un `identify` rechazado no tumba el perfil y se reintenta solo. Sin ella habría que
+  // levantar un proxio de verdad para probar el caso que ya costó una tarde. En producción
+  // no se pasa nunca y esto es el cliente oficial de siempre.
+  const { WebSocketProxyClient } = makeClient ? {} : await import('@dotrino/proxy-client')
 
   /**
    * EL CANAL DIRECTO, ENCENDIDO Y CON LA PUERTA CERRADA.
@@ -65,13 +69,17 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
   // el acta es asíncrono. Así que se guarda una copia y se refresca donde ya se refresca
   // todo: en `identify`, que es lo que corre cada vez que el acta cambia o se reconecta.
   let actaVista = null
+  // ¿Está esta bóveda ATADA al proxio ahora mismo? Conectado no es identificado: el socket
+  // puede estar perfectamente abierto y el sobre rechazado, y entonces nadie la alcanza por
+  // su pubkey. Se expone para que `status` lo enseñe en vez de dejarlo a un log del arranque.
+  let identificado = false
   const enElActa = (token) => {
     // SIN ACTA NO SE NEGOCIA. No se sabe quién es nadie, y en la duda no se arranca a
     // parsear red no confiable. Se sigue por el proxio, que es el escalón que siempre está.
     if (!actaVista) return false
     return (actaVista.members || []).some((m) => m?.pub === token)
   }
-  const client = new WebSocketProxyClient({
+  const client = makeClient ? makeClient({ url, acceptDirectFrom: enElActa }) : new WebSocketProxyClient({
     url, enableWebRTC: true, acceptDirectFrom: enElActa, autoReconnect: true,
     maxReconnectAttempts: 100000, reconnectDelay: 4000
   })
@@ -79,6 +87,7 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
   await client.connect()
 
   const identify = async () => {
+    identificado = false
     if (!client.token) return
     const record = (await identity.profileActa?.().catch(() => null))?.acta || null
     actaVista = record   // la copia que mira la puerta del canal directo
@@ -90,6 +99,7 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
       // El sobre lo arma el pilar (`identifyAs`), que le pone el destinatario.
       try {
         await client.identifyAs({ publickey: comm, sign: (d) => commKey.sign(d), acta: record })
+        identificado = true
         // SE DICE QUE SE IDENTIFICÓ, y con qué llave. Este camino era MUDO: al pasar de la
         // maestra a la llave de comunicación, el único rastro de «estoy alcanzable» que
         // quedaba en el log era el del repliegue. Así que cuando la consola decía «no
@@ -124,13 +134,51 @@ export async function createTransport ({ identity, dir, url = DEFAULT_PROXY, com
       if (!publickey) return
       log('[vault] identifying with the master key: this vault is not in its own record yet (open the profile once to fix it)')
       await client.identifyAs({ publickey, sign: (d) => identity.signData(d), acta: record })
+      identificado = true
     } catch (e) {
       log(`[vault] cannot identify on the proxy yet: ${e.message} — the profile still opens; unlock it once and it gets its own communication key`)
     }
   }
-  await identify()
+  /**
+   * IDENTIFICARSE PUEDE FALLAR, Y ESO NO PUEDE TUMBAR EL PERFIL — NI QUEDARSE ASÍ.
+   *
+   * Esto era `await identify()` a secas, así que cualquier «no» del proxio subía por
+   * `createTransport` hasta `startVault` y el perfil **no se abría en absoluto**: no es que
+   * se quedara sin voz, es que cada petición contestaba `profile is not open` y en el
+   * `status` el perfil salía sin huella. Y no se reintentaba nunca: `identify` solo vuelve a
+   * correr con el evento `token`, o sea al RECONECTAR, y aquí el socket estaba perfectamente
+   * conectado — lo que el proxio rechazó fue el sobre.
+   *
+   * El caso real (2026-09-10): esta máquina arranca con el reloj 35 minutos atrasado (el
+   * `systemd-timesyncd` no contactó el servidor de hora hasta media hora después del
+   * arranque), el proxio rechaza el `identify` con «ts fuera de la ventana ±5min» y la
+   * bóveda se quedaba fuera de la red DESDE EL ARRANQUE HASTA QUE ALGUIEN LA REINICIABA.
+   * Con ella fuera no hay a quién timbrar: el teléfono nunca recibía un pedido de
+   * aprobación, y desde fuera eso se ve igual que «no hay pedidos».
+   *
+   * Reintentar con espera creciente lo arregla solo en cuanto el reloj se corrige, y cada
+   * intento se dice en voz alta: una bóveda inalcanzable en silencio es el fallo que ya
+   * costó un día entero (`CLAUDE.md`, el apagón del 1-2 de septiembre).
+   */
+  let reintento = null
+  let fallos = 0
+  const identifyWithRetry = async () => {
+    if (reintento) { clearTimeout(reintento); reintento = null }
+    try {
+      await identify()
+      if (fallos) log(`[vault] identified on the proxy after ${fallos + 1} attempt(s)`)
+      fallos = 0
+    } catch (e) {
+      fallos++
+      const espera = Math.min(60000, 5000 * fallos)
+      log(`[vault] could not identify on the proxy (${e.message}) — retrying in ${Math.round(espera / 1000)}s; until then this vault is unreachable and cannot ring anyone`)
+      reintento = setTimeout(() => { reintento = null; identifyWithRetry() }, espera)
+      reintento.unref?.()
+    }
+  }
+  await identifyWithRetry()
   // Re-identificar al reconectar (el token cambia).
-  client.on('token', () => { identify().catch(() => {}) })
+  client.on('token', () => { fallos = 0; identifyWithRetry() })
 
-  return { client, token: client.token, identify }
+  return { client, token: client.token, identify: identifyWithRetry, isIdentified: () => identificado }
 }

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
@@ -306,7 +362,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   }
   await ensureCommKeyInActa()
 
-  const { client, identify: reidentificar } = await createTransport({ identity, dir, url: proxyUrl, commKey, log })
+  const { client, identify: reidentificar, isIdentified } = await createTransport({ identity, dir, url: proxyUrl, commKey, log })
 
   // El registro público de cadenas de selladores: deposita, si hay a dónde, los eslabones
   // que le dicen a un tercero si esta cuenta sigue sellada por quien él cree. Ver
@@ -1226,7 +1282,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 +1319,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 +1365,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 +1459,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 +1504,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 +1528,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).
    *
@@ -3179,6 +3315,9 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   return {
     identity, client, store, threads, secrets, master, fingerprint: fp, dir,
+    // Alcanzable ≠ corriendo: si el proxio rechazó el `identify` esta bóveda está viva y
+    // nadie puede hablarle. Lo mira `status` (ver `manager.js`, `summary`).
+    isIdentified,
     // Se expone para poder PROBAR que una respuesta que no cabe no mata la conexión: es el
     // único punto por el que sale todo, y el fallo que cierra vive justo ahí.
     reply,
@@ -3232,6 +3371,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) => {