@dotrino/vaultd 0.46.2 → 0.49.1

package/README.md

@@ -73,7 +73,7 @@ solo de qué cert se emitió un día.
 
 ```sh
 dotrino-vault members            # el acta: qué llaves son tuyas y qué puede hacer cada una
-dotrino-vault caps <ID> +firma   # cambia permisos (+firma -guarda +lee …)
+dotrino-vault caps <ID> +firma   # cambia permisos (+firma -guarda +lee +administra +aprueba …)
 ```
 
 **Los certificados caducan y se renuevan solos.** Un cert dura **30 días**. Mientras
@@ -235,11 +235,12 @@ dotrino-vault approve <código>     # aprueba tecleando los 6 dígitos que MUEST
 dotrino-vault reject  <deviceId>   # rechaza un dispositivo pendiente
 dotrino-vault devices              # lista dispositivos enrolados / revocados
 dotrino-vault members              # el acta del perfil: qué llaves son tuyas y qué puede cada una
-dotrino-vault caps <ID> ±permiso   # cambia lo que puede un dispositivo (+firma -guarda +lee …)
+dotrino-vault caps <ID> ±permiso   # cambia lo que puede un dispositivo (+firma -guarda +lee +administra +aprueba …)
 dotrino-vault revoke  <nonce>      # revoca un dispositivo (le ordena autoborrarse)
 dotrino-vault activity [n]         # bitácora de seguridad: firmas, renovaciones, enrolados, rechazos
 dotrino-vault pair --service <ns>  # empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
 dotrino-vault pair --scope <lista>  # los PERMISOS del cert: sign,read,store,secrets:<ns>. Sin esto, sign,read,store.
+dotrino-vault secret policy <ns> approval on|off   # el cajón pide tu aprobación en cada lectura (15 min de ventana)
                                     # Se combina con --service: `--service eco --scope sign` = un bot que firma
                                     # como aparato del acta y lee SOLO su cajón. `admin` no se empareja (caps).
 dotrino-vault secret set <ns> <CLAVE> <valor>   # variable del SCOPE: la comparten todos los
