@dotrino/vaultd 0.52.0 → 0.53.0

package/README.md

@@ -456,18 +456,25 @@ y así un reinicio del PC nunca deja tus apps muertas esperando a que alguien te
 ```sh
 dotrino-vault profile password     # pone o cambia la contraseña (te la pregunta)
 dotrino-vault profile password rm  # la quita
-dotrino-vault unlock               # abre la bóveda en esta consola
-dotrino-vault lock                 # vuelve a cerrarla
+dotrino-vault unlock               # abre la bóveda en esta consola (5 min sin usarse y se cierra sola)
+dotrino-vault lock                 # vuelve a cerrarla ya
 ```
 
 Lo único que se sigue viendo con el candado puesto es que **existe** y que está cerrada
 (`status`, `profile ls`): si no, no habría forma de saber qué abrir.
 
-El perfil se vuelve a bloquear al reiniciar el servicio. La contraseña **no se
-guarda**: solo un verificador con sal (PBKDF2), igual que el candado del navegador.
-Tiene un mínimo de 4 caracteres y, tras 5 intentos fallidos, cada intento nuevo
-espera cada vez más (hasta 5 minutos); la cuenta de fallos se guarda, así que
-reiniciar no la borra.
+**Se vuelve a cerrar solo a los 5 minutos sin usarse**, además de al reiniciar el
+servicio o con `dotrino-vault lock`. El plazo se cuenta desde la última cosa que hiciste
+en la consola, no desde que la abriste: mientras trabajas no te echa, y en cuanto te
+levantas de la silla se cierra. Lo que piden tus aparatos por el proxy **no** cuenta como
+uso —el candado no es suyo—, así que siguen funcionando igual mientras la consola se
+cierra. La TUI, además, **olvida la contraseña** en ese momento: si no, la reabriría sola
+a la siguiente tecla.
+
+La contraseña **no se guarda**: solo un verificador con sal (scrypt), igual que el
+candado del navegador. Tiene un mínimo de 12 caracteres —varias palabras al azar— y,
+tras 5 intentos fallidos, cada intento nuevo espera cada vez más (hasta 5 minutos); la
+cuenta de fallos se guarda, así que reiniciar no la borra.
 
 Con el perfil bloqueado, la CLI **no** te pide la contraseña sobre la marcha: cualquier
 comando que mire o toque esa bóveda falla con «perfil bloqueado» y hay que correr

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.52.0",
+  "version": "0.53.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/ctl.js

