@dotrino/vaultd 0.8.0 → 0.10.0

package/README.md

@@ -195,6 +195,15 @@ entre las dos pantallas y corras `approve`. Un código robado ya no alcanza para
 entrar; la revocación de un dispositivo le ordena **autoborrarse** (con firma de la
 maestra, no por un mensaje cualquiera).
 
+La invitación viaja **comprimida** (`lib/src/invite.js`): los datos van en binario y el
+binario en base64url, ~100 caracteres en vez de los ~340 del JSON. Eso baja el QR de 69
+módulos a 41 —de 77×39 a 49×25 en la terminal— y de paso deja un código pegable de una
+sola palabra. El grueso del ahorro es la llave maestra: en el QR va el **punto comprimido**
+de la curva (33 bytes) y el lector rearma la JWK con una plantilla, comprobando que sale
+**byte a byte** igual, porque el proxy direcciona por esa string exacta. Si una llave no
+encaja en ninguna plantilla, la invitación sale en su forma larga: se hace grande, nunca
+incorrecta.
+
 El servicio se gestiona con systemd `--user`
 (`systemctl --user {start,stop,restart} dotrino-vault`). Tus datos —clave maestra
 incluida— viven en `~/.local/share/dotrino/vault` (permisos `0600`/`0700`), con un
@@ -323,6 +332,7 @@ sin vault; solo la feature que los necesita (TURN) espera. Primer consumidor:
 - `src/store.js` — árbol de contenidos (`vault.json`, versionado).
 - `src/client.js` — helper de **dispositivo** (enrolar / pedir firma / leer).
 - `src/protocol.js` — tipos de mensaje y scopes. · `src/qr.js` — QR ASCII. · `src/paths.js` — dirs.
+- `lib/src/invite.js` — la invitación de emparejamiento: cómo se comprime y cómo se lee.
 - `bin/sea-entry.js` — entrypoint del binario único (multicall daemon / `--ctl` / `--tui`).
 - `bin/dotrino-vaultd.js` — entrypoint de desarrollo (node directo).
 - `bin/dotrino-vault-tui.js` — entrypoint de desarrollo de la TUI.

package/lib/src/enroll.js

@@ -42,6 +42,10 @@ export const DEVICE_TTL_MS = 30 * 24 * 60 * 60 * 1000
 export const MSG_ENROLL = 'vault.enroll'
 export const MSG_ENROLL_CHALLENGE = 'vault.enroll.challenge'
 export const MSG_ENROLLED = 'vault.enrolled'
+// --- camino A: la cuenta del aparato pasa a vivir en la bóveda ---
+export const MSG_ENROLL_ADOPT = 'vault.enroll.adopt'
+export const MSG_ACTA_SEALED = 'vault.acta.sealed'
+export const MSG_ACTA_ADOPTED = 'vault.acta.adopted'
 export const MSG_REVOKED = 'vault.revoked'
 export const MSG_ERROR = 'vault.error'
 
@@ -63,12 +67,22 @@ export function scopeToCn (scope) {
   return null
 }
 
