@dotrino/vaultd 0.116.0 → 0.118.0

package/README.md

@@ -353,7 +353,9 @@ dispositivos/variables que estás viendo:
 1. **Bóvedas** es la pantalla de entrada: lista tus perfiles (`↑↓` mover, `Enter`
    **entrar** a uno — lo activa si no lo estaba). Ahí también **conectas un
    dispositivo** con `p` (sin entrar: activa la bóveda elegida y abre la pregunta de
-   a qué cuenta entra), creas una bóveda nueva, renombras, borras y pones/quitas/usas
+   a qué cuenta entra), **metes esta bóveda en la cuenta de otra** con `j` (pegas la
+   invitación que enseña la otra y tecleas allí el código que sale aquí: lo mismo que
+   `dotrino-vault join`), creas una bóveda nueva, renombras, borras y pones/quitas/usas
    la contraseña (candado).
 2. Al entrar caes en sus **pestañas horizontales**, que cambias con `←→`:
    - **Dispositivos (pares):** verlos, **emparejar** uno nuevo, **aprobar** con el
@@ -391,7 +393,8 @@ se recuerda en `prefs.json` del dir de datos, y al arrancar se decide en este or
 sistema (`LC_ALL`, `LC_MESSAGES`, `LANGUAGE` o `LANG`) → español.
 
 **Las teclas NO cambian con el idioma**: son mnemónicos en **inglés** y valen igual en
-español (solo se traduce la palabra que las explica en la barra de ayuda).
+español (solo se traduce la palabra que las explica en la barra de ayuda). Si la barra no
+cabe en una línea, se reparte en varias; nunca se esconde una tecla.
 
 | Tecla | Acción | Dónde |
 |---|---|---|
@@ -400,6 +403,7 @@ español (solo se traduce la palabra que las explica en la barra de ayuda).
 | `r` | rename (Bóvedas) · refresh (Dispositivos/Scopes) · restart (Emparejar) | — |
 | `d` | delete — borrar la bóveda | Bóvedas |
 | `p` | **pair — conectar un dispositivo** (desde Bóvedas entra directo, sin `Enter`) | Bóvedas · Dispositivos |
+| `j` | join — entrar en la cuenta de otra bóveda (pegando su invitación) | Bóvedas |
 | `c` | change password — poner/cambiar la contraseña | Bóvedas |
 | `x` | quitar: contraseña · dispositivo pendiente · variable/scope | Bóvedas · Dispositivos · Scopes · Emparejar |
 | `u` / `k` | unlock / locK — candado de la bóveda | Bóvedas |

package/lib/src/service.js