@@ -1141,8 +1141,13 @@ function askText (prompt) {
 
 async function cmdUnlock () {
   const pwd = await askPassword('Contraseña del perfil: ')
-  reportProfiles(await profileRequest('unlock', { password: pwd }))
-  console.log('Ya puedes editar el perfil. Se vuelve a bloquear al reiniciar el servicio (o con: dotrino-vault lock).')
+  // El daemon devuelve cuánto aguanta abierto: se dice AQUÍ, al abrirlo, que es cuando
+  // sirve de algo. Encontrárselo cerrado sin haberlo leído nunca parece una avería.
+  const out = await profileRequest('unlock', { password: pwd })
+  reportProfiles(out)
+  const min = Math.max(1, Math.round((out?.autoLockMs || 5 * 60 * 1000) / 60000))
+  console.log(`Ya puedes editar el perfil. Se vuelve a bloquear solo tras ${min} min sin usarse` +
+    ' (o al reiniciar el servicio, o con: dotrino-vault lock).')
 }
 
 async function cmdLock () {
@@ -1231,7 +1236,8 @@ dispositivos siguen firmando y leyendo aunque esté bloqueado):
   profile password [set]            pone o cambia la contraseña
   profile password rm               la quita
   unlock                            desbloquea para poder editar
-  lock                              vuelve a bloquear (también al reiniciar el servicio)
+  lock                              vuelve a bloquear (también solo, a los 5 min sin
+                                    usarse, y al reiniciar el servicio)
 
 Arrancar y parar, según dónde corra:
   Linux (servicio)  systemctl --user {start,stop,restart} dotrino-vault

package/src/daemon.js

@@ -74,6 +74,9 @@ export async function runDaemon () {
     writeJson(stateFile, {
       v: 2, version: daemonVersion, fingerprint: cur.fingerprint || null, iss: cur.iss || null,
       proxy: proxyUrl, pid: process.pid, startedAt: new Date().toISOString(),
+      // Cuánto aguanta abierto el candado sin usarse. Va en la foto para que la consola
+      // pueda DECIRLO en vez de llevar su propio número (que se desincronizaría).
+      autoLockMs: mgr.profiles.autoLockMs,
       current: mgr.currentId(), profiles: mgr.summary()
     })
   }
@@ -105,7 +108,14 @@ export async function runDaemon () {
   const resolveTarget = (req) => {
     try {
       const id = req?.profile ? mgr.resolve(req.profile) : mgr.currentId()
-      return { id, vault: mgr.get(id), locked: mgr.profiles.isLocked(id) }
+      const locked = mgr.profiles.isLocked(id)
+      // ESTO CUENTA COMO USO: el candado se cierra solo a los 5 min de no usarse
+      // (`profiles.js`), y quien lo usa es esta consola. Va aquí y no en cada `case`
+      // porque toda petición de la CLI/TUI pasa por este punto, y así ninguna se olvida.
+      // Lo que un aparato pida por el proxy NO pasa por aquí, que es justo lo que se
+      // quiere: el candado no es suyo y no debe alargarlo.
+      if (!locked) mgr.profiles.touch(id)
+      return { id, vault: mgr.get(id), locked }
     } catch (e) { console.error('[vault] invalid profile in the request:', e.message); return null }
   }
   /** La bóveda destino, o `null` si el perfil está bloqueado (la petición no se atiende). */
@@ -247,8 +257,24 @@ export async function runDaemon () {
     if (r?.rekeyed) console.log('[vault] secrets master re-sealed (%d drawer(s))', r.drawers)
   }
 
+  /**
+   * BORRA la llave derivada en cuanto se usó. Es lo único de la contraseña que se puede
+   * borrar de verdad: un `string` de JS no se puede pisar (lo copia y lo mueve el motor
+   * hasta que pase el recolector), pero un `Uint8Array` sí, y es el que lleva el material
+   * con el que se abre la copia maestra. Vale lo que vale — no hace milagros con un
+   * volcado de memoria tomado en el instante justo —, pero acorta la ventana de horas a
+   * milisegundos, que es la diferencia entre «estaba ahí» y «estuvo».
+   */
+  const wipe = (k) => { try { if (k instanceof Uint8Array) k.fill(0) } catch (_) {} }
+
   async function handleProfileRequest (req) {
-    const ref = () => mgr.resolve(req.profile || mgr.currentId())
+    // Resolver el destino de una orden de perfil CUENTA COMO USO: estira el plazo del
+    // bloqueo automático igual que cualquier otra cosa que se haga desde la consola.
+    const ref = () => {
+      const id = mgr.resolve(req.profile || mgr.currentId())
+      mgr.profiles.touch(id)
+      return id
+    }
     switch (req.op) {
       case 'list': return {} // el volcado de perfiles ya se hace abajo
       // `id`: quien la crea necesita saber CUÁL quedó, no adivinar por nombre (dos
@@ -266,8 +292,9 @@ export async function runDaemon () {
         const id = ref()
         await mgr.profiles.unlock(id, req.password)
         let note = ''
+        let ak = null
         try {
-          const ak = await mgr.profiles.adminKey(id, req.password)
+          ak = await mgr.profiles.adminKey(id, req.password)
           // REHACER el llavero, no solo saldar: con la frase delante se puede dejar cada
           // cajón envuelto para exactamente quien dice el acta — creando lo que falta,
           // reemplazando lo que alguien metiera mal y quitando lo que sobre.
@@ -277,7 +304,8 @@ export async function runDaemon () {
           if (r?.dropped) note = ` · llavero al día (${r.dropped} envoltura(s) de más retirada(s))`
           else if (r?.wrapped) note = ' · llavero al día'
         } catch (e) { console.error('[vault] could not rebuild the keyring on unlock:', e.message) }
-        return { done: 'perfil desbloqueado' + note }
+        finally { wipe(ak) }
+        return { done: 'perfil desbloqueado' + note, autoLockMs: mgr.profiles.autoLockMs }
       }
       case 'lock': { mgr.profiles.lock(ref()); return { done: 'perfil bloqueado' } }
       // PONER contraseña: los secretos pasan de abrirse con la llave de la máquina a
@@ -291,7 +319,7 @@ export async function runDaemon () {
         const vieja = tenia ? await mgr.profiles.adminKey(id, req.current) : null
         await mgr.profiles.setPassword(id, req.password)
         const nueva = await mgr.profiles.adminKey(id, req.password)
-        await rekey(id, vieja, nueva)
+        try { await rekey(id, vieja, nueva) } finally { wipe(vieja); wipe(nueva) }
         return { done: 'contraseña guardada' }
       }
       // QUITARLA: al revés. Se abre la copia maestra con la frase y se vuelve a cerrar
@@ -301,7 +329,7 @@ export async function runDaemon () {
         const id = ref()
         if (!req.password) throw new Error('removing the password needs the current one: the secrets must be re-sealed before it goes')
         const vieja = await mgr.profiles.adminKey(id, req.password)
-        await rekey(id, vieja, null)
+        try { await rekey(id, vieja, null) } finally { wipe(vieja) }
         mgr.profiles.removePassword(id)
         return { done: 'contraseña quitada · los secretos ahora se abren con la llave de esta máquina' }
       }
@@ -373,6 +401,7 @@ export async function runDaemon () {
       if (sec?.op) {
         rm(secretReqFile) // puede llevar la contraseña: fuera del disco cuanto antes
         lastSecretError = null
+        let ak // fuera del try para poder BORRARLA pase lo que pase (ver `wipe`)
         try {
           const vault = targetOf(sec)
           // Carga en GRUPO (`secret set ns K=v K2=v2`, `secret import`): todas las
@@ -384,7 +413,7 @@ export async function runDaemon () {
           // convertir el archivo, rotar re-cifrando—: escribir no (§8.1). Sin ella se cae
           // a la llave de la máquina, que es la protección de antes de esto (y el vault lo
           // avisa al arrancar).
-          const ak = sec.password ? await mgr.profiles.adminKey(sec.profile ? mgr.resolve(sec.profile) : mgr.currentId(), sec.password) : undefined
+          ak = sec.password ? await mgr.profiles.adminKey(sec.profile ? mgr.resolve(sec.profile) : mgr.currentId(), sec.password) : undefined
           if (sec.op === 'migrate') {
             // Sin lista a mano: la pone el vault, y es la MISMA que usa cualquier
             // escritura (servicios del cajón + aparatos que administran). Con una lista
@@ -440,7 +469,7 @@ export async function runDaemon () {
             code: e.code || (/wrong password/i.test(e.message) ? 'WRONG_PASSWORD' : 'SECRET_FAILED')
           }
           console.error('[vault] secret failed:', e.message)
-        }
+        } finally { wipe(ak) }
       }
       // Perfiles / candado.
       const preq = readJsonSafe(profileReqFile)

package/src/manager.js

@@ -35,14 +35,20 @@ export function assertCanRemove ({ isMaster, memberCount, name = '' }) {
   throw e
 }
 
-export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge } = {}) {
+export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, autoLockMs } = {}) {
   ensureDir(root)
   // El keypair de transporte del proxy-client es del PROCESO, no de la identidad:
   // se instala apuntando a la RAÍZ (no al dir de un perfil) para que los perfiles
   // no se peleen por el archivo ni se lo lleven al borrarse.
   installNodeGlobals(root)
 
-  const profiles = openProfiles(root)
+  const profiles = openProfiles(root, {
+    ...(autoLockMs === undefined ? {} : { autoLockMs }),
+    // Que se cierre solo tiene que VERSE: si no, quien vuelve y encuentra la consola
+    // pidiendo la contraseña otra vez cree que algo se rompió.
+    onAutoLock: (id) => log('[vault] profile %s locked itself after %d min idle (the console; devices keep working)',
+      id, Math.round(profiles.autoLockMs / 60000))
+  })
   const migrated = profiles.migrate()
   if (migrated?.migrated) log('[vault] identidad mono-perfil migrada al perfil %s', migrated.id)
 

package/src/profiles.js

@@ -52,6 +52,25 @@ const PWD_MIN = 12
  */
 const TRIES_FORGET_MS = 15 * 60 * 1000
 
+/**
+ * BLOQUEO AUTOMÁTICO. Cuánto aguanta abierto el candado sin que nadie lo use.
+ *
+ * Abrir la bóveda dejaba la consola abierta hasta que alguien la cerraba a mano o
+ * reiniciaba el servicio — y el servicio de un PC de escritorio no se reinicia en semanas.
+ * O sea que teclear la contraseña una vez un lunes dejaba la máquina administrable para
+ * quien pasara por delante el jueves. Un candado que solo se cierra reiniciando no es un
+ * candado.
+ *
+ * El plazo se cuenta desde el ÚLTIMO USO (`touch`), no desde que se abrió: quien está
+ * trabajando no se queda fuera a media faena, y quien se levanta de la silla lo encuentra
+ * cerrado. Y vence solo, sin temporizador: se mira la hora al preguntar (`isOpen`), así
+ * que no hay nada que limpiar ni un `setTimeout` que mantenga vivo al proceso.
+ *
+ * Como todo el candado, esto es de la CONSOLA: al vencer, los aparatos ya emparejados
+ * siguen firmando, leyendo y guardando. Lo que se cierra es administrar y mirar.
+ */
+const AUTO_LOCK_MS = 5 * 60 * 1000
+
 /**
  * Archivos de un perfil que en la versión mono-perfil vivían sueltos en la raíz.
  *
@@ -91,7 +110,13 @@ async function derivePwd (password, saltB64, iter) {
 const newId = () => 'p' + crypto.randomUUID().slice(0, 8)
 const cleanName = (name) => String(name || '').slice(0, MAX_NAME)
 
-export function openProfiles (root = dataDir()) {
+/**
+ * @param {string} root  dir de datos
+ * @param {{ autoLockMs?: number, onAutoLock?: (id: string) => void }} [opts]
+ *   `autoLockMs`: 0 desactiva el bloqueo automático (las pruebas lo acortan).
+ *   `onAutoLock`: se avisa cuando un perfil se cierra solo, para poder decirlo en el log.
+ */
+export function openProfiles (root = dataDir(), { autoLockMs = AUTO_LOCK_MS, onAutoLock = null } = {}) {
   const file = path.join(root, REGISTRY)
   // CIFRADO EN REPOSO, como todo lo demás. Era el único archivo del vault sin códec, y
   // lleva dentro el verificador del candado. No protege de quien tenga el disco entero
@@ -107,8 +132,24 @@ export function openProfiles (root = dataDir()) {
   const save = () => writeJson(file, data, atRest)
 
   // Perfiles DESBLOQUEADOS en esta ejecución del daemon (en memoria: un reinicio
-  // vuelve a bloquear, igual que cerrar la pestaña en el navegador).
-  const unlocked = new Set()
+  // vuelve a bloquear, igual que cerrar la pestaña en el navegador), cada uno con la
+  // hora a la que se cierra solo si nadie lo usa (ver AUTO_LOCK_MS).
+  const unlocked = new Map() // id -> vence (ms epoch)
+
+  /** ¿Sigue abierto? Vence al MIRARLO, así que no hace falta ningún temporizador. */
+  const isOpen = (id) => {
+    const until = unlocked.get(id)
+    if (until == null) return false
+    if (autoLockMs > 0 && Date.now() >= until) {
+      unlocked.delete(id)
+      // El aviso va después de borrarlo: quien lo escuche verá el perfil ya cerrado.
+      try { onAutoLock?.(id) } catch (_) {}
+      return false
+    }
+    return true
+  }
+  /** Abre (o estira) el plazo. Todo lo que abre el candado pasa por aquí. */
+  const open = (id) => { unlocked.set(id, Date.now() + (autoLockMs > 0 ? autoLockMs : Number.MAX_SAFE_INTEGER)) }
 
   const find = (id) => data.profiles.find((p) => p.id === id) || null
   const dirOf = (id) => path.join(root, 'p', id)
@@ -118,7 +159,10 @@ export function openProfiles (root = dataDir()) {
     name: p.name || '',
     createdAt: p.createdAt || null,
     protected: !!p.pwd,
-    locked: !!p.pwd && !unlocked.has(p.id),
+    locked: !!p.pwd && !isOpen(p.id),
+    // Hasta cuándo sigue abierto si nadie lo toca. Es DATO: la consola lo enseña para
+    // que el cierre no llegue por sorpresa.
+    ...(p.pwd && isOpen(p.id) && autoLockMs > 0 ? { until: unlocked.get(p.id) } : {}),
     current: p.id === data.current,
     // Nació para adoptar la cuenta de un aparato (camino A) y todavía no lo ha hecho.
     ...(p.adopt ? { adopt: true } : {})
@@ -231,7 +275,20 @@ export function openProfiles (root = dataDir()) {
     // ----- candado -----
 
     isProtected: (id) => !!find(id)?.pwd,
-    isLocked: (id) => { const p = find(id); return !!p?.pwd && !unlocked.has(id) },
+    isLocked: (id) => { const p = find(id); return !!p?.pwd && !isOpen(id) },
+    /** Cuánto dura abierto el candado sin usarse (ms). 0 = no se cierra solo. */
+    get autoLockMs () { return autoLockMs },
+    /**
+     * «Se acaba de usar»: estira el plazo del bloqueo automático. Lo llama la consola
+     * al atender CADA petición suya, y solo eso cuenta como uso: que un aparato pida su
+     * configuración no abre nada ni alarga nada, porque el candado no es suyo.
+     * Devuelve si el perfil estaba abierto (a uno cerrado no hay nada que estirarle).
+     */
+    touch (id) {
+      if (!isOpen(id)) return false
+      open(id)
+      return true
+    },
     assertUnlocked (id) {
       if (api.isLocked(id)) throw new Error('profile locked: unlock it with your password (dotrino-vault unlock)')
     },
@@ -258,7 +315,7 @@ export function openProfiles (root = dataDir()) {
 
     async unlock (id, password) {
       const p = assertExists(id)
-      if (!p.pwd) { unlocked.add(id); return { ok: true, locked: false } }
+      if (!p.pwd) { open(id); return { ok: true, locked: false } }
       // Freno de fuerza bruta (una contraseña corta se adivina probando): tras 5
       // fallos, espera exponencial (2^n s, tope 5 min) persistida en el registro.
       // Los fallos VIEJOS se olvidan (ver TRIES_FORGET_MS): si desde el último ha pasado
@@ -296,7 +353,7 @@ export function openProfiles (root = dataDir()) {
       }
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return { ok: true, locked: false }
     },
 
@@ -314,7 +371,7 @@ export function openProfiles (root = dataDir()) {
       p.pwd = { v: 2, salt, verifier: deriveScryptPwd(password, salt) }
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return entry(p)
     },
 
@@ -324,7 +381,7 @@ export function openProfiles (root = dataDir()) {
       delete p.pwd
       delete p.tries
       save()
-      unlocked.add(id)
+      open(id)
       return entry(p)
     }
   }

package/src/tui/app.js

@@ -492,6 +492,72 @@ async function guard (term, st, msg, fn) {
  */
 const activeLocked = (st) => { const p = activeProfile(st); return !!(p?.protected && p.locked) }
 
+/** Los minutos que el daemon aguanta abierto (viene en `state.json`; 5 por defecto). */
+const autoLockMin = (st) => Math.max(1, Math.round((st.state?.autoLockMs || 5 * 60 * 1000) / 60000))
+
+/**
+ * ¿Alguna de las bóvedas que abrió ESTA sesión se cerró sola?
+ *
+ * El plazo lo lleva el daemon (`profiles.js`), no la TUI: aquí solo se MIRA su foto
+ * (`state.json`, que se reescribe cada dos segundos). Así hay un único reloj y no dos
+ * que se desincronizan — y lo que decida el daemon es lo que manda, porque es quien
+ * atiende.
+ */
+const autoLockedIds = (st) => (st.state?.profiles || [])
+  .filter((p) => p.protected && p.locked && (st.sessionPwd?.has(p.id) || st.unlockedHere?.has(p.id)))
+  .map((p) => p.id)
+
+/**
+ * Cuándo hay que despertar para enterarse. Sin esto la TUI se queda dormida en
+ * `readKey()` hasta la siguiente tecla y seguiría enseñando los aparatos y los nombres
+ * de las variables de una bóveda que el daemon ya cerró. Se suman ~2 s porque la foto
+ * se reescribe cada dos: despertar en el instante justo leería la anterior.
+ */
+function autoLockWakeIn (st, now = Date.now()) {
+  let at = 0
+  for (const p of st.state?.profiles || []) {
+    if (!p.until || !(st.sessionPwd?.has(p.id) || st.unlockedHere?.has(p.id))) continue
+    at = at ? Math.min(at, p.until) : p.until
+  }
+  if (!at) return 0
+  const left = at - now + 2200
+  // El plazo ya pasó y la foto sigue diciendo que está abierta: el daemon no la está
+  // reescribiendo (caído o colgado). Se insiste un rato y luego se deja de despertar, o
+  // la TUI se quedaría dando vueltas contra una foto que no va a cambiar.
+  if (left <= 0) return now - at > 15000 ? 0 : 1000
+  return Math.max(250, left)
+}
+
+/**
+ * BLOQUEO AUTOMÁTICO. Se cerró sola: se OLVIDA su contraseña y se sale de lo que se
+ * estaba mirando (dentro se ven los aparatos, las variables y tus datos, que es justo
+ * lo que el candado tapa).
+ *
+ * Olvidarla es la mitad que importa: sin esto la TUI la seguiría teniendo y la
+ * reabriría sola en cuanto alguien pulsara Enter (ver `reunlockSilently`), así que el
+ * candado del daemon no habría cerrado nada.
+ */
+async function forgetAutoLocked (term, st, api = vc) {
+  const ids = autoLockedIds(st)
+  if (!ids.length) return false
+  for (const id of ids) { st.sessionPwd?.delete(id); st.unlockedHere?.delete(id) }
+  const cur = (st.state?.profiles || []).find((p) => p.current)
+  if (ids.includes(cur?.id) && st.screen !== 'profiles') {
+    // Un modal abierto (una pregunta a medias) también se cierra: quien lo dejó abierto
+    // ya no está delante.
+    st.input = null
+    st.confirm = null
+    st.screen = 'profiles'
+  }
+  // Suelta lo cargado y repinta la lista con el candado ya echado (`refreshAll` no pide
+  // el contenido de una bóveda cerrada).
+  await refreshAll(term, st, api)
+  // El aviso va DESPUÉS del refresco: si no, un tropiezo al refrescar lo pisaría con su
+  // error rojo y el candado se cerraría en silencio.
+  flash(st, L(st).autoLocked(autoLockMin(st)), 'warn')
+  return true
+}
+
 // `api` es `vaultControl` — se recibe para poder probar ESTA función (la que se rompió)
 // sin un daemon detrás, que es donde vive la regla de qué se pide y en qué orden.
 async function refreshAll (term, st, api = vc) {
@@ -1608,14 +1674,23 @@ export async function runTui () {
     while (running) {
       st.state = vc.readState()
       st.daemonUp = vc.daemonAlive()
+      // ¿Se cerró sola mientras nadie miraba? Olvida su contraseña y sal de su contenido.
+      await forgetAutoLocked(term, st)
       // caducar el flash a los ~4 s
       if (st.flash && Date.now() - st.flash.at > 4000) st.flash = null
       render(term, st)
 
-      const tick = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      const base = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      // Despertar a tiempo del bloqueo automático, además del sondeo de la pantalla.
+      const wake = autoLockWakeIn(st)
+      const tick = base && wake ? Math.min(base, wake) : (base || wake)
       const key = await term.readKey(tick)
 
       if (key.name === 'resize') continue
+      // Un despertar del bloqueo automático no es una tecla: ya se atendió arriba, y las
+      // pantallas que NO esperan `tick` (todas menos aparatos y emparejamiento) no tienen
+      // por qué verlo.
+      if (key.name === 'tick' && st.screen !== 'pairing' && st.screen !== 'devices') continue
       // input/confirm se AWAITan: serializa las ops contra el daemon (ver onInputKey).
       // Ctrl-C dentro de un modal lo CANCELA (no sale); fuera de un modal, sale.
       if (st.input) { await onInputKey(st, key); continue }
@@ -1664,4 +1739,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, activeLocked, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }
+export const __test = { render, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts }

package/src/tui/i18n.js

@@ -126,6 +126,7 @@ const es = {
   vaultUnlocked: 'Bóveda desbloqueada',
   lockingVault: 'Bloqueando…',
   vaultLocked: 'Bóveda bloqueada',
+  autoLocked: (min) => `Se bloqueó sola tras ${min} min sin usarse · la contraseña se olvidó`,
 
   // dispositivos
   pendingDevice: (id) => ` ⧗ PENDIENTE: ${id}`,
@@ -422,6 +423,7 @@ const en = {
   vaultUnlocked: 'Vault unlocked',
   lockingVault: 'Locking…',
   vaultLocked: 'Vault locked',
+  autoLocked: (min) => `Locked itself after ${min} min idle · the password was forgotten`,
 
   pendingDevice: (id) => ` ⧗ PENDING: ${id}`,
   pendingHint: '  — press A to approve, X to reject',