-/** Token aleatorio de 128 bits en hex. */
-export function randToken () {
-  const b = crypto.getRandomValues(new Uint8Array(16))
+/**
+ * Token aleatorio en hex (16 bytes = 128 bits por defecto).
+ *
+ * El emparejamiento pide 12 (96 bits): son de un solo uso, valen 5 minutos y hay
+ * UNA sesión viva a la vez, así que adivinarlo es 2^95 intentos contra una bóveda
+ * que además exige el código de 6 dígitos. A cambio, cada byte de menos son ~1,4
+ * caracteres menos en el QR — y el QR se mide en filas de terminal.
+ */
+export function randToken (bytes = 16) {
+  const b = crypto.getRandomValues(new Uint8Array(bytes))
   return [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
 }
 
+/** Tamaño del token/nonce de una sesión de emparejamiento (ver `randToken`). */
+const PAIR_TOKEN_BYTES = 12
+
 /** deviceId legible (p. ej. `C440-AC0E`) a partir de una pubkey JWK. */
 export async function deviceIdOf (pub) {
   const id = (await pubkeyId(pub)).slice(0, 8).toUpperCase()
@@ -94,8 +108,11 @@ export async function deviceIdOf (pub) {
 export function createEnrollDesk ({
   identity, iss, proxy, send, sendByPubkey,
   audit = () => {}, log = () => {},
-  onChallenge = () => {}, onPendingChange = () => {},
-  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS
+  onChallenge = () => {}, onPendingChange = () => {}, onAdopted = () => {},
+  defaultScope = ['vault:sign'], defaultTtlMs = DEVICE_TTL_MS,
+  // Camino A: lo que ESTA bóveda le manda al aparato para que la meta en su acta. `encPub`
+  // es su llave de CIFRADO — sin ella entra mandando pero sin poder leer el contenido.
+  encPub = null, vaultLabel = ''
 } = {}) {
   if (!identity) throw new Error('createEnrollDesk: falta identity')
   if (!iss) throw new Error('createEnrollDesk: falta iss (pubkey de la maestra)')
@@ -126,8 +143,8 @@ export function createEnrollDesk ({
    */
   function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '', mode = 'join', account = '' } = {}) {
     pending.clear() // uno a la vez: una sesión nueva supersede a la anterior
-    const token = randToken()
-    const sn = randToken()
+    const token = randToken(PAIR_TOKEN_BYTES)
+    const sn = randToken(PAIR_TOKEN_BYTES)
     const acct = String(account || '').slice(0, 40)
     pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, mode, account: acct, state: 'AWAITING_ENROLL' })
     return { token, qr: { v: 2, iss, proxy, token, sn, m: mode, ...(acct ? { acct } : {}) }, expiresInMs: PAIRING_TTL_MS }
@@ -162,6 +179,17 @@ export function createEnrollDesk ({
       return reply(from, { type: MSG_ERROR, error: 'token de emparejamiento inválido o expirado' })
     }
     if (d.sn !== pend.sn) return reply(from, { type: MSG_ERROR, error: 'sesión inválida' })
+    // V7 · la INTENCIÓN viaja firmada y tiene que coincidir con el modo con el que ESTA
+    // bóveda abrió el emparejamiento. Es lo que garantiza que lo que pasa es lo que el
+    // humano vio anunciado en las dos pantallas, y no algo que se decidió a mitad de camino.
+    const intent = d.intent || 'join'
+    if (intent !== 'join' && intent !== 'adopt') {
+      return reply(from, { type: MSG_ERROR, error: 'intención desconocida: ' + intent })
+    }
+    if (intent !== (pend.mode || 'join')) {
+      audit('rejected', { what: 'enroll', reason: 'intent-mismatch' })
+      return reply(from, { type: MSG_ERROR, error: `este emparejamiento se abrió para «${pend.mode || 'join'}» y el dispositivo pidió «${intent}»` })
+    }
     if (!isFresh(d)) {
       audit('rejected', { what: 'enroll', reason: 'stale' })
       return reply(from, { type: MSG_ERROR, error: 'petición vencida: ts fuera de la ventana ±5 min (posible replay, o el reloj del dispositivo está desfasado)' })
@@ -198,9 +226,12 @@ export function createEnrollDesk ({
     }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
+    // Camino A: de qué cuenta estamos hablando. Se guarda para poder comprobar, cuando
+    // llegue el acta sellada, que es la que este dispositivo dijo que iba a entregar.
+    if (intent === 'adopt' && typeof d.profileId === 'string') pend.profileId = d.profileId
 
     reply(from, { type: MSG_ENROLL_CHALLENGE, deviceId })
-    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '' })
+    fire(onChallenge, { deviceId, scope: pend.scope, label: pend.label || '', mode: pend.mode || 'join' })
     fire(onPendingChange)
     return { deviceId }
   }
@@ -236,6 +267,20 @@ export function createEnrollDesk ({
       throw new Error('el código no coincide con el que muestra el dispositivo: no se emitió ningún certificado. Vuelve a mirarlo y prueba otra vez.')
     }
 
+    // CAMINO A · aquí la bóveda no entrega un cert: entrega SU IDENTIDAD para que el
+    // aparato la meta en el acta de la cuenta que le está pasando. El código de vuelta es
+    // la misma defensa de siempre, en el otro sentido: el aparato solo hace caso a una
+    // bóveda que demuestre que un humano la aprobó.
+    if ((pend.mode || 'join') === 'adopt') {
+      audit('adopt-approve', { device: pend.deviceId, profile: pend.profileId || null })
+      pend.state = 'AWAITING_ACTA'
+      pend.approvedAt = Date.now()
+      reply(pend.from, { type: MSG_ENROLL_ADOPT, code, pub: iss, encPub: encPub || null, label: vaultLabel || '' })
+      log('[vault] adopción aprobada para %s: esperando el acta sellada', pend.deviceId)
+      fire(onPendingChange)
+      return { ok: true, deviceId: pend.deviceId, adopting: true }
+    }
+
     const { cert } = await identity.signDelegation(pend.dpub, pend.scope, { ttlMs: pend.ttlMs, label: pend.label })
 
     // Aprobar un emparejamiento ES admitir al dispositivo en el perfil: el cert es la
@@ -263,6 +308,60 @@ export function createEnrollDesk ({
     return { ok: true, deviceId: pend.deviceId, cert }
   }
 
+  /**
+   * CAMINO A · paso 6: llega el acta que el aparato acaba de sellar, con la bóveda dentro
+   * como miembro, la clave de contenido envuelta para ella y el mando ya traspasado.
+   *
+   * Lo que se comprueba antes de guardar nada (y por qué):
+   *   · que el sellador sea ESTA bóveda — si no, no es un traspaso, es un acta ajena;
+   *   · que la selle el aparato que estaba en este emparejamiento — cierra que un tercero
+   *     que vea pasar el mensaje cuele la suya;
+   *   · que sea la cuenta que ese aparato declaró al enrolarse (`profileId`) — cierra el
+   *     cambiazo de cuenta entre el anuncio que leyó el humano y lo que llega después.
+   *
+   * Adoptar la cuenta de otro solo procede sobre un perfil que **nació para eso** (la marca
+   * de `prepareForAdoption`). Es la misma regla del navegador: sin la marca, adoptar sería
+   * pisar una cuenta con datos, y eso no puede pasar por accidente.
+   */
+  async function handleActaSealed (from, p) {
+    const acta = p?.acta
+    const pend = [...pending.values()].find((x) => x.state === 'AWAITING_ACTA' && (x.from === from || x.dpub))
+    if (!pend) return reply(from, { type: MSG_ERROR, error: 'no hay ninguna adopción esperando un acta' })
+    if (!acta || typeof acta !== 'object') return reply(from, { type: MSG_ERROR, error: 'acta ausente o ilegible' })
+    if (acta.sealer !== iss) {
+      audit('rejected', { what: 'adopt', reason: 'not-sealer' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no nombra a esta bóveda como quien manda' })
+    }
+    if (acta.sealedBy !== pend.dpub) {
+      audit('rejected', { what: 'adopt', reason: 'sealed-by-other' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta no la selló el dispositivo de este emparejamiento' })
+    }
+    if (pend.profileId && acta.profileId !== pend.profileId) {
+      audit('rejected', { what: 'adopt', reason: 'other-profile' })
+      return reply(from, { type: MSG_ERROR, error: 'esa acta es de otra cuenta distinta a la que anunció el dispositivo' })
+    }
+
+    try {
+      const r = await identity.joinProfile(acta)
+      if (!r?.joined) throw new Error(r?.reason || 'no se pudo adoptar')
+      audit('adopt', { device: pend.deviceId, profile: acta.profileId, seq: acta.seq })
+      // El acta que vuelve es la que la bóveda tiene guardada: el aparato la adopta y los
+      // dos quedan en la misma versión.
+      const mia = (await identity.profileActa?.())?.acta || acta
+      reply(pend.from, { type: MSG_ACTA_ADOPTED, code: p.code, acta: mia })
+      pend.state = 'DONE'
+      pending.delete(pend.token)
+      fire(onPendingChange)
+      fire(onAdopted, { deviceId: pend.deviceId, profileId: acta.profileId, seq: mia.seq })
+      log('[vault] cuenta adoptada del dispositivo %s (perfil %s)', pend.deviceId, acta.profileId?.slice(0, 12))
+      return { ok: true, adopted: true, profileId: acta.profileId, seq: mia.seq }
+    } catch (e) {
+      log('[vault] no se pudo adoptar la cuenta: %s', e.message)
+      reply(pend.from, { type: MSG_ERROR, error: 'la bóveda no pudo adoptar la cuenta: ' + e.message })
+      return { ok: false, error: e.message }
+    }
+  }
+
   /** Rechaza un enrolamiento pendiente. */
   function reject (deviceId) {
     const pend = deviceId
@@ -300,7 +399,7 @@ export function createEnrollDesk ({
   }
 
   return {
-    startPairing, stopPairing, handleEnroll, approve, reject,
+    startPairing, stopPairing, handleEnroll, handleActaSealed, approve, reject,
     listPending, findPending, emitRevoke, revoke,
     get pendingCount () { return pending.size }
   }

package/lib/src/invite.js

@@ -1,65 +1,310 @@
 /**
  * invite.js — la invitación de emparejamiento: cómo se escribe y cómo se lee.
  *
- * Un emparejamiento viaja de dos maneras, y cada una quiere una codificación
- * distinta:
+ * Una invitación viaja de dos maneras —un QR que se escanea y un código que se
+ * copia y se pega— y **las dos quieren lo mismo: que sea CORTA**. En un QR cada
+ * carácter son módulos, y los módulos son filas y columnas de terminal; en un
+ * código pegable, cada carácter es una oportunidad de que alguien lo corte mal.
  *
- *   · **El QR / el enlace** → JSON CRUDO (`j`). Nadie lo lee con los ojos y cada
- *     carácter cuenta: el base64 infla el payload un 33 % y eso son módulos de más
- *     en el QR (~8 columnas y 4 filas de terminal). Va crudo.
- *   · **El código que se copia y se pega** → base64url (`b`). Ahí sí lo manipula
- *     una persona: una sola palabra sin comillas, llaves ni espacios, que sobrevive
- *     a un doble clic, a un chat y a un campo de texto.
+ * Por eso el formato vigente es **`c` (compacto)**: los datos van en BINARIO y el
+ * binario en base64url. Nada de JSON. Un JSON con la llave maestra dentro pesa
+ * ~340 caracteres (la llave es una JWK *serializada como string*, con sus comillas
+ * escapadas: 182 de esos 340 son ella sola); el mismo contenido en binario son ~75
+ * bytes → **~100 caracteres**. Medido en la práctica: el QR pasó de 69 módulos
+ * (77×39 en la terminal) a 41 (49×25), y el código pegable de 458 caracteres a 101.
  *
- * Para que el lector no tenga que ADIVINAR cuál de las dos le llegó, el payload
- * empieza por una **marca de formato** de un carácter (`j` o `b`). Sin marca se
- * asume el formato viejo (base64url, y si no, JSON), solo por compatibilidad con
- * los enlaces que ya salieron.
+ * De dónde sale el ahorro, en orden de importancia:
+ *   · **La llave `iss`** (182 → 44 chars). Una pubkey P-256 son dos coordenadas de
+ *     32 bytes; en el QR va el **punto comprimido** de 33 bytes (SEC1: `02`/`03`
+ *     según la paridad de `y`, seguido de `x`) y el lector recupera `y` resolviendo
+ *     la curva. La JWK se rearma con una PLANTILLA (el índice va en la cabecera)
+ *     para que la string vuelva **byte a byte** igual: el proxy direcciona por esa
+ *     string exacta, así que una coma de más rompe el enrutamiento.
+ *   · **`token` y `sn`** (34+34 → 16+16 bytes): eran hexadecimal, que gasta dos
+ *     caracteres por byte.
+ *   · **`proxy`** (33 → 0): si es el del ecosistema no viaja; se sobreentiende.
+ *   · **`m` y `v`**: dos campos de JSON → dos grupos de bits de la cabecera.
  *
- * GOTCHA que justifica la mitad de este archivo: el JSON crudo lleva `{`, `}` y
- * `"`, que **no son legales en una URI**. Al abrir el enlace, el navegador los
- * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es el JSON
- * que se emitió. Medido en un navegador real (2026-07-28). Por eso se
- * `decodeURIComponent` antes de parsear: sin eso, el QR daba «ese código no vale».
+ * SEGURIDAD DEL AHORRO: `encodeInvite` **comprueba el viaje de vuelta** antes de
+ * entregar la forma compacta — decodifica lo que acaba de codificar y exige que sea
+ * idéntico al original. Si algo no encaja (una JWK con otra forma, un campo nuevo,
+ * un `token` que no es hex), devuelve la forma larga en base64. Así una llave rara
+ * no rompe un emparejamiento: como mucho lo hace más grande.
+ *
+ * Formatos que se leen (el primer carácter dice cuál es):
+ *   · `c` — compacto binario+base64url. **El que se emite hoy**, para el QR y para
+ *           el código pegable: es a la vez el más corto y una sola palabra sin
+ *           comillas ni llaves, que sobrevive a un doble clic y a un chat.
+ *   · `b` — base64url del JSON. Forma larga, de reserva.
+ *   · `j` — JSON crudo. Solo para leer enlaces ya emitidos.
+ *   · sin marca — anterior a la marca de formato (base64url, o JSON).
+ *
+ * GOTCHA que justifica el `decodeURIComponent`: el JSON crudo lleva `{`, `}` y `"`,
+ * que **no son legales en una URI**. Al abrir el enlace, el navegador los
+ * percent-codifica (`%22`…), así que lo que llega a `location.hash` NO es lo que se
+ * emitió. Medido en un navegador real (2026-07-28). El formato compacto no tiene
+ * ese problema —base64url ya es seguro en una URL—, pero `j` sigue por ahí.
  */
 
 export const FMT_JSON = 'j'
 export const FMT_B64 = 'b'
+export const FMT_COMPACT = 'c'
+
+/** El proxy del ecosistema: si es este, no viaja en la invitación compacta. */
+export const DEFAULT_PROXY = 'wss://proxy.dotrino.com'
+
+/**
+ * La base del enlace del QR. Corta a propósito (`/d#v=` en vez de
+ * `/dispositivos#vault=`): son 15 caracteres menos dentro del QR, y ahí los
+ * caracteres se pagan en módulos. `vault.dotrino.com/dispositivos` sigue
+ * funcionando —es la ruta que la gente ya tiene— y `parseInvite` lee las dos.
+ */
+export const PAIR_URL = 'https://vault.dotrino.com/d#v='
+
+// ---------------------------------------------------------------------------
+// Conversiones (sin dependencias: esto corre en el navegador, en Node y dentro
+// del binario SEA)
+// ---------------------------------------------------------------------------
+
+const B64_STD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
 
-const b64urlEncode = (s) => {
-  const bytes = new TextEncoder().encode(s)
-  let bin = ''
-  for (const b of bytes) bin += String.fromCharCode(b)
-  const raw = typeof btoa === 'function' ? btoa(bin) : Buffer.from(s, 'utf8').toString('base64')
-  return raw.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+function bytesToB64url (bytes) {
+  let out = ''
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i]; const b = bytes[i + 1]; const c = bytes[i + 2]
+    out += B64_STD[a >> 2]
+    out += B64_STD[((a & 3) << 4) | ((b ?? 0) >> 4)]
+    if (b === undefined) break
+    out += B64_STD[((b & 15) << 2) | ((c ?? 0) >> 6)]
+    if (c === undefined) break
+    out += B64_STD[c & 63]
+  }
+  return out.replace(/\+/g, '-').replace(/\//g, '_')
 }
 
-const b64urlDecode = (s) => {
-  const b = s.replace(/-/g, '+').replace(/_/g, '/')
-  const pad = b + '='.repeat((4 - b.length % 4) % 4)
-  if (typeof atob === 'function') {
-    const bin = atob(pad)
-    const bytes = Uint8Array.from(bin, (c) => c.charCodeAt(0))
-    return new TextDecoder().decode(bytes)
+function b64urlToBytes (s) {
+  const clean = String(s).replace(/-/g, '+').replace(/_/g, '/').replace(/[^A-Za-z0-9+/]/g, '')
+  const out = []
+  let acc = 0; let bits = 0
+  for (const ch of clean) {
+    const v = B64_STD.indexOf(ch)
+    if (v < 0) return null
+    acc = (acc << 6) | v; bits += 6
+    if (bits >= 8) { bits -= 8; out.push((acc >> bits) & 0xff) }
   }
-  return Buffer.from(pad, 'base64').toString('utf8')
+  return Uint8Array.from(out)
 }
 
-/** El payload marcado, listo para meter en el `#fragment` o para copiar y pegar. */
-export function encodeInvite (qr, fmt = FMT_B64) {
+const utf8 = (s) => new TextEncoder().encode(s)
+const fromUtf8 = (b) => new TextDecoder().decode(b)
+
+/**
+ * `token` y `sn` son hexadecimal. Caben en la invitación en dos tamaños —12 o 16
+ * bytes— porque el hexadecimal gasta dos caracteres por byte y en un QR eso se
+ * paga: 12 bytes (96 bits, lo que emite hoy `startPairing`) son 11 caracteres
+ * menos que 16, y esos 11 caracteres son la diferencia entre que quepa un nombre
+ * de cuenta normal o que el QR suba una versión entera.
+ */
+const hexLen = (s) => (typeof s === 'string' && /^[0-9a-f]+$/.test(s) && (s.length === 24 || s.length === 32)) ? s.length / 2 : 0
+const hexToBytes = (s) => Uint8Array.from(s.match(/../g).map((h) => parseInt(h, 16)))
+const bytesToHex = (b) => [...b].map((x) => x.toString(16).padStart(2, '0')).join('')
+
+const b64urlEncodeStr = (s) => bytesToB64url(utf8(s))
+const b64urlDecodeStr = (s) => { const b = b64urlToBytes(s); return b ? fromUtf8(b) : null }
+
+// ---------------------------------------------------------------------------
+// La llave maestra: JWK ⇄ punto comprimido de la curva P-256
+// ---------------------------------------------------------------------------
+
+/**
+ * Las formas de JWK que existen en el ecosistema. `JSON.stringify` de una JWK
+ * conserva el orden en que la exportó cada WebCrypto, y **ese orden es parte de la
+ * identidad**: el proxy direcciona por la string exacta. Por eso no se «normaliza»
+ * la JWK —eso cambiaría la dirección de la bóveda—, se rearma tal cual con la
+ * plantilla que le toca. El índice viaja en la cabecera (2 bits, hasta 4 formas).
+ */
+const JWK_TEMPLATES = [
+  // 0 — WebCrypto de Node (el daemon del PC): key_ops, ext, kty, x, y, crv
+  (x, y) => `{"key_ops":["verify"],"ext":true,"kty":"EC","x":"${x}","y":"${y}","crv":"P-256"}`,
+  // 1 — WebCrypto de navegador (Chrome/Firefox/Safari, alfabético): crv, ext, key_ops, kty, x, y
+  (x, y) => `{"crv":"P-256","ext":true,"key_ops":["verify"],"kty":"EC","x":"${x}","y":"${y}"}`,
+]
+
+// Parámetros de la curva P-256 (FIPS 186-4). `a` es −3.
+const P256_P = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn
+const P256_B = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn
+
+const modPow = (base, exp, m) => {
+  let r = 1n; let b = base % m
+  while (exp > 0n) { if (exp & 1n) r = (r * b) % m; b = (b * b) % m; exp >>= 1n }
+  return r
+}
+
+const bytesToBig = (b) => { let n = 0n; for (const x of b) n = (n << 8n) | BigInt(x); return n }
+const bigToBytes32 = (n) => { const out = new Uint8Array(32); for (let i = 31; i >= 0; i--) { out[i] = Number(n & 0xffn); n >>= 8n } return out }
+
+/** Coordenada de una JWK: base64url de 32 bytes exactos, o `null`. */
+function coordBytes (s) {
+  if (typeof s !== 'string' || !/^[A-Za-z0-9_-]{43}$/.test(s)) return null
+  const b = b64urlToBytes(s)
+  return b && b.length === 32 ? b : null
+}
+
+/**
+ * `iss` (JWK serializada) → `{ tpl, point }` con el punto comprimido de 33 bytes, o
+ * `null` si la llave no tiene una forma conocida (entonces la invitación va larga).
+ */
+function packPubkey (iss) {
+  if (typeof iss !== 'string') return null
+  let jwk
+  try { jwk = JSON.parse(iss) } catch { return null }
+  if (!jwk || jwk.kty !== 'EC' || jwk.crv !== 'P-256') return null
+  const xb = coordBytes(jwk.x); const yb = coordBytes(jwk.y)
+  if (!xb || !yb) return null
+
+  const tpl = JWK_TEMPLATES.findIndex((f) => f(jwk.x, jwk.y) === iss)
+  if (tpl < 0) return null // forma desconocida: no se puede rearmar igual → larga
+
+  const point = new Uint8Array(33)
+  point[0] = 2 + (yb[31] & 1) // 02 = y par, 03 = y impar
+  point.set(xb, 1)
+  return { tpl, point }
+}
+
+/** Punto comprimido + plantilla → la `iss` original (o `null` si el punto no es de la curva). */
+function unpackPubkey (point, tpl) {
+  const template = JWK_TEMPLATES[tpl]
+  if (!template || point.length !== 33 || (point[0] !== 2 && point[0] !== 3)) return null
+
+  const x = bytesToBig(point.subarray(1))
+  if (x >= P256_P) return null
+  // y² = x³ − 3x + b (mod p). Con p ≡ 3 (mod 4) la raíz es y = (y²)^((p+1)/4).
+  const y2 = (((x * x) % P256_P) * x - 3n * x + P256_B) % P256_P
+  const rhs = (y2 + P256_P) % P256_P
+  let y = modPow(rhs, (P256_P + 1n) / 4n, P256_P)
+  if ((y * y) % P256_P !== rhs) return null // x no está en la curva
+  if ((y & 1n) !== BigInt(point[0] & 1)) y = P256_P - y
+
+  return template(bytesToB64url(point.subarray(1)), bytesToB64url(bigToBytes32(y)))
+}
+
+// ---------------------------------------------------------------------------
+// El formato compacto
+// ---------------------------------------------------------------------------
+
+/**
+ * Cabecera (1 byte):
+ *   bits 0-2  versión del protocolo (`qr.v`, hoy 2)
+ *   bit  3    modo: 0 = `join` · 1 = `adopt`
+ *   bits 4-5  plantilla de la JWK (índice en `JWK_TEMPLATES`)
+ *   bit  6    lleva proxy propio (si no, el del ecosistema)
+ *   bit  7    `token`/`sn` de 12 bytes (si 0, de 16)
+ *
+ * Cuerpo: punto comprimido (33) ‖ token (n) ‖ sn (n) ‖ len+`acct` ‖ [len+`proxy`]
+ */
+const MODES = ['join', 'adopt']
+
+function compactEncode (qr) {
+  if (!qr || typeof qr !== 'object') return null
+  const v = qr.v
+  if (!Number.isInteger(v) || v < 0 || v > 7) return null
+  const mode = MODES.indexOf(qr.m)
+  if (mode < 0) return null
+  const n = hexLen(qr.token)
+  if (!n || hexLen(qr.sn) !== n) return null
+
+  const pub = packPubkey(qr.iss)
+  if (!pub || pub.tpl > 3) return null
+
+  const acct = utf8(String(qr.acct || ''))
+  if (acct.length > 255) return null
+  const ownProxy = qr.proxy && qr.proxy !== DEFAULT_PROXY
+  const proxy = ownProxy ? utf8(String(qr.proxy)) : null
+  if (proxy && proxy.length > 255) return null
+
+  // Un campo que no se sepa escribir se perdería en silencio: eso NO se hace.
+  const known = new Set(['v', 'iss', 'proxy', 'token', 'sn', 'm', 'acct'])
+  if (Object.keys(qr).some((k) => !known.has(k))) return null
+
+  const head = v | (mode << 3) | (pub.tpl << 4) | (ownProxy ? 0x40 : 0) | (n === 12 ? 0x80 : 0)
+  const out = [head, ...pub.point, ...hexToBytes(qr.token), ...hexToBytes(qr.sn), acct.length, ...acct]
+  if (proxy) out.push(proxy.length, ...proxy)
+  return bytesToB64url(Uint8Array.from(out))
+}
+
+function compactDecode (text) {
+  const b = b64urlToBytes(text)
+  const n = (b && (b[0] & 0x80)) ? 12 : 16
+  if (!b || b.length < 35 + n * 2) return null
+  const head = b[0]
+
+  const iss = unpackPubkey(b.subarray(1, 34), (head >> 4) & 3)
+  if (!iss) return null
+
+  let i = 34
+  const token = bytesToHex(b.subarray(i, i + n)); i += n
+  const sn = bytesToHex(b.subarray(i, i + n)); i += n
+  const acctLen = b[i]; i += 1
+  if (i + acctLen > b.length) return null
+  const acct = acctLen ? fromUtf8(b.subarray(i, i + acctLen)) : ''
+  i += acctLen
+
+  let proxy = DEFAULT_PROXY
+  if (head & 0x40) {
+    if (i >= b.length) return null
+    const n = b[i]; i += 1
+    if (i + n > b.length) return null
+    proxy = fromUtf8(b.subarray(i, i + n)); i += n
+  }
+  if (i !== b.length) return null // sobran bytes: no es lo que creemos que es
+
+  // Mismo orden de campos que `startPairing`, para que las dos formas serialicen igual.
+  return { v: head & 7, iss, proxy, token, sn, m: MODES[(head >> 3) & 1], ...(acct ? { acct } : {}) }
+}
+
+// ---------------------------------------------------------------------------
+// API
+// ---------------------------------------------------------------------------
+
+/** Comparación por contenido, sin depender del orden de las claves. */
+const canon = (o) => JSON.stringify(Object.keys(o).sort().map((k) => [k, o[k]]))
+
+/**
+ * El payload marcado, listo para meter en el `#fragment` o para copiar y pegar.
+ *
+ * Por defecto **compacto**, que es lo más corto y a la vez pegable. Se cae a la
+ * forma larga (`b`) sola, sin avisar, si el compacto no reproduce el original
+ * exactamente: más vale un QR grande que uno que no empareja.
+ */
+export function encodeInvite (qr, fmt = FMT_COMPACT) {
   const json = JSON.stringify(qr)
-  return fmt === FMT_JSON ? FMT_JSON + json : FMT_B64 + b64urlEncode(json)
+  if (fmt === FMT_JSON) return FMT_JSON + json
+  if (fmt === FMT_COMPACT) {
+    const c = compactEncode(qr)
+    // El viaje de vuelta se comprueba SIEMPRE: es barato (una vez por
+    // emparejamiento) y es lo que permite comprimir sin jugarse el enrolamiento.
+    if (c) { const back = compactDecode(c); if (back && canon(back) === canon(qr)) return FMT_COMPACT + c }
+  }
+  return FMT_B64 + b64urlEncodeStr(json)
 }
 
-/** Una URL sin percent-encodear rompe el `#`: el fragmento se corta ahí. */
+/** El enlace del QR: `https://vault.dotrino.com/d#v=<invitación>`. */
+export function inviteUrl (qr) { return PAIR_URL + encodeInvite(qr) }
+
+/**
+ * Corta el `#fragment` de una URL. `#vault=` es la forma larga histórica y `#v=` la
+ * corta de hoy; se prueba la larga primero porque `#vault=` empieza por `#v`.
+ */
 const cutFragment = (text) => {
-  const i = text.indexOf('#vault=')
-  return i >= 0 ? text.slice(i + 7) : text
+  const long = text.indexOf('#vault=')
+  if (long >= 0) return text.slice(long + 7)
+  const short = text.indexOf('#v=')
+  return short >= 0 ? text.slice(short + 3) : text
 }
 
 /**
- * Lee una invitación venga como venga: URL con `#vault=…`, el código suelto, con
- * marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
+ * Lee una invitación venga como venga: URL con `#v=`/`#vault=`, el código suelto,
+ * con marca de formato o sin ella (formatos viejos). Devuelve el objeto del QR o
  * `null` — nunca lanza, porque del otro lado hay alguien pegando texto a mano.
  */
 export function parseInvite (text) {
@@ -75,13 +320,15 @@ export function parseInvite (text) {
 
   const marca = payload[0]
   const resto = payload.slice(1)
-  if (marca === FMT_JSON) return parse(undoUrl(resto)) || parse(resto)
-  if (marca === FMT_B64) { try { return parse(b64urlDecode(resto)) } catch { return null } }
+  if (marca === FMT_COMPACT) { const o = compactDecode(resto); if (o) return o }
+  if (marca === FMT_JSON) { const o = parse(undoUrl(resto)) || parse(resto); if (o) return o }
+  if (marca === FMT_B64) { const s = b64urlDecodeStr(resto); const o = s && parse(s); if (o) return o }
 
   // --- sin marca: formatos anteriores a la marca de formato (compatibilidad) ---
   const crudo = undoUrl(payload)
   if (crudo.trimStart().startsWith('{')) return parse(crudo)
-  try { return parse(b64urlDecode(payload)) } catch { return null }
+  const s = b64urlDecodeStr(payload)
+  return s ? parse(s) : null
 }
 
-export default { encodeInvite, parseInvite, FMT_JSON, FMT_B64 }
+export default { encodeInvite, inviteUrl, parseInvite, FMT_JSON, FMT_B64, FMT_COMPACT, PAIR_URL, DEFAULT_PROXY }

package/lib/src/protocol.js

@@ -20,6 +20,13 @@ export const MSG = Object.freeze({
   ENROLL: 'vault.enroll',                     // dispositivo → vault: { data, signature }
   ENROLL_CHALLENGE: 'vault.enroll.challenge', // vault → dispositivo: { deviceId, sas }
   ENROLLED: 'vault.enrolled',                 // vault → dispositivo (tras aprobar): { cert, iss, sas }
+  // Camino A (la cuenta del aparato pasa a vivir en la bóveda): en vez de un cert, la
+  // bóveda manda QUIÉN es para que el aparato la admita, le envuelva la clave de
+  // contenido y le traspase el mando; el aparato devuelve el acta sellada y la bóveda
+  // responde con la definitiva. Ver docs/vinculacion-de-cuentas.md §2.
+  ENROLL_ADOPT: 'vault.enroll.adopt',         // vault → dispositivo: { code, pub, encPub, label }
+  ACTA_SEALED: 'vault.acta.sealed',           // dispositivo → vault: { acta, code }
+  ACTA_ADOPTED: 'vault.acta.adopted',         // vault → dispositivo: { acta }
   REVOKED: 'vault.revoked',                   // vault → dispositivo: { body:{op,sub,nonce,iat,exp}, signature }
   SIGN: 'vault.sign',                         // dispositivo → vault: { data, signature, cert }
   SIGNED: 'vault.signed',                     // vault → dispositivo: { signature, publickey, device }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.8.0",
+  "version": "0.10.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": {
@@ -19,7 +19,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@dotrino/identity": "^0.34.0",
+    "@dotrino/identity": "^0.35.0",
     "@dotrino/proxy-client": "0.8.0",
     "ws": "^8.18.0"
   },

package/src/ctl.js

@@ -26,6 +26,7 @@ import { execFileSync } from 'node:child_process'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
 import { qrToString } from './qr.js'
+import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 import { VERSION } from './version.js'
 
 const dir = dataDir()
@@ -53,8 +54,6 @@ const writeReq = (name, obj) => fs.writeFileSync(path.join(dir, name), JSON.stri
 const R = '\x1b[31m', B = '\x1b[1m', Z = '\x1b[0m' // rojo / negrita / reset
 // La versión se inyecta en build (esbuild --define); en dev cae a 'dev'.
 
-const PROFILE_URL = 'https://vault.dotrino.com/dispositivos#vault='
-
 /**
  * Cómo se arranca el vault EN ESTA MÁQUINA. El CLI corre en Linux (servicio systemd),
  * en Windows/macOS (por npm, en primer plano o al inicio de sesión) y dentro de un
@@ -167,18 +166,34 @@ async function cmdPair (args = []) {
     PROFILE = d.id // el emparejamiento y los comandos siguientes apuntan a ELLA
     console.log('Cuenta nueva: %s  (%s)', name, d.id)
   }
+  // `--adopt [nombre]`: la TERCERA respuesta a «¿de qué cuenta hablamos?» — el camino A.
+  // Aquí la cuenta NO sale de esta bóveda: la trae el aparato y esta bóveda pasa a
+  // guardarla y a mandarla. Por eso se crea un perfil VACÍO, que nace a la espera de
+  // adoptarla; sin ese sitio no habría dónde meterla.
+  const adIdx = args.findIndex((a) => a === '--adopt')
+  const adopt = adIdx >= 0
+  if (adopt) {
+    const next = args[adIdx + 1]
+    const name = (next && !next.startsWith('-')) ? next : `cuenta del dispositivo`
+    const d = await profileRequest('add', { name, adopt: true })
+    if (d.error) { console.error('%s', d.error); process.exit(1) }
+    if (!d.id) { console.error('El daemon no dijo qué cuenta creó.'); process.exit(1) }
+    PROFILE = d.id
+    console.log('Cuenta a la espera de adoptar la del dispositivo: %s  (%s)', name, d.id)
+  }
   // La petición se escribe SIEMPRE (aunque no haya --service): lleva a qué perfil
   // se empareja el dispositivo.
-  writeReq('pair-request.json', service ? { service } : {})
+  writeReq('pair-request.json', { ...(service ? { service } : {}), ...(adopt ? { mode: 'adopt' } : {}) })
   avisar(s.pid, 'SIGUSR1')
 
   let pair = null
   for (let i = 0; i < 50; i++) { await sleep(100); const p = readJson(pairFile, null); if (p?.expiresAt > Date.now()) { pair = p; break } }
   if (!pair) { console.error('No se recibió respuesta del daemon para el emparejamiento.'); process.exit(1) }
 
-  const payload = JSON.stringify(pair.qr)
-  const b64 = Buffer.from(payload, 'utf8').toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-  const url = PROFILE_URL + b64
+  // Una sola forma para las dos cosas: la invitación compacta (base64url de ~100
+  // caracteres) va igual de bien dentro del QR que pegada a mano. Ver `lib/src/invite.js`.
+  const b64 = encodeInvite(pair.qr)
+  const url = inviteUrl(pair.qr)
   const mins = Math.round((pair.expiresAt - Date.now()) / 60000)
   // QUÉ CUENTA se comparte: el vault puede tener varias bóvedas y este QR sale de
   // UNA (la activa, o la de --profile). Decirlo evita enrolar el dispositivo en la
@@ -186,7 +201,7 @@ async function cmdPair (args = []) {
   const acct = pair.profileName || pair.profile
   if (acct) console.log('\nCuenta que se comparte: %s%s', acct, pair.profileName && pair.profile ? `  (${pair.profile})` : '')
   console.log('\nEscanea este QR con el dispositivo que quieres conectar (válido %d min):\n', mins)
-  console.log(qrToString(url)) // el QR abre vault.dotrino.com/dispositivos y empareja solo
+  console.log(qrToString(url)) // el QR abre la consola de dispositivos y empareja solo
   console.log(`${R}${B}⚠ Este código deja LEER tus datos y FIRMAR con tu identidad.${Z}`)
   console.log(`${R}  NO lo compartas con nadie, ni con "soporte". Solo escanéalo en TU dispositivo.${Z}`)
   console.log('\nO abre esta dirección en el dispositivo:\n  ' + url)

package/src/daemon.js

@@ -123,7 +123,14 @@ export async function runDaemon () {
       // TAMBIÉN dentro del QR (`acct`) para que el dispositivo pueda anunciar qué va
       // a pasar antes de hacerlo (V9 de docs/vinculacion-de-cuentas.md).
       const profileName = mgr.profiles.get(profileId)?.name || ''
-      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode: 'join', account: profileName })
+      // MODO (V9): lo decide la bóveda y viaja en el QR para que el aparato pueda decir
+      // qué va a pasar antes de hacerlo.
+      //   · `join`  → el dispositivo entra a esta cuenta de la bóveda.
+      //   · `adopt` → la bóveda se queda con la cuenta que trae el aparato (camino A). El
+      //               perfil de esta bóveda tiene que haber nacido para eso (`--adopt`
+      //               crea uno vacío), o no habría dónde meterla.
+      const mode = pairReq?.mode === 'adopt' ? 'adopt' : 'join'
+      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS, mode, account: profileName })
       writeJson(pairFile, { v: 2, qr, expiresAt: Date.now() + expiresInMs, profile: profileId, profileName })
       // El token es un secreto efímero: no debe quedar en disco más allá de su
       // vida. Se borra al VENCER (aquí) y al APROBARSE (abajo, consumido).
@@ -160,7 +167,7 @@ export async function runDaemon () {
       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
       // cuentas pueden llamarse igual). Lo usa «emparejar en una cuenta nueva».
-      case 'add': { const p = await mgr.add(req.name); return { done: `perfil creado: ${p.name || p.id}`, id: p.id } }
+      case 'add': { const p = await mgr.add(req.name, { adopt: !!req.adopt }); return { done: `perfil creado: ${p.name || p.id}`, id: p.id, adopt: !!req.adopt } }
       case 'rm': { const r = await mgr.remove(req.profile); return { done: `perfil borrado: ${r.name || r.id}` } }
       case 'rename': { const p = mgr.profiles.rename(ref(), req.name); return { done: `perfil renombrado: ${p.name}` } }
       case 'use': { const p = mgr.profiles.setCurrent(ref()); return { done: `perfil activo: ${p.name || p.id}` } }

package/src/manager.js

@@ -56,6 +56,10 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
       proxyUrl,
       log: (...a) => log(`[${tag}]`, ...a),
       isLocked: () => profiles.isLocked(id),
+      // Camino A: nació para adoptar la cuenta de un aparato (ver profiles.add).
+      forAdoption: !!p?.adopt,
+      // Ya adoptó: la marca se consume (no vuelve a estar «a la espera»).
+      onAdopted: () => { try { profiles.clearAdopt(id) } catch (_) {} },
       onEnrollChallenge: (info) => onEnrollChallenge?.({ ...info, profile: id, profileName: p?.name || '' })
     })
     running.set(id, v)
@@ -88,10 +92,15 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     currentId: () => profiles.current(),
     resolve: (ref) => profiles.resolve(ref),
 
-    async add (name) {
-      const p = profiles.add(name)
+    /**
+     * Crea un perfil. Con `adopt: true` nace **vacío, esperando la cuenta de un aparato**
+     * (camino A): la bóveda pone el sitio y la llave que entrará como miembro, pero la
+     * cuenta la trae el dispositivo y se adopta al emparejar.
+     */
+    async add (name, { adopt = false } = {}) {
+      const p = profiles.add(name, { adopt })
       await open(p.id)
-      log('[vault] perfil creado: %s (%s)', p.name || '(sin nombre)', p.id)
+      log('[vault] perfil creado%s: %s (%s)', adopt ? ' (a la espera de adoptar una cuenta)' : '', p.name || '(sin nombre)', p.id)
       return profiles.get(p.id)
     },
 

package/src/profiles.js

@@ -63,7 +63,9 @@ export function openProfiles (root = dataDir()) {
     createdAt: p.createdAt || null,
     protected: !!p.pwd,
     locked: !!p.pwd && !unlocked.has(p.id),
-    current: p.id === data.current
+    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 } : {})
   })
 
   function assertExists (id) {
@@ -123,15 +125,30 @@ export function openProfiles (root = dataDir()) {
       return { id, migrated: legacy }
     },
 
-    add (name) {
+    /**
+     * Crea un perfil. Con `adopt: true` nace **para adoptar la cuenta de un aparato**
+     * (camino A): la bóveda le hace sitio, pero la cuenta —el `profileId`, la reputación,
+     * lo ya firmado— la trae el dispositivo. La marca la consume `startVault`, que se la
+     * pasa a la identidad (`prepareForAdoption`); sin ella, adoptar una cuenta ajena se
+     * leería como pisar una cuenta con datos y se rechazaría, que es lo que tiene que
+     * pasar cuando nadie lo pidió.
+     */
+    add (name, { adopt = false } = {}) {
       const id = newId()
       ensureDir(dirOf(id))
-      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now() })
+      data.profiles.push({ id, name: cleanName(name), createdAt: Date.now(), ...(adopt ? { adopt: true } : {}) })
       if (!data.current) data.current = id
       save()
       return entry(find(id))
     },
 
+    /** Quita la marca de «nació para adoptar» (ya adoptó, o se canceló). */
+    clearAdopt (id) {
+      const p = find(id)
+      if (p?.adopt) { delete p.adopt; save() }
+      return !!p
+    },
+
     rename (id, name) {
       const p = assertExists(id)
       api.assertUnlocked(id)

package/src/tui/app.js

@@ -694,10 +694,8 @@ function pairingBody (st, t, cols, height) {
   // en la cuenta equivocada sin enterarse.
   const ap = activeProfile(st)
   const acct = info.profileName || ap?.name || info.profile || ap?.id || '—'
-  lines.push(t.bold(i.pairAccount(acct)))
   const left = Math.max(0, Math.round((info.expiresAt - Date.now()) / 60000))
-  lines.push(t.muted(i.pairValid(left)))
-  lines.push('')
+  lines.push(t.bold(i.pairAccount(acct, left)))
   // QR: se dibuja siempre que quepa de ancho; si es más alto que la pantalla se
   // puede hacer scroll hacia arriba/abajo para verlo completo.
   let qr = ''
@@ -711,6 +709,7 @@ function pairingBody (st, t, cols, height) {
     lines.push(t.warn(i.pairQrTooNarrow(cols, qrWidth)))
     lines.push('')
   }
+  lines.push(t.muted(i.pairScan))
   lines.push(t.bold(i.pairUrl) + info.url)
   lines.push('')
   lines.push(t.muted(i.pairPaste))

package/src/tui/i18n.js

@@ -134,10 +134,12 @@ const es = {
   newAccountLabel: 'Nombre de la cuenta nueva',
   newAccountHint: 'nace vacía; el dispositivo será su primer invitado',
   accountCreated: (name) => `Cuenta creada: ${name}`,
-  pairAccount: (name) => `Cuenta que se comparte: ${name}`,
-  pairValid: (min) => `Válido ~${min} min. Escanéalo o abre la URL en el dispositivo.`,
+  // Cuenta + vigencia en UNA línea: cada línea de cabecera es una fila menos de QR
+  // visible antes de tener que hacer scroll.
+  pairAccount: (name, min) => `Cuenta que se comparte: ${name}  ·  válido ~${min} min`,
+  pairScan: 'Escanéalo, o abre esta dirección en el dispositivo:',
   pairUrl: 'URL: ',
-  pairPaste: 'O pega este código en la pestaña #vault de profile.dotrino.com:',
+  pairPaste: 'O pega este código en vault.dotrino.com/dispositivos:',
   pairWarning: '⚠ Este código deja LEER tus datos y FIRMAR con tu identidad. No lo compartas.',
   pairConnected: (id) => `⧗ Se conectó: ${id} — pulsa A y escribe el código que muestra.`,
   pairWaiting: 'Esperando a que el dispositivo se conecte…',
@@ -297,10 +299,10 @@ const en = {
   newAccountLabel: 'Name of the new account',
   newAccountHint: 'born empty; the device will be its first guest',
   accountCreated: (name) => `Account created: ${name}`,
-  pairAccount: (name) => `Account being shared: ${name}`,
-  pairValid: (min) => `Valid ~${min} min. Scan it or open the URL on the device.`,
+  pairAccount: (name, min) => `Account being shared: ${name}  ·  valid ~${min} min`,
+  pairScan: 'Scan it, or open this address on the device:',
   pairUrl: 'URL: ',
-  pairPaste: 'Or paste this code into the #vault tab of profile.dotrino.com:',
+  pairPaste: 'Or paste this code into vault.dotrino.com/dispositivos:',
   pairWarning: '⚠ This code lets someone READ your data and SIGN as you. Do not share it.',
   pairConnected: (id) => `⧗ Connected: ${id} — press A and type the code it shows.`,
   pairWaiting: 'Waiting for the device to connect…',

package/src/vault.js

@@ -35,7 +35,7 @@ import { MSG, SCOPE, secretsScope, isValidSecretsNs } from './protocol.js'
  *   Solo bloquea EDITAR el perfil (`profileSet`): firmar/leer y el resto del store
  *   siguen sirviendo a los dispositivos enrolados aunque esté bloqueado.
  */
-export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false } = {}) {
+export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log, onEnrollChallenge, isLocked = () => false, forAdoption = false, onAdopted } = {}) {
   ensureDir(dir)
   // CIFRADO EN REPOSO ligado a esta máquina: `identity.json` deja de estar en claro, así
   // que copiarlo a otro equipo no sirve de nada. No protege contra quien ya tiene ESTA
@@ -47,6 +47,13 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
   } catch (e) { log('[vault] no se pudo cifrar la identidad en reposo:', e.message) }
   const identity = await Identity.connect({ dir, atRest: atRestFor(dir) })
   if (!identity.me?.publickey) await identity.setMyNickname('')
+  // CAMINO A: este perfil nació para adoptar la cuenta de un aparato. La identidad se crea
+  // igual (su llave es la que entrará como miembro), pero se marca para que `joinProfile`
+  // acepte cambiar su acta recién nacida por la que traiga el dispositivo. Sin la marca,
+  // adoptar sería pisar una cuenta con datos y se rechaza — que es lo correcto por defecto.
+  if (forAdoption) {
+    try { await identity.prepareForAdoption() } catch (e) { log('[vault] no se pudo preparar el perfil para adoptar:', e.message) }
+  }
 
   const store = openStore(dir)
   const threads = openThreadStore(dir)
@@ -101,6 +108,12 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     sendByPubkey: (pub, obj) => client.sendByPubkey(pub, obj),
     audit,
     log,
+    // Camino A: lo que esta bóveda le manda al aparato para entrar en SU acta. La llave de
+    // cifrado es lo que le permite leer el contenido de la cuenta que va a custodiar; sin
+    // ella entraría mandando una cuenta que no puede abrir.
+    encPub: identity.me?.encryptionPubkey || null,
+    vaultLabel: 'bóveda',
+    onAdopted: (info) => { try { onAdopted?.(info) } catch (_) {} },
     defaultScope: [SCOPE.READ],
     onChallenge ({ deviceId, scope }) {
       log(`\n[vault] Un dispositivo quiere conectarse:`)
@@ -263,6 +276,7 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     if (!payload || typeof payload !== 'object') return
     try {
       if (payload.type === MSG.ENROLL) return await desk.handleEnroll(from, payload)
+      if (payload.type === MSG.ACTA_SEALED) return await desk.handleActaSealed(from, payload)
       if (payload.type === MSG.SIGN) return await handleSign(from, payload)
       if (payload.type === MSG.GET) return await handleGet(from, payload)
       if (payload.type === MSG.STORE) return await handleStore(from, payload)

package/src/vaultControl.js

@@ -20,7 +20,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { pubkeyId } from '@dotrino/identity/capabilities'
 import { dataDir, readJson } from './paths.js'
-import { encodeInvite, FMT_JSON, FMT_B64 } from '../lib/src/invite.js'
+import { encodeInvite, inviteUrl } from '../lib/src/invite.js'
 
 const dir = dataDir()
 
@@ -256,24 +256,24 @@ export async function deleteScope (ns, profile) {
 // Emparejamiento de dispositivos (pares)
 // ---------------------------------------------------------------------------
 
-const PROFILE_URL = 'https://vault.dotrino.com/dispositivos#vault='
-
 /**
- * Codifica el QR crudo en sus dos formas (ver `lib/src/invite.js`):
+ * Codifica el QR crudo para enseñarlo (ver `lib/src/invite.js`).
  *
- *   · `url`  → para el QR y el enlace: JSON CRUDO con marca `j`. Es lo más corto
- *              que hay, y en un QR cada carácter son módulos: con base64 el QR
- *              pide ~8 columnas y 4 filas más de terminal.
- *   · `code` → para copiar y pegar: base64url con marca `b`. Una sola palabra,
- *              sin comillas ni llaves, que sobrevive a un doble clic y a un chat.
+ * Las dos formas son **la misma invitación compacta**: binario en base64url, ~100
+ * caracteres. Sirve igual para el QR (donde cada carácter son módulos, y módulos
+ * son filas de terminal) que para copiar y pegar (una sola palabra, sin comillas
+ * ni llaves, que sobrevive a un doble clic y a un chat). Antes hacían falta dos
+ * codificaciones distintas porque la única forma de achicar el QR era mandar el
+ * JSON crudo, ilegible al pegarlo; comprimiendo de verdad, esa disyuntiva
+ * desaparece.
  *
- * La MARCA de formato (el primer carácter) existe para que el lector no tenga que
- * probar los dos formatos a ver cuál cuela: la lee y sabe.
+ *   · `url`     → el enlace del QR, `…/d#v=<invitación>`.
+ *   · `code`    → la invitación suelta, para pegar en la consola.
+ *   · `payload` → el JSON crudo. Ya no se emite; se devuelve para diagnóstico.
  */
 export function pairUrl (qr) {
-  const payload = JSON.stringify(qr)
-  const code = encodeInvite(qr, FMT_B64)
-  return { url: PROFILE_URL + encodeInvite(qr, FMT_JSON), code, payload, b64: code }
+  const code = encodeInvite(qr)
+  return { url: inviteUrl(qr), code, payload: JSON.stringify(qr), b64: code }
 }
 
 export async function startPairing ({ profile, service } = {}) {