@@ -22,10 +22,10 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { createHash } from 'node:crypto'
 import {
-  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation,
+  makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice,
   verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { openWrap, wrapForMember, decryptWithCek } from '@dotrino/identity/content'
-import { verifyActa, sealKeyAt, sealersOf, memberCan } from '@dotrino/identity/acta'
+import { verifyActa, sealKeyAt, memberCan, checkVaultReply } from '@dotrino/identity/acta'
 import { MSG, secretsScope, isValidSecretsNs, VAULT_PROTOCOL, VAULT_SPEAKS } from './protocol.js'
 import { PKG_VERSION } from './version.js'
 import { makeEphemeralKey, openSealed } from './sealed.js'
@@ -400,18 +400,15 @@ export async function enrollWithVault ({ qr, label = 'agent', expectedScope = nu
     // por reloj, dice el `seq` del acta con el que se emitió, y quien lo emitió tiene que
     // ser SELLADORA de ese acta. Sin acta no se puede comprobar nada de eso, y entrar a
     // ciegas en un perfil es justo lo que no se hace.
-    const acta = res.acta
-    if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-    // Y el acta tiene que ser la DEL PERFIL DEL QR. Antes esto se comprobaba mirando que el
-    // cert lo firmara `qr.iss`; con varias selladoras el emisor puede ser otra llave del
-    // mismo perfil, así que lo que se fija es el perfil, no la llave.
-    if (acta.profileId !== qr.iss) throw new Error('the record is from a profile other than the one in the QR')
-    const v = await verifyDelegation({
-      cert: res.cert, expectedSub: device.publickey,
-      actaSeq: acta.seq, sealers: sealersOf(acta),
-      ...(expectedScope ? { expectedScope } : {})
+    //
+    // Se juzga contra la llave de LA BÓVEDA del QR, con la regla del pilar. Antes se exigía
+    // `acta.profileId === qr.iss`, que solo es verdad en una cuenta que nació en esa bóveda:
+    // un servicio no podía emparejarse con una segunda bóveda ni con una que adoptó la cuenta.
+    const chk = await checkVaultReply({
+      acta: res.acta, cert: res.cert, vault: qr.iss, sub: device.publickey,
+      scope: expectedScope || null, justSealed: true
     })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
 
     return { device, enc: enc ? { publickey: enc.encPublickey, privateJwk: enc.encPrivateJwk } : null, cert: res.cert, iss: qr.iss, proxy: qr.proxy || 'wss://proxy.dotrino.com' }
   } finally { client.close() }
@@ -599,7 +596,13 @@ export async function fetchSecrets ({ dir, ns, proxyUrl, masterPubkey, device, c
         const pending = waitForMsg(client, (p) => p.type === MSG.RENEWED || p.type === MSG.ERROR, 15000)
         client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
         const res = await pending
-        if (res.type === MSG.RENEWED && res.cert?.sub === device.publickey) {
+        // SE VERIFICA ANTES DE GUARDARLO. Aquí solo se miraba que fuera para esta llave: un
+        // papel cualquiera, sin firma que valga, sustituía al bueno y el servicio se quedaba
+        // fuera hasta el siguiente arranque. Misma regla que al enrolarse, sin `justSealed`:
+        // la última acta pudo sellarla otra selladora de la cuenta.
+        const ok = res.type === MSG.RENEWED &&
+          (await checkVaultReply({ acta: res.acta, cert: res.cert, vault: masterPubkey, sub: device.publickey })).ok
+        if (ok) {
           cert = res.cert
           recordar({ cert })
           // QUIEN NO PASA `dir` GUARDA ÉL. Un servicio que lleva su identidad en su propio

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.116.0",
+  "version": "0.118.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": {
@@ -22,10 +22,10 @@
   },
   "dependencies": {
     "@dotrino/compat": "0.4.0",
-    "@dotrino/identity": "0.81.0",
+    "@dotrino/identity": "0.92.0",
     "@dotrino/passmanager": "^0.10.1",
     "@dotrino/proxy-client": "0.18.2",
-    "@dotrino/roadmap": "0.2.0",
+    "@dotrino/roadmap": "0.3.3",
     "@dotrino/store": "0.11.0",
     "ws": "^8.18.0"
   },

package/src/client.js

@@ -11,19 +11,10 @@
  * estrictamente (firmado por la maestra que vio en el QR, y para SU clave) antes de
  * guardarlo. La maestra nunca sale del vault.
  */
-import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDelegation, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
+import { makeDeviceKey, makeDeviceEncKey, importDeviceEncKey, signWithDevice, verifyDeviceSig, makePairingCode, commitCode, pubkeyId } from '@dotrino/identity/capabilities'
 import { myContentKey, encryptWithCek, decryptWithKeyring } from '@dotrino/identity/content'
-import { sealersOf } from '@dotrino/identity/acta'
-
-/**
- * Con qué se juzga un papel: el ACTA que la bóveda manda junto a él. Sustituye a comparar
- * `cert.iss` con la maestra — con varias selladoras el emisor puede ser otra llave del mismo
- * perfil, así que lo que se fija es el PERFIL, no la llave.
- */
-function contexto (acta) {
-  if (!acta) throw new Error('the vault did not send its record: cannot check who signed this cert')
-  return { actaSeq: acta.seq, sealers: sealersOf(acta) }
-}
+// Con qué se juzga lo que devuelve la bóveda (papel + acta): la regla del pilar, una sola.
+import { checkVaultReply } from '@dotrino/identity/acta'
 import { installNodeGlobals } from './node-globals.js'
 import { MSG } from './protocol.js'
 
@@ -102,11 +93,11 @@ export async function enroll ({ qr, label = '', dir, onChallenge, approveTimeout
     client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
     const res = await enrolled
 
-    // VALIDACIÓN ESTRICTA antes de persistir (cierra inyección de cert / sustitución de maestra).
-    if (res.acta?.profileId !== qr.iss) throw new Error('the record is from a profile other than the one you saw (possible malicious proxy)')
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...contexto(res.acta) })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
-    if (res.cert.sub !== device.publickey) throw new Error('cert issued for a different device')
+    // VALIDACIÓN ESTRICTA antes de persistir (cierra inyección de cert / sustitución de maestra),
+    // contra la llave de la bóveda del QR y con la regla del pilar: vale también para una
+    // segunda bóveda o una que adoptó la cuenta, donde esa llave no es el `profileId`.
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: qr.iss, sub: device.publickey, justSealed: true })
+    if (!chk.ok) throw new Error('the vault reply does not check out: ' + chk.reason)
     // OJO: devolvemos qr.iss (la maestra que el usuario VIO), NO res.iss.
     return { device: { ...device, encPublickey: enc.encPublickey, encPrivateJwk: enc.encPrivateJwk }, cert: res.cert, iss: qr.iss, acta: res.acta }
   } finally { client.close() }
@@ -168,11 +159,10 @@ export async function requestRenew ({ masterPubkey, proxyUrl, device, cert, dir
     client.sendByPubkey(masterPubkey, { type: MSG.RENEW, data, signature, cert })
     const res = await pending
     if (res.type === MSG.ERROR) throw new Error(res.error)
-    // Se valida antes de devolverlo, igual que en el enrolamiento: un cert que no está
-    // firmado por la maestra que ya conocemos, o que no es para esta llave, no se guarda.
-    if (res.acta?.profileId !== masterPubkey) throw new Error('the record is from a profile other than the pinned one')
-    const v = await verifyDelegation({ cert: res.cert, expectedSub: device.publickey, ...contexto(res.acta) })
-    if (!v.ok) throw new Error('invalid cert: ' + v.reason)
+    // Se valida antes de devolverlo, igual que en el enrolamiento: un cert que no firmó la
+    // bóveda que ya conocemos, o que no es para esta llave, no se guarda.
+    const chk = await checkVaultReply({ acta: res.acta, cert: res.cert, vault: masterPubkey, sub: device.publickey })
+    if (!chk.ok) throw new Error('invalid renewed cert: ' + chk.reason)
     return { cert: res.cert }
   } finally { client.close() }
 }

package/src/ctl.js

@@ -453,7 +453,10 @@ async function cmdJoin (rest) {
   const s = requireDaemon()
   const res = path.join(dir, 'join.json')
   try { fs.rmSync(res, { force: true }) } catch (_) {}
-  writeReq('join-request.json', { qr, label: 'bóveda', ...(name ? { name } : {}), ...(kek ? { kek } : {}) })
+  // El `id` vuelve en cada respuesta: el daemon ya no se bloquea mientras espera, así que
+  // otra consola puede lanzar su propio `join` y su respuesta cae en el mismo archivo.
+  const reqId = crypto.randomUUID()
+  writeReq('join-request.json', { id: reqId, qr, label: 'bóveda', ...(name ? { name } : {}), ...(kek ? { kek } : {}) })
   sendSignal(s.pid, 'SIGUSR2')
 
   console.log('Entrando en la cuenta de la otra bóveda…')
@@ -461,7 +464,7 @@ async function cmdJoin (rest) {
   for (let i = 0; i < 900; i++) {          // hasta 3 min: hay un humano tipeando al otro lado
     await sleep(200)
     const d = ipcRead(res, null)
-    if (!d) continue
+    if (!d || ('req' in d && d.req !== reqId)) continue
     if (d.code && d.code !== visto) {
       visto = d.code
       console.log('\n  Tipea este código en la OTRA bóveda:   dotrino-vault approve %s\n', d.code)

package/src/daemon.js

@@ -256,6 +256,58 @@ export async function runDaemon () {
   // es el papel contrario — aquí no se invita a nadie, se acepta una invitación ajena.
   const joinReqFile = path.join(dir, 'join-request.json')
   const joinResFile = path.join(dir, 'join.json')
+  /** Hay un `join` esperando su código. Uno a la vez: el perfil que nace es para ESE intento. */
+  let joining = false
+
+  async function runJoin (join, answer) {
+    // LA CUENTA AJENA VA EN UN PERFIL DEL GESTOR, no en una cuenta interna de la
+    // identidad. Antes esto usaba `enrollDevice(…, { join: 'new' })`, que crea una
+    // cuenta más DENTRO de la identidad de un perfil que ya existía —y el gestor no se
+    // enteraba—: no había instancia de bóveda para ella, nadie se identificaba en el
+    // proxio con esa llave, y el aviso de la otra bóveda —con el acta donde acababa de
+    // conceder `sella`— no llegaba a ninguna parte. Se unía y no servía para nada.
+    //
+    // Un perfil nace vacío y `adopt: true`, que es la marca que deja a `joinProfile`
+    // cambiar su acta recién nacida por la que traiga la otra bóveda; sin ella, unirse
+    // sería pisar una cuenta con datos y se rechaza, que es lo correcto por defecto.
+    let nacido = null
+    try {
+      const p = await mgr.add(join.name || 'cuenta de la otra bóveda', { adopt: true, kek: join.kek || null })
+      nacido = p.id
+      const id = mgr.get(p.id)?.identity
+      if (!id) throw new Error('no identity for the new profile')
+      const off = id.onVault?.((e) => {
+        if (e?.phase === 'challenge' && e.code) {
+          console.log('[vault] type this code in the other vault:  %s', e.code)
+          answer({ code: e.code, state: 'waiting', profile: p.id })
+        }
+      })
+      // `'current'` y no `'new'`: el perfil que se acaba de crear ES el sitio, y su
+      // llave recién hecha es la que entra en el acta de la otra bóveda. Crear ahí
+      // dentro otra cuenta más sería el bug de arriba otra vez, un nivel más abajo.
+      // `seq` es el del acta con la que la otra bóveda emitió el papel (`pairWithVault`
+      // de @dotrino/identity). Antes se leía `r.acta.seq`, que no existe: el aviso decía
+      // siempre «acta #?».
+      let r
+      try { r = await id.enrollDevice(join.qr, { label: join.label || 'bóveda', join: 'current' }) } finally { off?.() }
+      // LA CUENTA RECIÉN ADOPTADA PASA A SER LA ACTIVA, y no es un capricho: es la
+      // razón por la que se hizo el `join`. Sin esto, el `Perfil 1` vacío que nace en
+      // el primer arranque sigue siendo el destino por defecto y todo lo que hagas
+      // después —emparejar un aparato, aprobarlo— entra en la cuenta equivocada sin
+      // decir nada. En un contenedor que arranca para respaldar una cuenta, ese perfil
+      // vacío no es más que un accidente del primer arranque.
+      try { mgr.profiles.setCurrent(p.id) } catch (_) {}
+      console.log('[vault] joined the account of the other vault (record #%s) as profile %s (now the active one)', r.seq, p.id)
+      answer({ state: 'done', seq: r.seq, profile: p.id })
+      writeState()
+    } catch (e) {
+      console.error('[vault] could not join:', e.message)
+      // El perfil nació para esto y está vacío: si el intento no llegó a término se va
+      // con él. Si no, cada reintento dejaba una cuenta fantasma en el conmutador.
+      if (nacido) { try { await mgr.remove(nacido) } catch (_) {} }
+      answer({ state: 'error', error: e.message })
+    }
+  }
   const secretsListFile = path.join(dir, 'secrets-list.json')
   /**
    * Por qué falló la última orden de variables. La consola pide el cambio y el volcado
@@ -512,49 +564,22 @@ export async function runDaemon () {
       const join = readJsonSafe(joinReqFile)
       if (join?.qr) {
         rm(joinReqFile)
-        rm(joinResFile)
-        // LA CUENTA AJENA VA EN UN PERFIL DEL GESTOR, no en una cuenta interna de la
-        // identidad. Antes esto usaba `enrollDevice(…, { join: 'new' })`, que crea una
-        // cuenta más DENTRO de la identidad de un perfil que ya existía —y el gestor no se
-        // enteraba—: no había instancia de bóveda para ella, nadie se identificaba en el
-        // proxio con esa llave, y el aviso de la otra bóveda —con el acta donde acababa de
-        // conceder `sella`— no llegaba a ninguna parte. Se unía y no servía para nada.
-        //
-        // Un perfil nace vacío y `adopt: true`, que es la marca que deja a `joinProfile`
-        // cambiar su acta recién nacida por la que traiga la otra bóveda; sin ella, unirse
-        // sería pisar una cuenta con datos y se rechaza, que es lo correcto por defecto.
-        let nacido = null
-        try {
-          const p = await mgr.add(join.name || 'cuenta de la otra bóveda', { adopt: true, kek: join.kek || null })
-          nacido = p.id
-          const id = mgr.get(p.id)?.identity
-          if (!id) throw new Error('no identity for the new profile')
-          const off = id.onVault?.((e) => {
-            if (e?.phase === 'challenge' && e.code) {
-              console.log('[vault] type this code in the other vault:  %s', e.code)
-              ipcWrite(joinResFile, { at: Date.now(), code: e.code, state: 'waiting', profile: p.id })
-            }
-          })
-          // `'current'` y no `'new'`: el perfil que se acaba de crear ES el sitio, y su
-          // llave recién hecha es la que entra en el acta de la otra bóveda. Crear ahí
-          // dentro otra cuenta más sería el bug de arriba otra vez, un nivel más abajo.
-          const r = await id.enrollDevice(join.qr, { label: join.label || 'bóveda', join: 'current' })
-          off?.()
-          // LA CUENTA RECIÉN ADOPTADA PASA A SER LA ACTIVA, y no es un capricho: es la
-          // razón por la que se hizo el `join`. Sin esto, el `Perfil 1` vacío que nace en
-          // el primer arranque sigue siendo el destino por defecto y todo lo que hagas
-          // después —emparejar un aparato, aprobarlo— entra en la cuenta equivocada sin
-          // decir nada. En un contenedor que arranca para respaldar una cuenta, ese perfil
-          // vacío no es más que un accidente del primer arranque.
-          try { mgr.profiles.setCurrent(p.id) } catch (_) {}
-          console.log('[vault] joined the account of the other vault (record #%s) as profile %s (now the active one)', r?.acta?.seq ?? '?', p.id)
-          ipcWrite(joinResFile, { at: Date.now(), state: 'done', seq: r?.acta?.seq ?? null, profile: p.id })
-        } catch (e) {
-          console.error('[vault] could not join:', e.message)
-          // El perfil nació para esto y está vacío: si el intento no llegó a término se va
-          // con él. Si no, cada reintento dejaba una cuenta fantasma en el conmutador.
-          if (nacido) { try { await mgr.remove(nacido) } catch (_) {} }
-          ipcWrite(joinResFile, { at: Date.now(), state: 'error', error: e.message })
+        // Cada respuesta lleva el `id` de la petición, para que quien espera no tome por
+        // suya la de otro intento (la TUI y la CLI leen el mismo archivo).
+        const answer = (extra) => ipcWrite(joinResFile, { at: Date.now(), req: join.id || null, ...extra })
+        if (joining) {
+          console.error('[vault] join rejected: another join is still waiting for its code')
+          answer({ state: 'error', errorCode: 'JOIN_BUSY', error: 'another join is still waiting for its code' })
+        } else {
+          rm(joinResFile)
+          joining = true
+          // NO SE ESPERA AQUÍ. Unirse aguarda a que una persona teclee el código en la otra
+          // bóveda —hasta 3 minutos—, y `serve()` atiende las peticiones de una en una: con
+          // un `await` en este punto el daemon no contestaba NADA durante ese rato. La CLI
+          // no lo notaba porque se quedaba quieta esperando; la TUI sí, porque sigue pidiendo
+          // cosas (la lista de bóvedas, el «sigo aquí» del candado) y cada una acababa en
+          // «el daemon no respondió».
+          runJoin(join, answer).finally(() => { joining = false })
         }
       }
       // Secretos: `secret set/rm` (por SCOPE) y `secret device set/rm` (por APARATO),

package/src/tui/app.js

@@ -24,7 +24,7 @@
  *
  * LAS TECLAS NO CAMBIAN CON EL IDIOMA: son mnemónicos en INGLÉS y son las mismas
  * en español (lo que se traduce es la palabra que las explica en la barra de
- * ayuda). new · rename · delete · password · unlock · locK · pair · approve ·
+ * ayuda). new · rename · delete · password · unlock · locK · pair · join · approve ·
  * reject · reVoke · refresh · back · language · quit. Una tecla significa LO MISMO
  * en todas las pantallas: `p` es SIEMPRE emparejar (también en Bóvedas, sin tener
  * que entrar antes), el candado es `k` (la `l` es el idioma) y la contraseña `c`.
@@ -67,6 +67,8 @@ function humanErr (e, st) {
     NOT_APPLIED: t.errNotApplied,
     NOT_DELETED: t.errNotDeleted,
     PAIR_FAILED: t.errPairFailed,
+    INVITE_INVALID: t.errInviteInvalid,
+    JOIN_BUSY: t.errJoinBusy,
     APPROVE_FAILED: t.errWrongCode,
     MASTER_WITH_MEMBERS: t.errMasterWithMembers,
     PROFILE_LOCKED: t.errProfileLocked
@@ -230,6 +232,41 @@ function fitHelp (segs, cols) {
   return join([...head, '…', ...tail])
 }
 
+/**
+ * La barra de ayuda en VARIAS líneas cuando no cabe en una. Recortar del medio escondía
+ * justo las teclas de la pantalla —en 80 columnas, Bóvedas perdía la mitad—, y una tecla
+ * que no se ve es una tecla que no existe para quien no la sepa de memoria.
+ *
+ * Se reparte por segmentos enteros (una tecla nunca se parte en dos líneas). `maxLines`
+ * es lo que deja el alto del terminal: si ni así caben, la última línea vuelve a recortar
+ * del medio con `fitHelp`, que conserva el idioma y la salida.
+ */
+function wrapHelp (segs, cols, maxLines = Infinity) {
+  const sep = ' · '
+  const lines = []
+  let cur = []
+  for (const seg of segs) {
+    if (cur.length && widthOf([...cur, seg].join(sep)) + 1 > cols) { lines.push(cur); cur = [seg] } else cur.push(seg)
+  }
+  if (cur.length) lines.push(cur)
+  if (!lines.length) return ['']
+  if (lines.length <= maxLines) return lines.map((l) => l.join(sep))
+  const keep = Math.max(0, maxLines - 1)
+  return [...lines.slice(0, keep).map((l) => l.join(sep)), fitHelp(lines.slice(keep).flat(), cols)]
+}
+
+/** Texto corrido partido por palabras para que quepa en `width` columnas. */
+function wrapWords (text, width) {
+  const out = []
+  let line = ''
+  for (const word of String(text).split(/\s+/).filter(Boolean)) {
+    const cand = line ? line + ' ' + word : word
+    if (line && widthOf(cand) > width) { out.push(line); line = word } else line = cand
+  }
+  if (line) out.push(line)
+  return out
+}
+
 // --------------------------------- pantallas -------------------------------
 
 function profileRows (st, t) {
@@ -852,6 +889,8 @@ async function onKeyProfiles (term, st, key) {
       st.scroll.pairmode = { value: 0 }
       st.screen = 'pairmode'
     })
+  } else if (ch === 'j') {
+    promptJoin(term, st)
   } else if (ch === 'n') {
     setInput(st, {
       label: i.newVaultLabel,
@@ -1231,6 +1270,104 @@ function promptApprove (term, st) {
   })
 }
 
+/**
+ * `j`: ESTA bóveda entra en la cuenta de otra (multivault). Es el papel contrario a `p`:
+ * aquí no se invita a nadie, se acepta la invitación que enseña la otra bóveda.
+ */
+function promptJoin (term, st, api = vc) {
+  const i = L(st)
+  setInput(st, {
+    label: i.joinInviteLabel,
+    hint: i.joinInviteHint,
+    onSubmit: (text) => {
+      st.input = null
+      const invite = text.trim()
+      // Se mira ANTES de preguntar el nombre: pedirte cómo llamar a la cuenta y decir
+      // después que la invitación no vale es hacerte teclear para nada.
+      if (!api.joinInvite(invite)) { flash(st, i.errInviteInvalid, 'danger'); return }
+      setInput(st, {
+        label: i.joinNameLabel,
+        hint: i.joinNameHint,
+        onSubmit: async (name) => {
+          st.input = null
+          const r = await guard(term, st, i.startingJoin, () => api.startJoin({ invite, name: name.trim().slice(0, 60) || null }))
+          if (!r.ok) return
+          st.join = { id: r.v, startedAt: Date.now(), state: 'waiting', code: null }
+          st.scroll.join = { value: 0 }
+          st.screen = 'join'
+        },
+        onCancel: () => { st.input = null }
+      })
+    },
+    onCancel: () => { st.input = null }
+  })
+}
+
+/** Lo que la bóveda espera a que la otra apruebe (`approveTimeoutMs` de @dotrino/identity). */
+const JOIN_APPROVE_MS = 180_000
+/** Y lo que espera la pantalla antes de darlo por perdido: el daemon contesta antes. */
+const JOIN_GIVE_UP_MS = JOIN_APPROVE_MS + 20_000
+
+async function onKeyJoin (term, st, key, api = vc) {
+  const j = st.join
+  if (!j) { st.screen = 'profiles'; return true }
+  if (key.name === 'tick') {
+    if (j.state !== 'waiting') return true
+    const d = api.joinStatus(j.id)
+    if (d?.state === 'waiting' && d.code) j.code = d.code
+    else if (d?.state === 'done') {
+      Object.assign(j, { state: 'done', seq: d.seq, profile: d.profile })
+      // La cuenta nueva es ya la activa (lo decide el daemon): la lista tiene que decirlo,
+      // y la selección se pone encima para que Enter entre en ELLA.
+      await refreshAll(term, st, api)
+      const idx = (st.profiles?.profiles || []).findIndex((p) => p.id === d.profile)
+      if (idx >= 0) st.sel.profiles = idx
+    } else if (d?.state === 'error') {
+      Object.assign(j, { state: 'error', error: d.errorCode ? humanErr({ code: d.errorCode }, st) : d.error })
+    } else if (Date.now() - j.startedAt > JOIN_GIVE_UP_MS) {
+      Object.assign(j, { state: 'error', error: L(st).joinNoReply })
+    }
+    return true
+  }
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+  if (key.name === 'escape' || ch === 'b' || (key.name === 'enter' && j.state !== 'waiting')) {
+    // Salir no cancela: la bóveda sigue esperando el código en segundo plano (no hay forma
+    // de abortar un enrolamiento a medias). Se dice, para que nadie crea que lo paró.
+    if (j.state === 'waiting') flash(st, L(st).joinInBackground, 'warn')
+    st.join = null
+    st.screen = 'profiles'
+    await refreshProfiles(term, st, api)
+  }
+  return true
+}
+
+function joinBody (st, t, cols) {
+  const i = L(st)
+  const j = st.join
+  if (!j) return []
+  const width = Math.max(10, cols - 2)
+  const lines = []
+  if (j.state === 'done') {
+    for (const l of wrapWords(i.joinDone(j.seq ?? '?'), width)) lines.push(t.ok(l))
+    lines.push('')
+    for (const l of wrapWords(i.joinNextPassword, width)) lines.push(t.warn(l))
+  } else if (j.state === 'error') {
+    for (const l of wrapWords(i.joinFailed(j.error || '?'), width)) lines.push(t.danger(l))
+  } else if (!j.code) {
+    lines.push(t.muted(i.joinWaiting))
+  } else {
+    lines.push(t.bold(i.joinCodeIntro))
+    lines.push('')
+    lines.push('    ' + t.accent(t.bold(j.code)))
+    lines.push('')
+    for (const l of wrapWords(i.joinCodeWhere(j.code), width)) lines.push(t.muted(l))
+    lines.push('')
+    const left = Math.max(0, Math.round((j.startedAt + JOIN_APPROVE_MS - Date.now()) / 1000))
+    lines.push(t.muted(i.joinLeft(left)))
+  }
+  return lines
+}
+
 async function onKeyPairing (term, st, key) {
   const i = L(st)
   const ch = key.name === 'char' ? key.ch.toLowerCase() : null
@@ -1241,9 +1378,9 @@ async function onKeyPairing (term, st, key) {
   }
   // Scroll vertical para ver el QR completo cuando no cabe en la pantalla.
   if (['up', 'down', 'pageup', 'pagedown', 'home', 'end'].includes(key.name)) {
-    const { rows } = term.size()
-    const contentH = Math.max(1, rows - 7)
-    const pb = pairingBody(st, term.t, term.size().cols, contentH)
+    const { cols, rows } = term.size()
+    const contentH = contentHeight(st, cols, rows)
+    const pb = pairingBody(st, term.t, cols, contentH)
     const maxScroll = Math.max(0, pb.length - contentH)
     const scroll = st.scroll.pairing || (st.scroll.pairing = { value: 0 })
     if (key.name === 'up') scroll.value = Math.max(0, scroll.value - 1)
@@ -1672,6 +1809,7 @@ const helpSegs = (i, screen, st = {}) => {
     secrets: i.helpSecrets,
     pairing: i.helpPairing,
     pairmode: i.helpPairMode,
+    join: i.helpJoin,
     me: i.helpMe,
     caps: i.helpCaps,
     devvars: i.helpDevVars
@@ -1694,6 +1832,7 @@ const title = (i, screen) => ({
   profiles: i.titleProfiles,
   pairing: i.titlePairing,
   pairmode: i.titlePairMode,
+  join: i.titleJoin,
   caps: i.titleCaps,
   devvars: i.titleDevVars
 })[screen] || ''
@@ -1747,6 +1886,24 @@ function pairingBody (st, t, cols, height) {
   return lines
 }
 
+/** Filas fijas de arriba: cabecera, bóveda activa, aviso de versión, título y un hueco. */
+const TOP = 5
+/** Filas de contenido que deja libres como mínimo una ayuda larga. */
+const MIN_CONTENT = 3
+
+/** Las líneas de la barra de ayuda de la pantalla actual, ya repartidas al ancho. */
+function helpLines (st, i, cols, rows) {
+  if (st.input) return [i.helpInput]
+  if (st.confirm) return [i.helpConfirm]
+  const maxLines = Math.max(1, rows - TOP - 1 - MIN_CONTENT)
+  return wrapHelp(helpSegs(i, st.screen, st), cols, maxLines)
+}
+
+/** Alto del contenido: lo que queda entre la cabecera, la línea de estado y la ayuda. */
+function contentHeight (st, cols, rows, help = helpLines(st, L(st), cols, rows)) {
+  return Math.max(1, rows - TOP - 1 - help.length)
+}
+
 function render (term, st) {
   const t = term.t
   const i = L(st)
@@ -1777,9 +1934,9 @@ function render (term, st) {
   lines[3] = INNER_TABS.includes(st.screen) ? ' ' + renderTabs(st, t) : ' ' + t.title('» ' + title(i, st.screen))
   lines[4] = ''
 
-  const top = 5
-  const bottom = 2 // status + help
-  const contentH = Math.max(1, rows - top - bottom)
+  const help = helpLines(st, i, cols, rows)
+  const contentH = contentHeight(st, cols, rows, help)
+  const top = TOP
   const scrollRef = st.scroll[st.screen] || (st.scroll[st.screen] = { value: 0 })
 
   let body = []
@@ -1793,11 +1950,11 @@ function render (term, st) {
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
     body = scrollBody(pb, contentH, scrollRef)
-  }
+  } else if (st.screen === 'join') body = scrollBody(joinBody(st, t, cols), contentH, scrollRef)
   for (let n = 0; n < contentH; n++) lines[top + n] = body[n] ?? ''
 
-  // línea de estado: input / confirm / flash / busy
-  const statusRow = rows - 2
+  // línea de estado: input / confirm / flash / busy, justo encima de la ayuda
+  const statusRow = rows - 1 - help.length
   if (st.busy) lines[statusRow] = ' ' + t.accent('⏳ ' + st.busy)
   else if (st.input) {
     const inp = st.input
@@ -1812,11 +1969,8 @@ function render (term, st) {
     lines[statusRow] = ' ' + style((kind === 'danger' ? '✗ ' : kind === 'warn' ? '! ' : '✓ ') + st.flash.text)
   } else lines[statusRow] = ''
 
-  // barra de ayuda
-  let help = fitHelp(helpSegs(i, st.screen, st), cols)
-  if (st.input) help = i.helpInput
-  else if (st.confirm) help = i.helpConfirm
-  lines[rows - 1] = t.bar(help, cols)
+  // barra de ayuda (una o varias líneas, pegadas abajo)
+  help.forEach((h, n) => { lines[rows - help.length + n] = t.bar(h, cols) })
 
   term.render(lines)
 }
@@ -1846,8 +2000,9 @@ async function daemonDownScreen (term, st) {
     ]
     if (st.flash) content.push('', (st.flash.kind === 'danger' ? t.danger : t.warn)(st.flash.text))
     lines[0] = t.bar(i.downHeader, cols)
-    for (let n = 0; n < content.length && 2 + n < rows - 1; n++) lines[2 + n] = ' ' + content[n]
-    lines[rows - 1] = t.bar(fitHelp(i.downHelp, cols), cols)
+    const help = wrapHelp(i.downHelp, cols, Math.max(1, rows - 4))
+    for (let n = 0; n < content.length && 2 + n < rows - help.length; n++) lines[2 + n] = ' ' + content[n]
+    help.forEach((h, n) => { lines[rows - help.length + n] = t.bar(h, cols) })
     term.render(lines)
 
     const key = await term.readKey()
@@ -1916,7 +2071,7 @@ export async function runTui () {
       if (st.flash && Date.now() - st.flash.at > 4000) st.flash = null
       render(term, st)
 
-      const base = (st.screen === 'pairing' || (st.screen === 'devices' && !st.input && !st.confirm)) ? 800 : 0
+      const base = (st.screen === 'pairing' || st.screen === 'join' || (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)
@@ -1926,7 +2081,7 @@ export async function runTui () {
       // 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
+      if (key.name === 'tick' && !['pairing', 'join', 'devices'].includes(st.screen)) 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 }
@@ -1968,6 +2123,7 @@ export async function runTui () {
       else if (st.screen === 'devvars') running = await onKeyDevVars(term, st, key)
       else if (st.screen === 'pairmode') running = await onKeyPairMode(term, st, key)
       else if (st.screen === 'pairing') running = await onKeyPairing(term, st, key)
+      else if (st.screen === 'join') running = await onKeyJoin(term, st, key)
     }
   } finally {
     // AL SALIR SE VUELVE A CERRAR lo que se abrió aquí. Sin esto, teclear la contraseña una
@@ -1982,4 +2138,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, onKeySecrets, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }
+export const __test = { render, onKeySecrets, activeLocked, autoLockedIds, autoLockWakeIn, forgetAutoLocked, autoLockMin, refreshAll, ensureUnlocked, profileRows, deviceRows, secretRows, devVarRows, meRows, capsRows, onKeyCaps, pairModeRows, pairingBody, scrollBody, fitHelp, wrapHelp, wrapWords, joinBody, onKeyJoin, promptJoin, onKeyProfiles, onInputKey, toggleLang, mergeMembersAndCerts, seguirAqui, resetToque: () => { ultimoToque = 0 } }

package/src/tui/i18n.js

@@ -113,6 +113,7 @@ const es = {
   titleProfiles: 'Bóvedas',
   titlePairing: 'Emparejar un dispositivo',
   titlePairMode: 'Emparejar: ¿a qué cuenta entra?',
+  titleJoin: 'Entrar en la cuenta de otra bóveda',
 
   // bóvedas (perfiles)
   noPassword: 'sin clave',
@@ -285,6 +286,22 @@ const es = {
   pairWaiting: 'Esperando a que el dispositivo se conecte…',
   pairQrTooNarrow: (cols, need) => `Agranda el terminal (el QR necesita ${need} cols; hay ${cols}).`,
 
+  // unirse a la cuenta de OTRA bóveda: el papel contrario a emparejar
+  joinInviteLabel: 'Invitación de la otra bóveda',
+  joinInviteHint: 'pega el código o la URL que enseña la otra al pulsar p (Esc cancela)',
+  joinNameLabel: '¿Cómo se llamará aquí esa cuenta?',
+  joinNameHint: 'el nombre con el que la verás en esta lista; vacío = «cuenta de la otra bóveda»',
+  startingJoin: 'Pidiendo entrar en la cuenta…',
+  joinWaiting: 'Conectando con la otra bóveda…',
+  joinCodeIntro: 'Teclea este código en la OTRA bóveda:',
+  joinCodeWhere: (code) => `allí: pulsa a en la pantalla del QR, o ejecuta  dotrino-vault approve ${code}`,
+  joinLeft: (s) => `Esperando la aprobación · quedan ~${s} s`,
+  joinDone: (seq) => `Listo: esta bóveda ya es miembro de esa cuenta (acta #${seq}). Ahora es la bóveda activa.`,
+  joinNextPassword: 'Si la otra bóveda le va a dar «sella», ponle antes contraseña a esta cuenta (c en Bóvedas): sin ella, cualquiera con acceso a esta máquina podría firmar el acta en tu nombre.',
+  joinFailed: (err) => `No se pudo entrar: ${err}`,
+  joinNoReply: 'La bóveda no contestó a tiempo. ¿Se aprobó el código en la otra?',
+  joinInBackground: 'La espera sigue: si la otra bóveda aprueba, la cuenta aparecerá en esta lista.',
+
   // confirmación / entrada
   confirmKeys: '  (s / N)',
   helpInput: 'Enter confirmar · Esc cancelar · Ctrl-U limpiar',
@@ -293,8 +310,8 @@ const es = {
   // Barras de ayuda. Las TECLAS son las mismas en los dos idiomas (mnemónico
   // INGLÉS: new/rename/delete/password/unlock/locK/pair/approve/revoke/refresh/
   // language/quit); lo único que se traduce es la palabra que las explica.
-  // Segmentos, no una línea: el render recorta del medio si no caben.
-  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
+  // Segmentos, no una línea: si no caben en una, el render los reparte en varias.
+  helpProfiles: ['↑↓', 'Enter entrar', 'p emparejar', 'j unirse', 'n nueva', 'r renombrar', 'd borrar', 'c clave', 'x quitar-clave', 'u desbloq', 'k bloquear', 'l English', 'q salir'],
   // La barra dice lo que se PUEDE hacer AHORA, no todo lo que existe: aprobar/rechazar solo
   // valen si hay alguien esperando, y renombrar/revocar solo si hay un aparato seleccionado.
   // Anunciar teclas muertas confunde y además las quema para otros usos.
@@ -330,6 +347,7 @@ const es = {
   revealNoPwd: 'Este perfil no tiene contraseña: se abre con la llave de esta máquina.',
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', '↑↓ scroll', 'Esc atrás', 'l English'],
   helpPairMode: ['↑↓', 'Enter elegir', 'Esc atrás', 'l English', 'q salir'],
+  helpJoin: ['Esc bóvedas', 'l English', 'q salir'],
 
   // pantalla "daemon caído"
   downTitle: 'El daemon del vault no está corriendo.',
@@ -354,6 +372,8 @@ const es = {
   errNotApplied: 'El daemon no aplicó el cambio (revisa los logs del servicio).',
   errNotDeleted: 'El daemon no borró la variable (revisa los logs del servicio).',
   errPairFailed: 'El daemon no inició el emparejamiento.',
+  errInviteInvalid: 'Esa invitación no se entiende: pega el código o la URL completos que enseña la otra bóveda.',
+  errJoinBusy: 'Ya hay otra entrada en curso esperando su código: termina esa primero.',
   // El código NO es la contraseña de la bóveda: son los seis dígitos que el aparato
   // enseña en su pantalla. Si no coincide, la bóveda no firma nada y el aparato sigue
   // esperando ahí, así que se puede volver a intentar con A.
@@ -444,6 +464,7 @@ const en = {
   titleProfiles: 'Vaults',
   titlePairing: 'Pair a device',
   titlePairMode: 'Pairing: which account does it join?',
+  titleJoin: 'Join the account of another vault',
 
   noPassword: 'no password',
   noPasswordWarn: 'This profile has no password: a copy of this disk opens the private variables.',
@@ -599,11 +620,26 @@ const en = {
   pairWaiting: 'Waiting for the device to connect…',
   pairQrTooNarrow: (cols, need) => `Widen the terminal (the QR needs ${need} cols; you have ${cols}).`,
 
+  joinInviteLabel: 'Invitation from the other vault',
+  joinInviteHint: 'paste the code or the URL the other one shows when you press p (Esc cancels)',
+  joinNameLabel: 'What should that account be called here?',
+  joinNameHint: 'the name you will see in this list; empty = “account of the other vault”',
+  startingJoin: 'Asking to join the account…',
+  joinWaiting: 'Connecting to the other vault…',
+  joinCodeIntro: 'Type this code in the OTHER vault:',
+  joinCodeWhere: (code) => `there: press a on the QR screen, or run  dotrino-vault approve ${code}`,
+  joinLeft: (s) => `Waiting for approval · ~${s} s left`,
+  joinDone: (seq) => `Done: this vault is now a member of that account (record #${seq}). It is now the active vault.`,
+  joinNextPassword: 'If the other vault is going to grant it “sealer”, set a password on this account first (c in Vaults): without one, anyone with access to this machine could sign the record as you.',
+  joinFailed: (err) => `Could not join: ${err}`,
+  joinNoReply: 'The vault did not answer in time. Was the code approved in the other one?',
+  joinInBackground: 'Still waiting: if the other vault approves, the account will show up in this list.',
+
   confirmKeys: '  (y / N)',
   helpInput: 'Enter confirm · Esc cancel · Ctrl-U clear',
   helpConfirm: 'y confirm · n/Esc cancel',
 
-  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'u unlock', 'k lock', 'l Español', 'q quit'],
+  helpProfiles: ['↑↓', 'Enter open', 'p pair', 'j join', 'n new', 'r rename', 'd delete', 'c password', 'x drop-password', 'u unlock', 'k lock', 'l Español', 'q quit'],
   helpDevices: ({ pending, hasDevices, isService } = {}) => [
     '←→ tab', '↑↓', 'p pair',
     ...(pending ? ['a approve', 'x reject'] : []),
@@ -633,6 +669,7 @@ const en = {
   revealNoPwd: 'This profile has no password: it opens with this machine key.',
   helpPairing: ['a approve', 'x reject', 'r restart', '↑↓ scroll', 'Esc back', 'l Español'],
   helpPairMode: ['↑↓', 'Enter choose', 'Esc back', 'l Español', 'q quit'],
+  helpJoin: ['Esc vaults', 'l Español', 'q quit'],
 
   downTitle: 'The vault daemon is not running.',
   downBody1: 'The TUI gives orders to the daemon (the keeper of your key). Without it',
@@ -655,6 +692,8 @@ const en = {
   errNotApplied: 'The daemon did not apply the change (check the service logs).',
   errNotDeleted: 'The daemon did not delete the variable (check the service logs).',
   errPairFailed: 'The daemon did not start the pairing.',
+  errInviteInvalid: 'That invitation cannot be read: paste the whole code or URL the other vault shows.',
+  errJoinBusy: 'Another join is already waiting for its code: finish that one first.',
   errWrongCode: 'The code does not match the one shown by the device: nobody got in. Check it and press A again.',
   errProfileLocked: 'Vault locked: open it with its password',
   errWrongPassword: (n) => `Wrong password${n ? ` — ${n} failed attempts so far` : ''}`,

package/src/vaultControl.js

@@ -22,7 +22,7 @@ import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir } from './paths.js'
 // El canal local va cifrado en reposo (ver `ipc.js`).
 import { ipcRead, ipcWrite } from './ipc.js'
-import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
+import { encodeInvite, inviteUrl, parseInvite } from '../lib/src/invite.js'
 
 const dir = dataDir()
 
@@ -37,8 +37,10 @@ const F = {
   me: 'me.json',
   acta: 'acta.json',
   approve: 'approve.json',
+  join: 'join.json',
   // peticiones (las escribe el control; el daemon las consume y borra)
   pairReq: 'pair-request.json',
+  joinReq: 'join-request.json',
   approveReq: 'approve-request.json',
   rejectReq: 'reject-request.json',
   revokeReq: 'revoke-request.json',
@@ -697,3 +699,50 @@ export async function rejectPending (deviceId, profile) {
   signalOrCleanup('SIGUSR2', [F.rejectReq])
   await sleep(200)
 }
+
+// ---------------------------------------------------------------------------
+// Unirse a la cuenta de otra bóveda (multivault)
+// ---------------------------------------------------------------------------
+
+/**
+ * La invitación de otra bóveda, lista para `startJoin`, o null si no se entiende. Vale el
+ * código suelto y la URL del QR: es lo que enseña la otra al pulsar `p`.
+ *
+ * Lo que hace falta de verdad es el nonce de la sesión (`sn`) y una forma de alcanzar a la
+ * otra bóveda: la cita del proxio (`conn`) o su llave (`iss`). Misma regla que `join` en
+ * la CLI.
+ */
+export function joinInvite (text) {
+  const qr = parseInvite(String(text || '').trim())
+  return qr?.sn && (qr.conn || qr.iss) ? qr : null
+}
+
+/**
+ * Pide al daemon que ESTA bóveda entre en la cuenta de la otra. Devuelve el `id` de la
+ * petición; el progreso se lee con `joinStatus(id)`.
+ *
+ * No espera al final a propósito: entre medias una persona tiene que teclear en la otra
+ * bóveda el código que sale aquí, y eso son minutos.
+ *
+ * @param {{ invite?: string, name?: string|null }} [opts]
+ */
+export async function startJoin ({ invite, name } = {}) {
+  const qr = joinInvite(invite)
+  if (!qr) throw coded('invalid invitation', 'INVITE_INVALID')
+  requireAlive()
+  rm(F.join)
+  const id = await writeReq(F.joinReq, { qr, label: 'bóveda', ...(name ? { name } : {}) })
+  signalOrCleanup('SIGUSR2', [F.joinReq])
+  return id
+}
+
+/**
+ * Por dónde va el `join` con ese `id`: `{ state: 'waiting', code }`, `{ state: 'done',
+ * seq, profile }` o `{ state: 'error', error, errorCode? }`. null si aún no hay nada suyo.
+ */
+export function joinStatus (id) {
+  const d = read(F.join, null)
+  if (!d) return null
+  if ('req' in d && d.req !== id) return null
+  return d
+}