@@ -755,6 +756,47 @@ CLI de apoyo: `dotrino-env status` (qué hay enrolado aquí), `dotrino-env check
 los secretos en el entorno de un proceso que no es Node). Primer consumidor:
 `dotrino-proxy` (TURN de Cloudflare).
 
+### Aprobación por uso (el teléfono dice que sí) y la llave SSH en el teléfono
+
+Un cajón puede exigir el **visto bueno de un aparato** en cada lectura: para lo que corre
+en tu PC (un asistente, un script) y no debería llevarse tus claves sin que lo sepas.
+
+```sh
+dotrino-vault caps <ID-del-teléfono> +aprueba       # quién aprueba (no viaja en un QR)
+dotrino-vault secret policy claude approval on       # el cajón «claude» espera el sí
+dotrino-env run --ns claude -- node mi-script.js     # el proceso se queda esperando…
+```
+
+…la bóveda apunta el pedido, avisa al teléfono (cola del proxio → aviso nativo), y solo su
+firma entrega las claves — **al proceso que pidió, en memoria**, con una **ventana de
+15 min** por aparato y cajón para no pedir veinte veces. Lo denegado corta sin reintentos;
+lo que nadie atiende vence a los 5 min; todo queda en `dotrino-vault activity`.
+
+**La llave SSH vive en el teléfono.** El daemon expone un **agente SSH** (protocolo de
+`ssh-agent`, socket en `$XDG_RUNTIME_DIR/dotrino-vault/ssh-agent.sock`) que **no guarda
+ninguna llave privada**: la llave nace en el teléfono (vault.dotrino.com → *Llave SSH de
+este aparato*; WebCrypto no extraíble, `ecdsa-sha2-nistp256`) y cada firma es un pedido
+que apruebas ahí. En el PC no queda nada que copiar.
+
+```sh
+dotrino-vault ssh                 # imprime el export SSH_AUTH_SOCK=… y la receta
+dotrino-vault ssh keys            # las llaves registradas (= ssh-add -L)
+ssh mi-servidor                   # el teléfono pide tu «sí» y firma
+```
+
+**La bóveda puede estar en OTRA máquina** (la de Dotrino en el VPS): en tu PC corre el
+agente **delgado**, que no custodia nada y reenvía cada reto como un pedido a la bóveda
+que enroló ese servicio:
+
+```sh
+dotrino-env enroll --ns claude                   # una vez, contra la bóveda que sea
+dotrino-env ssh-agent --ns claude                # imprime export SSH_AUTH_SOCK=…
+```
+
+Para no aprobar cada comando, reusa la conexión con `ControlMaster auto` +
+`ControlPersist 15m` en `~/.ssh/config`: esa es la ventana de 15 min del SSH.
+`DOTRINO_VAULT_SSH_AGENT=0` apaga el agente.
+
 ## Alcance
 
 - **v1 (este):** daemon headless en Node, **multi-perfil**. En **Linux** queda como

package/lib/README.md

@@ -279,3 +279,10 @@ cert de una máquina vigente: sin esto toda máquina enrolada caducaba a los 30
 | bitácora, cifrado en reposo, candado, multi-perfil | son del daemon; en el navegador dependen de `@dotrino/identity` |
 
 MIT · parte de [Dotrino](https://dotrino.com).
+
+## Agente SSH delgado (`dotrino-env ssh-agent`)
+
+La llave SSH vive en el teléfono del dueño (registrada en su bóveda). En esta máquina solo
+corre un agente `ssh-agent` sin llaves: cada `SIGN_REQUEST` viaja a la bóveda como un
+pedido que el teléfono aprueba firmando. `dotrino-env ssh-agent --ns <ns>` imprime el
+`SSH_AUTH_SOCK`. Como librería: `listSshKeys(args)` y `requestSshSign(args, { keyId, data })`.

package/lib/src/env.js

@@ -98,12 +98,12 @@ let lastApplied = null
  *   `overridden` = las que YA tenían otro valor en el entorno y el vault pisó. Es
  *   el dato que delata un `.env` rancio, así que se reporta en vez de callarse.
  */
-export async function loadEnv ({ ns, dir, override, wait = true, required = [], onRetry } = {}) {
+export async function loadEnv ({ ns, dir, override, wait = true, required = [], onRetry, onPending } = {}) {
   if (override === undefined) override = overrideByDefault()
   ns = resolveNs(ns)
   dir = dir || serviceDir(ns)
   const load = wait ? waitForSecrets : fetchSecrets
-  const secrets = await load({ dir, ns, onRetry })
+  const secrets = await load({ dir, ns, onRetry, onPending })
 
   const missing = required.filter((k) => !(k in secrets))
   if (missing.length) {

package/lib/src/protocol.js

@@ -97,7 +97,8 @@ export const SCOPE = Object.freeze({
   // Consola remota (docs/consola-remota.md): admitir y expulsar miembros a distancia.
   // NO incluye cambiar permisos, traspasar el mando ni conceder `admin`: eso es el rol
   // de master y sigue siendo local. No se empareja — se concede desde el PC.
-  ADMIN: 'vault:admin'
+  ADMIN: 'vault:admin',
+  APPROVE: 'vault:approve' // aprobar pedidos de secretos (cajones con `approval`); se concede a mano, como admin
 })
 
 /**

package/lib/src/service.js

@@ -161,6 +161,9 @@ async function identifyAsService (client, device) {
   await client.identify({ data, signature })
 }
 
+/** Cuánto espera un agente a que alguien apruebe (el pedido vive 5 min en la bóveda). */
+export const APPROVAL_TIMEOUT_MS = 5 * 60 * 1000 + 10 * 1000
+
 function waitForMsg (client, predicate, timeoutMs = 30000) {
   return new Promise((resolve, reject) => {
     const off = client.on('message', (_from, payload) => {
@@ -407,7 +410,7 @@ export async function registerEncKey ({ dir, ns, proxyUrl, masterPubkey, device,
  * Renueva el cert automáticamente si está por vencer (best-effort).
  * @returns {Promise<Record<string,string>>}  secretos KEY→valor
  */
-export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, timeoutMs = 30000 } = {}) {
+export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, timeoutMs = 30000, onPending, approvalTimeoutMs = APPROVAL_TIMEOUT_MS } = {}) {
   let saved = null
   if (dir) saved = readServiceIdentity(dir)
   // Sin `dir`: la identidad viene entera por parámetros — es el caso de un agente
@@ -448,9 +451,22 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
     const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
     const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
     client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data, signature, cert })
-    const res = await pending
+    let res = await pending
     if (res.type === MSG.ERROR) throw new Error(res.error)
 
+    // CAJÓN CON APROBACIÓN: la bóveda contesta «pendiente» (firmado) y la respuesta de
+    // verdad llega cuando el aparato que aprueba firme — por esta misma conexión, que
+    // sigue identificada. Se espera lo que dura el pedido; denegado o vencido es error.
+    if (res.body?.op === 'secrets.pending' && res.body.ns === ns) {
+      const okPending = await verifyDeviceSig({ publickey: masterPubkey, data: res.body, signature: res.signature })
+      if (!okPending) throw new Error('invalid master signature on the pending reply')
+      try { onPending?.({ id: res.body.id, ns, exp: res.body.exp }) } catch (_) {}
+      const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : approvalTimeoutMs
+      res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'secrets.result') || p.type === MSG.ERROR, Math.min(until, approvalTimeoutMs))
+        .catch((e) => { throw new Error(/timeout/.test(e.message) ? 'approval: nobody approved the request in time' : e.message) })
+      if (res.type === MSG.ERROR) throw new Error(res.error)
+    }
+
     // Autenticidad: el cuerpo viene firmado por la MAESTRA pineada.
     const body = res.body
     if (!body || body.op !== 'secrets.result' || body.ns !== ns) throw new Error('malformed secrets reply')
@@ -475,6 +491,54 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
   } finally { client.close() }
 }
 
+/**
+ * AGENTE SSH DELGADO (`dotrino-env ssh-agent`): este proceso no custodia nada. Lista las
+ * llaves públicas que la bóveda tiene registradas y, por cada reto, le pide a la bóveda
+ * que lo convierta en un PEDIDO que el teléfono firma. Cualquier aparato con `vault:sign`
+ * puede pedir; quien decide es el teléfono.
+ */
+function serviceArgs ({ dir, ns, proxyUrl, masterPubkey, device, cert }) {
+  let saved = dir ? readServiceIdentity(dir) : null
+  if (!saved && device && cert) saved = { ns, iss: masterPubkey, proxy: proxyUrl, device, cert }
+  const out = { ns: ns || saved?.ns, proxyUrl: proxyUrl || saved?.proxy, masterPubkey: masterPubkey || saved?.iss, device: device || saved?.device, cert: cert || saved?.cert }
+  if (!out.proxyUrl || !out.masterPubkey || !out.device || !out.cert) throw new Error('service not enrolled: run enrollService() first (service-identity.json missing)')
+  return out
+}
+async function sshRpc (args, data, { timeoutMs = 30000, waitResult = null } = {}) {
+  const { proxyUrl, masterPubkey, device, cert } = serviceArgs(args)
+  const client = await freshClient(proxyUrl)
+  try {
+    await identifyAsService(client, device)
+    const signed = { ...data, publickey: device.publickey, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data: signed })
+    const pending = waitForMsg(client, (p) => p.type === MSG.SECRETS_RESULT || p.type === MSG.ERROR, timeoutMs)
+    client.sendByPubkey(masterPubkey, { type: MSG.SECRETS, data: signed, signature, cert })
+    let res = await pending
+    if (res.type === MSG.ERROR) throw new Error(res.error)
+    if (waitResult && res.body?.op === 'ssh.pending') {
+      try { waitResult.onPending?.({ id: res.body.id, exp: res.body.exp }) } catch (_) {}
+      const until = typeof res.body.exp === 'number' ? Math.max(5000, res.body.exp - Date.now() + 5000) : APPROVAL_TIMEOUT_MS
+      res = await waitForMsg(client, (p) => (p.type === MSG.SECRETS_RESULT && p.body?.op === 'ssh.sign.result') || p.type === MSG.ERROR, Math.min(until, APPROVAL_TIMEOUT_MS))
+        .catch((e) => { throw new Error(/timeout/.test(e.message) ? 'ssh: nobody approved the request in time' : e.message) })
+      if (res.type === MSG.ERROR) throw new Error(res.error)
+    }
+    const ok = await verifyDeviceSig({ publickey: masterPubkey, data: res.body, signature: res.signature })
+    if (!ok) throw new Error('invalid master signature on the reply')
+    return res.body
+  } finally { client.close() }
+}
+/** Las llaves SSH públicas registradas en la bóveda: `[{ id, blob, comment }]`. */
+export async function listSshKeys (args = {}) {
+  const body = await sshRpc(args, { op: 'ssh.keys.public' })
+  return Array.isArray(body.items) ? body.items : []
+}
+/** Pide la firma SSH de `data` con la llave `keyId`; devuelve el blob de firma (Buffer). */
+export async function requestSshSign (args = {}, { keyId, data, onPending } = {}) {
+  const body = await sshRpc(args, { op: 'ssh.sign', key: keyId, data: Buffer.from(data).toString('base64') }, { waitResult: { onPending } })
+  if (typeof body.sig !== 'string') throw new Error('ssh: malformed signature reply')
+  return Buffer.from(body.sig, 'base64')
+}
+
 /**
  * Abre un bundle sellado: saca la CEK de la envoltura dirigida a este aparato y
  * descifra con ella las variables privadas. Las públicas vienen en claro.
@@ -882,15 +946,16 @@ function fingerprintOf (secrets) {
  * servicio no opera hasta que esto resuelva — esa es la regla.
  * @returns {Promise<Record<string,string>>}
  */
-export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry } = {}) {
+export async function waitForSecrets ({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, retryMs = 5000, maxRetryMs = 60000, onRetry, onPending } = {}) {
   let delay = retryMs
   for (;;) {
     try {
-      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc })
+      return await fetchSecrets({ dir, ns, proxyUrl, masterPubkey, device, cert, enc, onPending })
     } catch (e) {
       // Lo NO transitorio no se arregla reintentando: falta de enrolamiento,
       // cert revocado/vencido o scope equivocado exigen re-emparejar → se corta.
-      if (/not enrolled|invalid ns|unauthorized: (revoked|expired|scope|cn|untrusted-issuer|cert-device-mismatch)/.test(e.message)) throw e
+      // Que te lo DENIEGUEN tampoco se reintenta: fue una decisión, no un tropiezo.
+      if (/not enrolled|invalid ns|unauthorized: (revoked|expired|scope|cn|untrusted-issuer|cert-device-mismatch|denied)/.test(e.message)) throw e
       try { onRetry?.(e, delay) } catch (_) {}
       await new Promise((r) => setTimeout(r, delay))
       delay = Math.min(maxRetryMs, Math.round(delay * 1.6))

package/lib/src/sshAgent.js

@@ -0,0 +1,100 @@
+/**
+ * AGENTE SSH del daemon: un socket Unix con el protocolo de `ssh-agent` (draft-miller-
+ * ssh-agent), para que el `ssh` del usuario firme con la llave que vive en su TELÉFONO.
+ *
+ * Lo que hace es poco a propósito: listar las llaves públicas registradas y, en cada
+ * `SIGN_REQUEST`, pedirle la firma al aparato que aprueba (`vault.requestSshSign`) y
+ * devolverla. No guarda llaves privadas, no acepta que le añadan (`ssh-add` de una llave
+ * del disco se rechaza: la idea es justo que no haya llaves en el disco) y no hace de
+ * proxy de nada más.
+ *
+ *   export SSH_AUTH_SOCK=$XDG_RUNTIME_DIR/dotrino-vault/ssh-agent.sock
+ *   ssh-add -L          # las llaves del teléfono
+ *   ssh mi-servidor     # el teléfono pide tu «sí» y firma
+ */
+import fs from 'node:fs'
+import net from 'node:net'
+import path from 'node:path'
+import { sshString, readStrings } from './sshKeys.js'
+
+const AGENT_FAILURE = 5
+const AGENT_SUCCESS = 6
+const REQUEST_IDENTITIES = 11
+const IDENTITIES_ANSWER = 12
+const SIGN_REQUEST = 13
+const SIGN_RESPONSE = 14
+
+/** Dónde va el socket: en el directorio de ejecución del usuario si lo hay (se limpia solo). */
+export function defaultSocketPath (dir) {
+  const run = process.env.XDG_RUNTIME_DIR
+  return run ? path.join(run, 'dotrino-vault', 'ssh-agent.sock') : path.join(dir, 'ssh-agent.sock')
+}
+
+const frame = (type, payload = Buffer.alloc(0)) => {
+  const body = Buffer.concat([Buffer.from([type]), payload])
+  const len = Buffer.alloc(4); len.writeUInt32BE(body.length)
+  return Buffer.concat([len, body])
+}
+
+/**
+ * @param {{ socketPath: string, vault: () => { sshKeys: () => any[], requestSshSign: (a: { keyId: string, data: Buffer }) => Promise<Buffer> }, log?: Function }} opts
+ */
+export function startSshAgent ({ socketPath, vault, log = () => {}, refresh = null }) {
+  fs.mkdirSync(path.dirname(socketPath), { recursive: true, mode: 0o700 })
+  try { fs.unlinkSync(socketPath) } catch (_) {}
+
+  async function handle (type, payload) {
+    if (refresh) { try { await refresh() } catch (_) {} }
+    const v = vault()
+    if (type === REQUEST_IDENTITIES) {
+      const keys = v.sshKeys()
+      const n = Buffer.alloc(4); n.writeUInt32BE(keys.length)
+      const parts = keys.map((k) => Buffer.concat([sshString(Buffer.from(k.blob, 'base64')), sshString(Buffer.from(k.comment || ''))]))
+      return frame(IDENTITIES_ANSWER, Buffer.concat([n, ...parts]))
+    }
+    if (type === SIGN_REQUEST) {
+      const [blob, data] = readStrings(payload, 2)
+      const key = v.sshKeys().find((k) => k.blob === blob.toString('base64'))
+      if (!key) return frame(AGENT_FAILURE)
+      try {
+        const sig = await v.requestSshSign({ keyId: key.id, data })
+        return frame(SIGN_RESPONSE, sshString(sig))
+      } catch (e) {
+        log('[vault] ssh-agent: not signed: ' + e.message)
+        return frame(AGENT_FAILURE)
+      }
+    }
+    // Añadir/quitar llaves, candado, extensiones: nada de eso vive aquí.
+    return frame(AGENT_FAILURE)
+  }
+
+  const server = net.createServer((sock) => {
+    let buf = Buffer.alloc(0)
+    let busy = Promise.resolve()
+    sock.on('data', (chunk) => {
+      buf = Buffer.concat([buf, chunk])
+      while (buf.length >= 4) {
+        const len = buf.readUInt32BE(0)
+        if (len < 1 || len > 256 * 1024) { sock.destroy(); return }
+        if (buf.length < 4 + len) break
+        const type = buf[4]; const payload = buf.subarray(5, 4 + len)
+        buf = buf.subarray(4 + len)
+        // En orden: el protocolo es petición-respuesta, y un cliente que encadena dos
+        // firmas espera las respuestas en el mismo orden.
+        busy = busy.then(() => handle(type, payload)).then((out) => { if (!sock.destroyed) sock.write(out) }).catch(() => { if (!sock.destroyed) sock.write(frame(AGENT_FAILURE)) })
+      }
+    })
+    sock.on('error', () => {})
+  })
+  server.on('error', (e) => log('[vault] ssh-agent: ' + e.message))
+  server.listen(socketPath, () => {
+    try { fs.chmodSync(socketPath, 0o600) } catch (_) {}
+    log(`[vault] ssh-agent listening at ${socketPath}  (export SSH_AUTH_SOCK=${socketPath})`)
+  })
+  return {
+    socketPath,
+    close () { try { server.close() } catch (_) {} try { fs.unlinkSync(socketPath) } catch (_) {} }
+  }
+}
+
+export default { startSshAgent, defaultSocketPath, AGENT_SUCCESS }

package/lib/src/sshKeys.js

@@ -0,0 +1,76 @@
+/**
+ * LLAVES SSH del teléfono — solo la parte PÚBLICA, que es lo único que vive en esta
+ * máquina. La privada nace y muere en el aparato que aprueba (WebCrypto no extraíble hoy;
+ * el llavero del sistema en la app nativa): firmar un reto SSH es un pedido de aprobación
+ * más, y la firma vuelve con el «sí». Así la llave SSH no está en el disco del PC, que
+ * era exactamente lo que había que sacar de aquí.
+ *
+ * Formatos (RFC 4253 / 5656): el blob de una llave `ecdsa-sha2-nistp256` es
+ * string(tipo) string("nistp256") string(0x04‖X‖Y); su firma es string(tipo) string(mpint r ‖ mpint s).
+ * Puro: sin disco ni red — quien guarda es `vault.js`.
+ */
+import { createPublicKey, createHash, verify as nodeVerify } from 'node:crypto'
+
+export const ECDSA_P256 = 'ecdsa-sha2-nistp256'
+
+const u32 = (n) => { const b = Buffer.alloc(4); b.writeUInt32BE(n >>> 0); return b }
+export const sshString = (buf) => Buffer.concat([u32(buf.length), Buffer.from(buf)])
+export function sshMpint (bytes) {
+  let b = Buffer.from(bytes)
+  while (b.length > 1 && b[0] === 0) b = b.subarray(1)
+  if (b[0] & 0x80) b = Buffer.concat([Buffer.from([0]), b])
+  return sshString(b)
+}
+/** Lee strings SSH encadenados: `[Buffer, …]`. */
+export function readStrings (buf, max = 16) {
+  const out = []; let o = 0
+  while (o + 4 <= buf.length && out.length < max) {
+    const n = buf.readUInt32BE(o); o += 4
+    if (o + n > buf.length) throw new Error('ssh: truncated string')
+    out.push(buf.subarray(o, o + n)); o += n
+  }
+  return out
+}
+
+/** Blob de llave pública a partir de las coordenadas (base64url JWK). */
+export function p256Blob ({ x, y }) {
+  const point = Buffer.concat([Buffer.from([4]), Buffer.from(x, 'base64url'), Buffer.from(y, 'base64url')])
+  return Buffer.concat([sshString(Buffer.from(ECDSA_P256)), sshString(Buffer.from('nistp256')), sshString(point)])
+}
+
+/**
+ * Acepta una línea `authorized_keys` (`ecdsa-sha2-nistp256 AAAA… comentario`) y devuelve
+ * lo que se guarda: tipo, blob, comentario y JWK pública. Solo P-256: es lo que firma
+ * WebCrypto y el llavero del teléfono; RSA no entra.
+ */
+export function parsePublicKey (line) {
+  const [type, b64, ...rest] = String(line || '').trim().split(/\s+/)
+  if (type !== ECDSA_P256 || !b64) throw new Error(`ssh: only ${ECDSA_P256} keys are accepted`)
+  const blob = Buffer.from(b64, 'base64')
+  const [t, curve, point] = readStrings(blob, 3)
+  if (t.toString() !== ECDSA_P256 || curve.toString() !== 'nistp256' || point.length !== 65 || point[0] !== 4) throw new Error('ssh: malformed key blob')
+  const jwk = { kty: 'EC', crv: 'P-256', x: point.subarray(1, 33).toString('base64url'), y: point.subarray(33).toString('base64url') }
+  return { type, blob: blob.toString('base64'), comment: rest.join(' '), jwk, id: fingerprint(blob) }
+}
+
+/** `SHA256:…` como lo imprime `ssh-keygen -l`. */
+export function fingerprint (blob) {
+  return 'SHA256:' + createHash('sha256').update(Buffer.from(blob)).digest('base64').replace(/=+$/, '')
+}
+
+/**
+ * Comprueba la firma cruda del teléfono (`r‖s`, 64 bytes, SHA-256 sobre `data`) y la
+ * convierte al blob de firma SSH. Una firma que no cuadra NO se convierte: devolver un
+ * blob inválido dejaría al `ssh` del usuario con un error opaco y a nosotros sin bitácora.
+ */
+export function sshSignature ({ jwk, data, rawSig }) {
+  const sig = Buffer.from(rawSig, 'base64')
+  if (sig.length !== 64) throw new Error('ssh: raw signature must be 64 bytes (r||s)')
+  const key = createPublicKey({ key: { kty: 'EC', crv: 'P-256', x: jwk.x, y: jwk.y }, format: 'jwk' })
+  const ok = nodeVerify('sha256', Buffer.from(data), { key, dsaEncoding: 'ieee-p1363' }, sig)
+  if (!ok) throw new Error('ssh: the signature does not verify against the registered key')
+  const rs = Buffer.concat([sshMpint(sig.subarray(0, 32)), sshMpint(sig.subarray(32))])
+  return Buffer.concat([sshString(Buffer.from(ECDSA_P256)), sshString(rs)])
+}
+
+export default { ECDSA_P256, parsePublicKey, p256Blob, sshSignature, sshString, sshMpint, readStrings, fingerprint }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.46.2",
+  "version": "0.49.1",
   "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": {
@@ -20,7 +20,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.57.0",
+    "@dotrino/identity": "^0.58.0",
     "@dotrino/proxy-client": "^0.10.1",
     "ws": "^8.18.0"
   },

package/src/approvals.js

@@ -0,0 +1,69 @@
+/**
+ * PEDIDOS DE APROBACIÓN y VENTANAS de un cajón con `approval` (puro: sin red ni disco).
+ *
+ * Cuando un cajón exige aprobación por uso, leerlo ya no depende solo de tener el cert:
+ * el vault apunta el pedido, avisa a los aparatos con `approve` (el teléfono), y solo su
+ * firma libera los secretos. Aprobado, se abre una VENTANA para ese aparato y ese cajón
+ * (15 min): una sesión de trabajo no pide veinte veces. Lo que nadie aprueba vence solo.
+ *
+ * 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.
+ */
+const rnd = () => [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, '0')).join('')
+
+export const PENDING_TTL_MS = 5 * 60 * 1000
+export const GRANT_TTL_MS = 15 * 60 * 1000
+
+export function createApprovals ({ now = Date.now, pendingTtlMs = PENDING_TTL_MS, grantTtlMs = GRANT_TTL_MS } = {}) {
+  /** id → { id, ns, device, deviceId, label, ek, ts, exp } */
+  const pending = new Map()
+  /** `${ns}|${device}` → exp */
+  const grants = new Map()
+  const gkey = (ns, device) => ns + '|' + device
+
+  const publicOf = (p) => ({ id: p.id, kind: p.kind, ns: p.ns, deviceId: p.deviceId, label: p.label, ts: p.ts, exp: p.exp, ...(p.ssh ? { ssh: p.ssh } : {}) })
+
+  return {
+    /**
+     * Apunta un pedido. `kind`: `secrets` (leer un cajón; uno por cajón y aparato: pedir
+     * otra vez reemplaza al anterior) o `ssh` (firmar un reto SSH con la llave del
+     * teléfono; cada firma es un pedido, con `ssh: { key, data }` y sus callbacks).
+     */
+    request ({ kind = 'secrets', ns, device = null, deviceId, label = '', ek = null, ssh = null, resolve = null, reject = null }) {
+      if (kind === 'secrets') for (const [id, p] of pending) if (p.kind === 'secrets' && p.ns === ns && p.device === device) pending.delete(id)
+      const ts = now()
+      const p = { id: rnd(), kind, ns, device, deviceId, label, ek, ssh, resolve, reject, ts, exp: ts + pendingTtlMs }
+      pending.set(p.id, p)
+      return publicOf(p)
+    },
+    /** Los pedidos vivos, sin la `ek` (no hace falta fuera de aquí). */
+    list () { this.sweep(); return [...pending.values()].map(publicOf) },
+    /** Saca un pedido para resolverlo (aprobar o denegar). `null` si no existe o venció. */
+    take (id) {
+      this.sweep()
+      const p = pending.get(id)
+      if (p) pending.delete(id)
+      return p || null
+    },
+    /** Abre la ventana de ese aparato sobre ese cajón. */
+    grant (ns, device) { const exp = now() + grantTtlMs; grants.set(gkey(ns, device), exp); return exp },
+    /** ¿Sigue abierta la ventana? */
+    has (ns, device) {
+      const exp = grants.get(gkey(ns, device))
+      if (exp == null) return false
+      if (exp <= now()) { grants.delete(gkey(ns, device)); return false }
+      return true
+    },
+    /** Cierra las ventanas de un aparato (al revocarlo, por ejemplo). */
+    forget (device) { for (const k of [...grants.keys()]) if (k.endsWith('|' + device)) grants.delete(k) },
+    /** Tira lo vencido; devuelve los pedidos que vencieron, para anotarlos. */
+    sweep () {
+      const t = now(); const gone = []
+      for (const [id, p] of pending) if (p.exp <= t) { pending.delete(id); gone.push(publicOf(p)); try { p.reject?.(new Error('approval: nobody approved the request in time')) } catch (_) {} }
+      for (const [k, exp] of grants) if (exp <= t) grants.delete(k)
+      return gone
+    }
+  }
+}
+
+export default { createApprovals, PENDING_TTL_MS, GRANT_TTL_MS }

package/src/ctl.js

@@ -27,6 +27,7 @@ import tty from 'node:tty'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
 import { assertVar } from './secretsStore.js'
+import { isValidSecretsNs } from './protocol.js'
 import { parseEnvText, PAIR_RE } from '../lib/src/envtext.js'
 import { qrToString } from './qr.js'
 import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
@@ -127,6 +128,7 @@ function cmdStatus () {
   }
   console.log('  fingerprint : %s', s.fingerprint)
   console.log('  proxy       : %s', s.proxy)
+  if (s.sshAgent) console.log('  ssh-agent   : %s   (dotrino-vault ssh)', s.sshAgent)
   console.log('  pid         : %s%s', s.pid, up ? '' : ' (no responde)')
   console.log('  datos       : %s', dir)
   const profiles = s.profiles || []
@@ -196,6 +198,7 @@ async function cmdPair (args = []) {
     for (const tok of raw.split(',').map((t) => t.trim()).filter(Boolean)) {
       const t = ALIAS[tok] || tok
       if (t === 'admin' || t === 'administra') { console.error('`admin` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +administra'); process.exit(2) }
+      if (t === 'approve' || t === 'aprueba') { console.error('`approve` no se empareja: concédelo desde el PC con  dotrino-vault caps <ID> +aprueba'); process.exit(2) }
       if (t === 'sign' || t === 'read' || t === 'store') { scope.push('vault:' + t); continue }
       const m = /^secrets:([a-z0-9-]{1,32})$/.exec(t)
       if (m) { scope.push('vault:secrets:' + m[1]); continue }
@@ -379,7 +382,7 @@ async function cmdMembers () {
   assertOpen(record)
   if (!record.members?.length) { console.log('Este perfil todavía no tiene acta.'); return }
 
-  const CAP = { sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves', admin: `${B}administra el perfil${Z}` }
+  const CAP = { sign: 'firma', store: 'guarda', read: 'lee', secrets: 'lee sus claves', admin: `${B}administra el perfil${Z}`, approve: `${B}aprueba pedidos${Z}` }
   // El nombre del perfil es una pubkey JWK. Recortarla no la hace legible: la deja
   // pareciendo un error (`{"key_ops":["verify"],"e…`). Se muestra su huella corta, la
   // misma que se enseña al emparejar y en la lista de miembros.
@@ -399,7 +402,7 @@ async function cmdMembers () {
     // se mira quién es quién — y en la lista de variables ya seria tarde.
     if (m.cn && !m.canSeal) console.log('      %ssin llave de cifrado: NO puede leer sus variables%s', R, Z)
   }
-  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra')
+  console.log('\n  Cambiar permisos:  dotrino-vault caps <ID> +firma | -firma | +guarda | -guarda | +lee | -lee | +administra | +aprueba')
   console.log('  «Administra» deja conectar y quitar dispositivos desde ese aparato, sin venir aquí.')
   console.log('  No deja cambiar permisos ni traspasar el mando: eso solo se hace en esta máquina.')
   console.log('  Los servicios solo pueden abrir las claves de su propio nombre; eso no se cambia aquí.\n')
@@ -440,16 +443,42 @@ async function findMember (id) {
   return m
 }
 
+/**
+ * `dotrino-vault ssh` — cómo usar la llave SSH del teléfono desde este PC. La llave
+ * privada no está aquí: el daemon expone un agente SSH y cada firma la aprueba el
+ * teléfono (`caps <ID> +aprueba`). Imprime lo que hay que poner en el shell.
+ */
+async function cmdSsh (args = []) {
+  const s = requireDaemon()
+  if (!s.sshAgent) { console.error('El daemon no tiene el agente SSH activo (DOTRINO_VAULT_SSH_AGENT=0, o Windows).'); process.exit(1) }
+  if (args[0] === 'keys' || args[0] === '-L') {
+    try { execFileSync('ssh-add', ['-L'], { env: { ...process.env, SSH_AUTH_SOCK: s.sshAgent }, stdio: 'inherit' }) } catch (_) { process.exit(1) }
+    return
+  }
+  console.log('# La llave SSH vive en tu teléfono; este PC solo le pide la firma. Pon en tu shell:')
+  console.log('export SSH_AUTH_SOCK=%s', s.sshAgent)
+  console.log('')
+  console.log('# Registra la llave desde el teléfono (vault.dotrino.com → Llave SSH) y pega su línea')
+  console.log('# pública en ~/.ssh/authorized_keys de cada servidor. Para no aprobar cada comando,')
+  console.log('# reusa la conexión 15 min en ~/.ssh/config:')
+  console.log('#   Host *')
+  console.log('#     ControlMaster auto')
+  console.log('#     ControlPath ~/.ssh/cm-%r@%h:%p')
+  console.log('#     ControlPersist 15m')
+  console.log('')
+  console.log('# Ver las llaves registradas:  dotrino-vault ssh keys')
+}
+
 /** `dotrino-vault caps <ID> ±permiso` — cambia lo que puede hacer un dispositivo. */
 async function cmdCaps (args = []) {
   const [id, ...changes] = args
   if (!id || !changes.length) {
-    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra')
+    console.error('uso: dotrino-vault caps <ID> +firma|-firma|+guarda|-guarda|+lee|-lee|+administra|-administra|+aprueba|-aprueba')
     process.exit(2)
   }
   const CAP_BY_WORD = {
-    firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin',
-    sign: 'sign', store: 'store', read: 'read', admin: 'admin'
+    firma: 'sign', guarda: 'store', lee: 'read', administra: 'admin', aprueba: 'approve',
+    sign: 'sign', store: 'store', read: 'read', admin: 'admin', approve: 'approve'
   }
   const s = requireDaemon()
   const m = await findMember(id)
@@ -708,6 +737,7 @@ async function cmdSecret (rest) {
     '     dotrino-vault secret device rm  <ID> <CLAVE>',
     '     dotrino-vault secret list',
     '     dotrino-vault secret migrate                                 SELLA los secretos (una vez)',
+    '     dotrino-vault secret policy <ns> approval on|off              cada lectura espera tu aprobación (teléfono)',
     '',
     'CARGA LA CONFIGURACIÓN DE UN SERVICIO DE UNA VEZ (`set` con varios pares, o `import`):',
     'la bóveda la aplica entera y avisa UNA sola vez. De una en una, cada variable es un',
@@ -818,6 +848,20 @@ async function cmdSecret (rest) {
   }
 
   if (sub === 'migrate') return secretMigrate()
+  // `secret policy <ns> approval on|off`: el cajón pasa a pedir el visto bueno de un
+  // aparato con `aprueba` (el teléfono) en cada lectura, con ventana de 15 min.
+  if (sub === 'policy') {
+    const [ns, what, val] = args
+    if (!isValidSecretsNs(ns || '') || what !== 'approval' || !['on', 'off'].includes(val)) {
+      console.error('uso: dotrino-vault secret policy <ns> approval on|off'); process.exit(2)
+    }
+    writeReq('secret-request.json', { op: 'policy', ns, approval: val === 'on' })
+    sendSignal(s.pid, 'SIGUSR2')
+    console.log(val === 'on'
+      ? `Listo: cada lectura de «${ns}» esperará la aprobación de un aparato con  caps <ID> +aprueba  (ventana de 15 min).`
+      : `Listo: «${ns}» vuelve a entregarse sin aprobación.`)
+    return
+  }
 
   // --- VER un valor, su histórico y volver atrás ---------------------------------
   // Las tres van juntas porque son la misma idea: ver es lo único que la contraseña
@@ -1291,6 +1335,7 @@ export async function runCtl (argv) {
     case 'caps': return cmdCaps(rest)
     case 'revoke': return cmdRevoke(rest[0])
     case 'secret': return cmdSecret(rest)
+    case 'ssh': return cmdSsh(rest)
     case 'activity': return cmdActivity(Number(rest[0]) || 30)
     case 'logs': return cmdLogs()
     case 'version':

package/src/daemon.js

@@ -17,6 +17,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { startVaultManager } from './manager.js'
+import { startSshAgent, defaultSocketPath } from './sshAgent.js'
 import { dataDir, writeJson, readJson } from './paths.js'
 import { VERSION } from './version.js'
 
@@ -63,6 +64,14 @@ export async function runDaemon () {
 
   const mgr = await startVaultManager({ root: dir, proxyUrl, onEnrollChallenge })
 
+  // --- agente SSH (la llave vive en el teléfono; ver sshAgent.js). `DOTRINO_VAULT_SSH_AGENT=0`
+  // lo apaga; cualquier otro valor es la ruta del socket.
+  let sshAgent = null
+  if (process.env.DOTRINO_VAULT_SSH_AGENT !== '0' && process.platform !== 'win32') {
+    const socketPath = process.env.DOTRINO_VAULT_SSH_AGENT || defaultSocketPath(dir)
+    try { sshAgent = startSshAgent({ socketPath, vault: () => mgr.current(), log: console.log }) } catch (e) { console.error('[vault] ssh-agent could not start: %s', e.message) }
+  }
+
   // --- state.json ---
   const stateFile = path.join(dir, 'state.json')
   const daemonVersion = VERSION
@@ -73,7 +82,7 @@ export async function runDaemon () {
     const cur = mgr.summary().find((p) => p.current) || {}
     writeJson(stateFile, {
       v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
-      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
+      proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(), sshAgent: sshAgent?.socketPath || null,
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -146,7 +155,8 @@ export async function runDaemon () {
       // PERMISOS, no tipos (2026-08-22): el cert lleva lo que pidió `pair --scope`, y si
       // no pidió nada, el juego de siempre. `--service <ns>` sigue siendo el atajo de
       // `vault:secrets:<ns>`. Se valida aquí porque es la maestra la que firma: nada
-      // que no esté en esta lista entra en un cert, y `vault:admin` nunca por este camino.
+      // que no esté en esta lista entra en un cert, y `vault:admin` / `vault:approve` nunca
+      // por este camino (se conceden a mano con `caps`).
       const ALLOWED = (x) => x === 'vault:sign' || x === 'vault:read' || x === 'vault:store' || /^vault:secrets:[a-z0-9-]{1,32}$/.test(x)
       const asked = Array.isArray(pairReq?.scope) ? pairReq.scope.filter((x) => typeof x === 'string') : null
       if (asked && asked.some((x) => !ALLOWED(x))) {
@@ -396,6 +406,7 @@ export async function runDaemon () {
             console.log('[vault] %d secret(s) applied in one go: %s', changed.length, sec.pub ? 'device' : sec.ns)
           } else if (sec.op === 'set') { await vault.setSecret(sec.ns, sec.key, sec.value, sec.public); console.log('[vault] secret saved: %s/%s', sec.ns, sec.key) }
           else if (sec.op === 'rm') { await vault.deleteSecret(sec.ns, sec.key); console.log('[vault] secret deleted: %s/%s', sec.ns, sec.key) }
+          else if (sec.op === 'policy') { const r = await vault.setSecretPolicy(sec.ns, { approval: !!sec.approval }); console.log('[vault] %s: approval %s', sec.ns, r.approval ? 'REQUIRED (15 min window)' : 'off') }
           else if (sec.op === 'dev-set') { await vault.setDeviceSecret(sec.pub, sec.key, sec.value, sec.public); console.log('[vault] device secret saved: %s', sec.key) }
           else if (sec.op === 'dev-rm') { await vault.deleteDeviceSecret(sec.pub, sec.key); console.log('[vault] device secret deleted: %s', sec.key) }
           // Saldar lo que quedó a deber: heredarle a un aparato nuevo lo ya guardado y
@@ -605,6 +616,7 @@ export async function runDaemon () {
   const shutdown = (sig) => {
     console.log(`\n[vault] ${sig} → deteniendo…`)
     rm(pairFile); rm(pendingEnrollFile)
+    try { sshAgent?.close() } catch (_) {}
     try { mgr.close() } catch (_) {}
     process.exit(0)
   }

package/src/secretsStore.js

@@ -159,6 +159,11 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
   if (!data) data = { schemaVersion: SCHEMA_VERSION, ns: {}, dev: {}, recovery: null, history: [] }
   if (!data.dev) data.dev = {}
   if (!data.history) data.history = []
+  // 0.47.0/0.48.0 guardaron la política DENTRO del cajón; se saca a `policies` al abrir.
+  for (const [ns, bag] of Object.entries(data.ns || {})) {
+    const stray = bag?.policy && typeof bag.policy === 'object' && !('v' in bag.policy) ? bag.policy : null
+    if (stray) { delete bag.policy; if (stray.approval) { if (!data.policies) data.policies = {}; data.policies[ns] = { approval: true } } }
+  }
 
   // v3 → v5 y v4 → v5 NO se hacen al abrir, y es deliberado: el daemon tiene que poder
   // arrancar y SERVIR sin nada (un perfil bloqueado sigue atendiendo a sus agentes). Un
@@ -588,6 +593,30 @@ export function openSecretsStore (dir, { sealer = null, recipients = null, signe
       for (const ns of Object.keys(data.ns)) out[ns] = names(data.ns, ns)
       return out
     },
+    /**
+     * POLÍTICA de un cajón. Hoy una sola: `approval` — cada lectura espera el visto bueno
+     * de un aparato con `approve` (ver `approvals.js`). Los cajones de los servicios que
+     * corren solos (proxio, geo) van sin ella: no pueden esperar a un teléfono.
+     *
+     * Vive APARTE de las variables (`data.policies`), no dentro del cajón: en el formato
+     * v3 el cajón ES el mapa de variables y cualquier cosa que se meta ahí se reparte como
+     * si fuera una (pasó: `policy` salió en la lista y en el bundle).
+     */
+    policyOf (ns) { assertNs(ns); return { approval: !!data.policies?.[ns]?.approval } },
+    setPolicy (ns, patch) {
+      assertNs(ns)
+      if (!data.policies) data.policies = {}
+      data.policies[ns] = { ...(data.policies[ns] || {}), ...patch }
+      if (!data.policies[ns].approval) delete data.policies[ns]
+      save()
+      return this.policyOf(ns)
+    },
+    /** Solo los cajones con alguna política puesta (ns → política). */
+    policies () {
+      const out = {}
+      for (const [ns, p] of Object.entries(data.policies || {})) if (p?.approval) out[ns] = { approval: true }
+      return out
+    },
     /** Nombres y visibilidad (pub → [{key, public}]), sin valores. */
     listDevices () {
       const out = {}

package/src/sshAgent.js

@@ -0,0 +1,2 @@
+export * from '../lib/src/sshAgent.js'
+export { default } from '../lib/src/sshAgent.js'

package/src/sshKeys.js

@@ -0,0 +1,2 @@
+export * from '../lib/src/sshKeys.js'
+export { default } from '../lib/src/sshKeys.js'

package/src/tui/app.js

@@ -36,6 +36,7 @@ import { createTerm, widthOf } from './term.js'
 import { qrToString } from '../qr.js'
 import { dict, otherLang, loadLang, saveLang } from './i18n.js'
 import * as vc from '../vaultControl.js'
+import { VERSION } from '../version.js'
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
 
@@ -1465,7 +1466,10 @@ function render (term, st) {
   const ap = activeProfile(st)
   const apTxt = ap ? `${t.accent('●')} ${t.bold(ap.name || i.noName)} ${lockGlyph(ap)} ${t.muted('· ' + (ap.fingerprint || '—'))}` : t.muted('—')
   lines[1] = ' ' + i.activeVault + apTxt
-  lines[2] = ''
+  // El .deb instala el binario pero NO reinicia el servicio (y si se reinicia ANTES de
+  // instalar, peor: el daemon se queda con el binario viejo, ya borrado, y hay dos copias
+  // en RAM). `status` ya lo avisa; aquí también, que es donde uno se queda mirando.
+  lines[2] = (up && s?.version && VERSION !== 'dev' && s.version !== VERSION) ? ' ' + t.warn(i.daemonStale(s.version, VERSION)) : ''
   // Dispositivos/Scopes son pestañas de la bóveda activa (se entra desde Bóvedas);
   // el resto muestra su título simple.
   lines[3] = INNER_TABS.includes(st.screen) ? ' ' + renderTabs(st, t) : ' ' + t.title('» ' + title(i, st.screen))

package/src/tui/i18n.js

@@ -26,6 +26,7 @@ const es = {
   // encabezado / estado
   daemonRunning: 'corriendo',
   daemonStopped: 'DETENIDO',
+  daemonStale: (running, installed) => `⚠ el servicio corre ${running} y el binario instalado es ${installed}: reinícialo (systemctl --user restart dotrino-vault)`,
   activeVault: 'Bóveda activa: ',
   noName: '(sin nombre)',
   tooSmall: 'Terminal muy pequeño',
@@ -324,6 +325,7 @@ const en = {
 
   daemonRunning: 'running',
   daemonStopped: 'STOPPED',
+  daemonStale: (running, installed) => `⚠ the service runs ${running} but the installed binary is ${installed}: restart it (systemctl --user restart dotrino-vault)`,
   activeVault: 'Active vault: ',
   tooSmall: 'Terminal too small',
   tooSmallHint: (cols, rows) => `Resize to ≥ 24×9 (now ${cols}×${rows}).`,

package/src/vault.js

@@ -22,6 +22,8 @@ import { createTransport, masterPubkeyOf } from './transport.js'
 import { openStore } from './store.js'
 import { openThreadStore, STORE_READ_METHODS, PROFILE_EDIT_METHODS } from './threadStore.js'
 import { openSecretsStore, assertVar } from './secretsStore.js'
+import { createApprovals } from './approvals.js'
+import { parsePublicKey, sshSignature } from './sshKeys.js'
 import { makeSealer } from './sealer.js'
 import { openSealKeys } from './sealKey.js'
 import { seal } from '../lib/src/sealed.js'
@@ -69,6 +71,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
 
   const store = openStore(dir)
   const threads = openThreadStore(dir)
+  const approvals = createApprovals()
+  const approvalsSweeper = setInterval(() => { for (const g of approvals.sweep()) audit(g.kind === 'ssh' ? 'ssh.expired' : 'secrets.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
@@ -485,6 +489,8 @@ 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', 'ssh.keys', 'ssh.key.add', 'ssh.key.rm'].includes(p.data?.op)) return handleApproval(from, p)
+    if (p.data?.op === 'ssh.sign' || p.data?.op === 'ssh.keys.public') return handleSshRemote(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)' })
@@ -501,29 +507,202 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       audit('rejected', { what: 'secrets', ns, reason: 'cn' })
       return reply(from, { type: MSG.ERROR, error: `unauthorized: cn — the record does not recognise this member as the "${ns}" service` })
     }
-    let enc
-    try {
-      // Mientras el archivo siga en v3 el cable NO cambia: se mandan los valores como
-      // siempre. Solo tras la migración viajan sobres, y entonces quien los abre es el
-      // agente con su llave. Así el despliegue del daemon se deshace con un reinicio,
-      // porque hasta el primer desbloqueo no ha cambiado nada de lo que ve nadie.
-      const b = secrets.bundleFor(ns, chk.device)
-      // EL ACTA VIAJA CON EL BUNDLE (§8.8): es lo que le permite al agente comprobar que
-      // los sobres los selló esta bóveda, y con qué llave —la que el acta nombra para el
-      // `seq` con el que se firmaron—. No es un dato secreto: el acta es pública dentro
-      // del perfil y el agente ya es miembro. Sin ella podría abrir igual, pero no sabría
-      // de dónde salió lo que abre.
-      const payload = b.legacy
-        ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])) }
-        : { sealed: b, acta: record || null }
-      enc = await seal({ ek: p.data.ek, payload })
-    } catch (e) {
+    // APROBACIÓN POR USO: si el cajón la exige y este aparato no tiene la ventana abierta,
+    // el pedido se apunta, se avisa a quien aprueba y se contesta «pendiente». La respuesta
+    // de verdad sale cuando el teléfono firme (`handleApproval`), sellada a la misma `ek`.
+    if (secrets.policyOf(ns).approval && !approvals.has(ns, chk.device)) {
+      const deviceId = await deviceIdOf(chk.device).catch(() => null)
+      const label = (record?.members || []).find((m) => m.pub === chk.device)?.label || ''
+      const pend = approvals.request({ ns, device: chk.device, deviceId, label, ek: p.data.ek })
+      audit('secrets.pending', { device: deviceId, ns, id: pend.id })
+      log(`[vault] ${ns}: ${deviceId || '????-????'} is waiting for approval (${pend.id})`)
+      const body = { op: 'secrets.pending', ns, id: pend.id, exp: pend.exp, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+      await notifyApprovers(pend, record)
+      return
+    }
+    let res
+    try { res = await resultFor(ns, chk.device, p.data.ek, record) } catch (e) {
       return reply(from, { type: MSG.ERROR, error: 'secrets: invalid ek' })
     }
+    audit('secrets', { device: await deviceIdOf(chk.device), ns })
+    reply(from, { type: MSG.SECRETS_RESULT, ...res })
+  }
+
+  /** El bundle de `ns` para `devicePub`, sellado a su `ek` y firmado por la maestra. */
+  async function resultFor (ns, devicePub, ek, record) {
+    // Mientras el archivo siga en v3 el cable NO cambia: se mandan los valores como
+    // siempre. Solo tras la migración viajan sobres, y entonces quien los abre es el
+    // agente con su llave. Así el despliegue del daemon se deshace con un reinicio,
+    // porque hasta el primer desbloqueo no ha cambiado nada de lo que ve nadie.
+    const b = secrets.bundleFor(ns, devicePub)
+    // EL ACTA VIAJA CON EL BUNDLE (§8.8): es lo que le permite al agente comprobar que
+    // los sobres los selló esta bóveda, y con qué llave —la que el acta nombra para el
+    // `seq` con el que se firmaron—. No es un dato secreto: el acta es pública dentro
+    // del perfil y el agente ya es miembro. Sin ella podría abrir igual, pero no sabría
+    // de dónde salió lo que abre.
+    const payload = b.legacy
+      ? { secrets: Object.fromEntries(Object.entries(b.entries).map(([k, e]) => [k, e.v])) }
+      : { sealed: b, acta: record || null }
+    const enc = await seal({ ek, payload })
     const body = { op: 'secrets.result', ns, enc, ts: Date.now() }
     const { signature } = await identity.signData(body)
-    audit('secrets', { device: await deviceIdOf(chk.device), ns })
-    reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+    return { body, signature }
+  }
+
+  // ---------- LLAVES SSH DEL TELÉFONO (`sshKeys.js`) ----------
+  // Aquí solo viven las PÚBLICAS: la privada está en el aparato que aprueba. `ssh` en este
+  // PC habla con el agente del daemon (`sshAgent.js`), y cada firma es un pedido más.
+  const sshKeysFile = path.join(dir, 'ssh-keys.json')
+  const atRest = atRestFor(dir)
+  const readSshKeys = () => { const d = readJsonAt(sshKeysFile); return Array.isArray(d?.keys) ? d.keys : [] }
+  function readJsonAt (file) { try { return JSON.parse(atRest.decrypt(fs.readFileSync(file, 'utf8'))) } catch (_) { return null } }
+  const writeSshKeys = (keys) => fs.writeFileSync(sshKeysFile, atRest.encrypt(JSON.stringify({ v: 1, keys })), { mode: 0o600 })
+  const sshKeys = () => readSshKeys().map((k) => ({ id: k.id, type: k.type, blob: k.blob, comment: k.comment, deviceId: k.deviceId, addedAt: k.addedAt }))
+
+  /**
+   * FIRMAR UN RETO SSH: lo pide el agente local (el `ssh` del usuario) y lo resuelve el
+   * teléfono. No hay ventana: cada conexión es un «sí» — para no repetirlo veinte veces
+   * está `ControlMaster` en el `ssh_config`, que reusa la conexión 15 min.
+   */
+  function requestSshSign ({ keyId, data, askedBy = null, onPending = null }) {
+    const key = readSshKeys().find((k) => k.id === keyId)
+    if (!key) return Promise.reject(new Error('ssh: unknown key'))
+    return new Promise((resolve, reject) => {
+      const pend = approvals.request({
+        kind: 'ssh', ns: 'ssh', deviceId: askedBy || (fp.slice(0, 4).toUpperCase() + '-' + fp.slice(4, 8).toUpperCase()), label: 'ssh',
+        ssh: { key: key.id, comment: key.comment, data: Buffer.from(data).toString('base64') },
+        resolve, reject
+      })
+      try { onPending?.(pend) } catch (_) {}
+      audit('ssh.pending', { key: key.id, id: pend.id, device: askedBy || null })
+      log(`[vault] ssh: ${key.comment || key.id} is waiting for the phone to sign (${pend.id})`)
+      identity.profileActa?.().catch(() => null).then((r) => notifyApprovers(pend, r?.acta))
+    })
+  }
+
+  /**
+   * AGENTE SSH DELGADO en otra máquina (`dotrino-env ssh-agent`): un aparato con `vault:sign`
+   * pide que un reto se firme con una llave del teléfono. No hay nada que proteger en el
+   * que pide: solo convierte el reto en un pedido; quien firma es el teléfono.
+   */
+  async function handleSshRemote (from, p) {
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: SCOPE.SIGN, trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'ssh')
+    const answer = async (body) => {
+      body = { ...body, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+    }
+    if (p.data.op === 'ssh.keys.public') return answer({ op: 'ssh.keys.public', items: sshKeys().map((k) => ({ id: k.id, blob: k.blob, comment: k.comment })) })
+    const key = readSshKeys().find((k) => k.id === p.data.key)
+    if (!key || typeof p.data.data !== 'string') return reply(from, { type: MSG.ERROR, error: 'ssh: unknown key' })
+    const asker = await deviceIdOf(chk.device).catch(() => null)
+    let pendId = null
+    const done = requestSshSign({ keyId: key.id, data: Buffer.from(p.data.data, 'base64'), askedBy: asker, onPending: (pend) => { pendId = pend.id } })
+    await answer({ op: 'ssh.pending', id: pendId, exp: Date.now() + 5 * 60 * 1000 })
+    try {
+      const sig = await done
+      await answer({ op: 'ssh.sign.result', sig: Buffer.from(sig).toString('base64') })
+    } catch (e) { reply(from, { type: MSG.ERROR, error: e.message }) }
+  }
+
+  /**
+   * PEDIDOS DE APROBACIÓN (cajones con `approval`). Entran por `vault.secrets` con
+   * `op: approvals | approve | deny`, firmados por un aparato con `vault:approve` — que,
+   * como `admin`, no se empareja: se concede a mano (`caps <ID> +aprueba`). El acta tiene
+   * que decirlo también, para que quitar el permiso surta efecto en el acto.
+   */
+  async function handleApproval (from, p) {
+    const op = p.data?.op
+    const chk = await verifyChain({
+      data: p.data, signature: p.signature, cert: p.cert,
+      expectedScope: SCOPE.APPROVE, trustedIssuer: master, revoked: await revocationSet()
+    })
+    if (!chk.ok) return denyChain(from, chk, p, 'approval')
+    const record = (await identity.profileActa?.().catch(() => null))?.acta
+    if (record && !Acta.memberCan(record, chk.device, 'approve')) {
+      audit('rejected', { what: 'approval', reason: 'acta' })
+      return reply(from, { type: MSG.ERROR, error: 'unauthorized: acta — this member does not approve' })
+    }
+    const by = await deviceIdOf(chk.device).catch(() => null)
+    const answer = async (body) => {
+      body = { ...body, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      reply(from, { type: MSG.SECRETS_RESULT, body, signature })
+    }
+    if (op === 'approvals') return answer({ op: 'approvals', items: approvals.list() })
+    if (op === 'ssh.keys') return answer({ op: 'ssh.keys', items: sshKeys() })
+    if (op === 'ssh.key.add') {
+      let k
+      try { k = parsePublicKey(p.data?.pub) } catch (e) { return reply(from, { type: MSG.ERROR, error: e.message }) }
+      const keys = readSshKeys().filter((x) => x.id !== k.id)
+      keys.push({ ...k, deviceId: by, addedAt: Date.now() })
+      writeSshKeys(keys)
+      audit('ssh.key.add', { key: k.id, by })
+      log(`[vault] ssh: key ${k.id} (${k.comment || 'no comment'}) registered by ${by}`)
+      return answer({ op: 'ssh.key.add', id: k.id, ok: true })
+    }
+    if (op === 'ssh.key.rm') {
+      const keys = readSshKeys(); const n = keys.length
+      writeSshKeys(keys.filter((x) => x.id !== p.data?.id))
+      if (keys.length !== n) audit('ssh.key.rm', { key: p.data?.id, by })
+      return answer({ op: 'ssh.key.rm', ok: true })
+    }
+    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' })
+    if (pend.kind === 'ssh') {
+      if (op === 'deny') {
+        audit('ssh.denied', { key: pend.ssh.key, id, by })
+        try { pend.reject?.(new Error('ssh: denied from ' + by)) } catch (_) {}
+        return answer({ op: 'deny.result', id, ok: true })
+      }
+      if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
+      const key = readSshKeys().find((k) => k.id === pend.ssh.key)
+      let blob
+      try { blob = sshSignature({ jwk: key.jwk, data: Buffer.from(pend.ssh.data, 'base64'), rawSig: p.data?.sig }) } catch (e) {
+        try { pend.reject?.(e) } catch (_) {}
+        audit('rejected', { what: 'ssh.sign', reason: e.message })
+        return reply(from, { type: MSG.ERROR, error: e.message })
+      }
+      audit('ssh.signed', { key: key.id, id, by })
+      log(`[vault] ssh: ${key.comment || key.id} signed by ${by}`)
+      try { pend.resolve?.(blob) } catch (_) {}
+      return answer({ op: 'approve.result', id, ok: true })
+    }
+    if (op === 'deny') {
+      audit('secrets.denied', { device: pend.deviceId, ns: pend.ns, id, by })
+      log(`[vault] ${pend.ns}: request of ${pend.deviceId} DENIED by ${by}`)
+      try { client.sendByPubkey(pend.device, { type: MSG.ERROR, error: `unauthorized: denied — the "${pend.ns}" request was denied from ${by}` }) } catch (_) {}
+      return answer({ op: 'deny.result', id, ok: true })
+    }
+    if (op !== 'approve') return reply(from, { type: MSG.ERROR, error: 'approval: unknown op' })
+    const exp = approvals.grant(pend.ns, pend.device)
+    let res
+    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, until: exp })
+    log(`[vault] ${pend.ns}: request of ${pend.deviceId} approved by ${by} (window until ${new Date(exp).toISOString()})`)
+    // Va por `sendByPubkey`: si el que pedía ya no está conectado, lo recoge al volver.
+    try { client.sendByPubkey(pend.device, { type: MSG.SECRETS_RESULT, ...res }) } catch (_) {}
+    return answer({ op: 'approve.result', id, ok: true, exp })
+  }
+
+  /** Aviso a los aparatos que aprueban (cola del proxio → push nativo si están apagados). */
+  async function notifyApprovers (pend, record) {
+    try {
+      const body = { ev: 'approval', id: pend.id, ns: pend.ns, deviceId: pend.deviceId, label: pend.label, exp: pend.exp, ts: Date.now() }
+      const { signature } = await identity.signData(body)
+      const who = (record?.members || []).filter((m) => Acta.memberCan(record, m.pub, 'approve')).map((m) => m.pub)
+      if (!who.length) log(`[vault] ${pend.ns}: nobody can approve (grant it with: dotrino-vault caps <ID> +aprueba)`)
+      for (const pub of who) { try { client.sendByPubkey(pub, { type: MSG.ADMIN_EVENT, body, signature }) } catch (_) {} }
+    } catch (e) { log('[vault] could not notify approvers:', e.message) }
   }
 
   client.on('message', async (from, payload) => {
@@ -1438,6 +1617,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     startPairing: desk.startPairing,
     stopPairing: desk.stopPairing,
     listPending: desk.listPending,
+    // Cajones con aprobación por uso (`approvals.js`).
+    secretPolicy: (ns) => secrets.policyOf(ns),
+    setSecretPolicy: async (ns, patch) => { const r = secrets.setPolicy(ns, patch); audit('secret.policy', { ns, ...r }); return r },
+    secretPolicies: () => secrets.policies(),
+    listApprovals: () => approvals.list(),
+    sshKeys,
+    requestSshSign,
     // 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) => {
@@ -1537,6 +1723,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
       return r
     },
     close () {
+      clearInterval(approvalsSweeper)
       for (const t of pendingNotices.values()) clearTimeout(t)
       pendingNotices.clear()
       try { client.close() } catch (_) {} identity.destroy()