@dotrino/vaultd 0.7.3 → 0.7.5

package/README.md

@@ -103,9 +103,12 @@ los dispositivos/variables que estás viendo:
    **entrar** a uno — lo activa si no lo estaba). Ahí también 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 (muestra el QR y la
-     URL, y espera a que se conecte), **aprobar** con el código que muestra el
-     dispositivo, **rechazar** y **revocar**.
+   - **Dispositivos (pares):** verlos, **emparejar** uno nuevo, **aprobar** con el
+     código que muestra el dispositivo, **rechazar** y **revocar**. Al emparejar, la
+     bóveda **pregunta primero a qué cuenta entra el dispositivo** —a esta, o a una
+     cuenta nueva que se estrena para él— y recién después muestra el QR, que además
+     dice de qué cuenta salió. (En la CLI: `dotrino-vault pair --new-account
+     [nombre]`.)
    - **Scopes y variables (secretos):** ver los scopes y sus variables (nunca los
      valores), **agregar** una variable (con su scope) y **quitar** una variable o
      un scope entero.

package/lib/src/enroll.js

@@ -108,13 +108,29 @@ export function createEnrollDesk ({
   const reply = (to, obj) => { try { send(to, obj) } catch (e) { log('[vault] no se pudo responder:', e.message) } }
   const isFresh = (d) => typeof d?.ts === 'number' && Math.abs(Date.now() - d.ts) <= FRESH_WINDOW_MS
 
-  /** Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía. */
-  function startPairing ({ scope = defaultScope, ttlMs = defaultTtlMs, label = '' } = {}) {
+  /**
+   * Inicia un emparejamiento: token + nonce de sesión. NO firma nada todavía.
+   *
+   * `mode` y `account` son LO QUE LA BÓVEDA DECLARA que va a pasar, y viajan en el QR
+   * para que el aparato pueda **decirlo antes de hacerlo** en vez de emparejar a
+   * ciegas (decisión V9 de `docs/vinculacion-de-cuentas.md`: pregunta el vault, el
+   * dispositivo muestra el proceso y sus consecuencias):
+   *
+   *   · `mode: 'join'`  → el dispositivo estrena una cuenta suya y entra a la de la
+   *                       bóveda. Es lo único que existe hoy.
+   *   · `mode: 'adopt'` → la bóveda se quedaría con la cuenta que trae el aparato
+   *                       (camino A). Reservado: todavía no hay protocolo.
+   *   · `account`       → cómo se llama la cuenta de la bóveda, para nombrarla en el
+   *                       aviso. Es ORIENTATIVO (un nombre que puso su dueño); la
+   *                       identidad de verdad de la cuenta es `iss`.
+   */
+  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()
-    pending.set(token, { token, exp: Date.now() + PAIRING_TTL_MS, scope, ttlMs, label, sn, state: 'AWAITING_ENROLL' })
-    return { token, qr: { v: 2, iss, proxy, token, sn }, expiresInMs: PAIRING_TTL_MS }
+    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 }
   }
 
   function stopPairing (token) { pending.delete(token) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "type": "module",
   "description": "Certificador personal de Dotrino: daemon headless que custodia la clave maestra y delega capacidades a tus dispositivos por el proxy. Tu CA propia.",
   "bin": {

package/src/ctl.js

@@ -153,6 +153,20 @@ async function cmdPair (args = []) {
       console.error('uso: dotrino-vault pair --service <ns>   (ns en minúsculas, p.ej. proxy)'); process.exit(2)
     }
   }
+  // `--new-account [nombre]`: la otra respuesta a «¿a qué cuenta entra?». En vez de
+  // meter el dispositivo en una cuenta que ya vive aquí, se ESTRENA una (vacía) y
+  // entra a ella; las demás no se tocan. En la TUI esto es una pregunta con sus
+  // opciones; en la CLI es una bandera, para que siga sirviendo en un script.
+  const naIdx = args.findIndex((a) => a === '--new-account')
+  if (naIdx >= 0) {
+    const next = args[naIdx + 1]
+    const name = (next && !next.startsWith('-')) ? next : `cuenta ${new Date().toISOString().slice(0, 10)}`
+    const d = await profileRequest('add', { name })
+    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 // el emparejamiento y los comandos siguientes apuntan a ELLA
+    console.log('Cuenta nueva: %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 } : {})
@@ -539,6 +553,9 @@ function help () {
   tui                 interfaz de terminal a pantalla completa (bóvedas, pares, secretos)
   status              estado del servicio + fingerprint
   pair [--save <f>]   inicia un emparejamiento (QR + espera); --save escribe la invitación (.dpair)
+  pair --new-account [nombre]
+                      estrena una cuenta VACÍA en este vault y mete ahí al dispositivo
+                      (sin la bandera entra a la cuenta activa, o a la de --profile)
   pair --service <ns> empareja un SERVICIO (proxy, geo…) con acceso SOLO a sus secretos
   secret set <ns> <CLAVE> <valor>   guarda un secreto para el servicio <ns>
   secret rm <ns> <CLAVE>            borra un secreto

package/src/daemon.js

@@ -117,11 +117,13 @@ export async function runDaemon () {
       const isService = typeof pairReq?.service === 'string' && pairReq.service
       const scope = isService ? ['vault:secrets:' + pairReq.service] : ['vault:sign', 'vault:read', 'vault:store']
       const label = pairReq?.label || (isService ? 'servicio:' + pairReq.service : 'cli')
-      const { qr, expiresInMs } = vault.startPairing({ scope, label, ttlMs: DEVICE_TTL_MS })
       // `profile`/`profileName`: la CUENTA del vault a la que entra el dispositivo.
       // Con varias bóvedas en el mismo daemon, el QR sale de UNA y quien empareja
-      // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`).
+      // tiene que verlo (lo muestran la TUI y `dotrino-vault pair`). El nombre viaja
+      // 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 })
       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).
@@ -156,7 +158,9 @@ export async function runDaemon () {
     const ref = () => mgr.resolve(req.profile || mgr.currentId())
     switch (req.op) {
       case 'list': return {} // el volcado de perfiles ya se hace abajo
-      case 'add': { const p = await mgr.add(req.name); return { done: `perfil creado: ${p.name || p.id}` } }
+      // `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 '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}` } }
@@ -215,7 +219,9 @@ export async function runDaemon () {
         rm(profileReqFile) // lleva la contraseña: fuera del disco cuanto antes
         let extra = {}
         try { extra = await handleProfileRequest(preq) }
-        catch (e) { extra = { error: e.message }; console.error('[vault] perfil: %s', e.message) }
+        // `code`: la TUI es bilingüe y traduce por código (un freno como el D12 tiene
+        // que leerse en el idioma de quien lo lee, no en el del daemon).
+        catch (e) { extra = { error: e.message, ...(e.code ? { code: e.code } : {}) }; console.error('[vault] perfil: %s', e.message) }
         dumpProfiles(extra)
       } else {
         dumpProfiles()

package/src/manager.js

@@ -13,6 +13,28 @@ import { openProfiles } from './profiles.js'
 import { installNodeGlobals } from './node-globals.js'
 import { dataDir, ensureDir } from './paths.js'
 
+/**
+ * D12 (`docs/acta-de-perfil.md`): la bóveda **no** borra una cuenta que ella manda si
+ * quedan otros miembros — antes tiene que pasarle el acta a un dispositivo conectado.
+ * Es D6 ("perder el master es perder la cuenta") leído al derecho: con más miembros,
+ * el que borra no la pierde solo para él.
+ *
+ * Pura a propósito (recibe el veredicto ya calculado) para poder probar la regla sin
+ * levantar un vault entero.
+ */
+export function assertCanRemove ({ isMaster, memberCount, name = '' }) {
+  if (!isMaster || memberCount <= 1) return true
+  const otros = memberCount - 1
+  const e = new Error(
+    `la cuenta "${name}" la manda esta bóveda y tiene ${otros} dispositivo(s) más: ` +
+    'pásale primero el mando a uno que esté conectado. Si la borras así, se quedan ' +
+    'con su llave y sin nadie que pueda volver a firmar el acta.'
+  )
+  e.code = 'MASTER_WITH_MEMBERS'
+  e.members = memberCount
+  throw e
+}
+
 export async function startVaultManager ({ root = dataDir(), proxyUrl, log = console.log, onEnrollChallenge } = {}) {
   ensureDir(root)
   // El keypair de transporte del proxy-client es del PROCESO, no de la identidad:
@@ -76,6 +98,21 @@ export async function startVaultManager ({ root = dataDir(), proxyUrl, log = con
     /** Borra el perfil: cierra su conexión y elimina su maestra y sus datos. */
     async remove (ref) {
       const id = profiles.resolve(ref)
+      // FRENO D12 (acta-de-perfil.md): si esta bóveda MANDA la cuenta y quedan otros
+      // miembros, borrarla los deja con su llave y sin nadie que pueda volver a sellar
+      // el acta: la cuenta muere para todos, en silencio. Primero se le pasa el mando
+      // a un dispositivo conectado. (En el dispositivo no hay tal freno: allí borrar
+      // se lleva su llave y su copia, y la cuenta sigue viva donde vive el master.)
+      const v = running.get(id)
+      if (v) {
+        const [soyMaster, acta] = await Promise.all([
+          v.isMaster().catch(() => false),
+          v.profileMembers().catch(() => ({ members: [] }))
+        ])
+        assertCanRemove({ isMaster: soyMaster, memberCount: (acta?.members || []).length, name: profiles.get(id)?.name || id })
+      } else {
+        log('[vault] perfil %s no está abierto: se borra sin poder comprobar su acta', id)
+      }
       const res = profiles.remove(id) // valida: no es el único, no está bloqueado
       try { running.get(id)?.close() } catch (_) {}
       running.delete(id)

package/src/tui/app.js

@@ -50,7 +50,8 @@ function humanErr (e, st) {
     NO_REPLY: t.errNoReply,
     NOT_APPLIED: t.errNotApplied,
     NOT_DELETED: t.errNotDeleted,
-    PAIR_FAILED: t.errPairFailed
+    PAIR_FAILED: t.errPairFailed,
+    MASTER_WITH_MEMBERS: t.errMasterWithMembers
   }
   return byCode[e?.code] || e?.message || String(e)
 }
@@ -174,6 +175,30 @@ function deviceRows (st, t) {
   return rows
 }
 
+/**
+ * LA PREGUNTA DEL EMPAREJAMIENTO. La decisión es del vault (es quien lo inicia) y
+ * este daemon puede tener varias cuentas: antes de mostrar el QR hay que decir a
+ * cuál entra el dispositivo. Hoy se responde con las dos formas que existen —una
+ * cuenta que ya vive aquí, o una nueva que se estrena para él—; la tercera
+ * («adoptar la que trae el aparato») necesita el protocolo de adopción y se
+ * muestra desactivada para no prometer lo que todavía no hace
+ * (docs/vinculacion-de-cuentas.md §5).
+ */
+function pairModeRows (st, t) {
+  const i = L(st)
+  const ap = activeProfile(st)
+  const rows = [{ text: t.muted(' ' + i.pairModeIntro), sel: false }, { text: '', sel: false }]
+  rows.push({ text: ` ${t.bold(i.pairModeHere(ap?.name || ap?.id || '—'))}`, sel: true, meta: { mode: 'here' } })
+  rows.push({ text: t.muted('     ' + i.pairModeHereHint), sel: false })
+  rows.push({ text: '', sel: false })
+  rows.push({ text: ` ${t.bold(i.pairModeNew)}`, sel: true, meta: { mode: 'new' } })
+  rows.push({ text: t.muted('     ' + i.pairModeNewHint), sel: false })
+  rows.push({ text: '', sel: false })
+  rows.push({ text: ' ' + t.muted(i.pairModeAdopt), sel: false })
+  rows.push({ text: t.muted('     (' + i.pairModeAdoptSoon + ')'), sel: false })
+  return rows
+}
+
 function secretRows (st, t) {
   const i = L(st)
   const ns = st.secrets || {}
@@ -381,9 +406,10 @@ async function onKeyDevices (term, st, key) {
   const cur = sels[Math.min(st.sel.devices, sels.length - 1)]
   const ch = key.name === 'char' ? key.ch.toLowerCase() : null
 
-  if (ch === 'p') { // pair
-    const r = await guard(term, st, i.startingPairing, () => vc.startPairing({ profile: activeId(st) }))
-    if (r.ok) { st.pairing = r.v; st.pending = null; st.screen = 'pairing' }
+  if (ch === 'p') { // pair → primero LA PREGUNTA (a qué cuenta entra), luego el QR
+    st.sel.pairmode = 0
+    st.scroll.pairmode = { value: 0 }
+    st.screen = 'pairmode'
   } else if (ch === 'a') { // aprobar el pendiente
     if (!st.pending) { flash(st, i.noPending, 'warn'); return true }
     promptApprove(term, st)
@@ -407,6 +433,50 @@ async function onKeyDevices (term, st, key) {
   return true
 }
 
+/** Abre el emparejamiento contra `profile` y salta a la pantalla del QR. */
+async function beginPairing (term, st, profile) {
+  const r = await guard(term, st, L(st).startingPairing, () => vc.startPairing({ profile }))
+  if (r.ok) { st.pairing = r.v; st.pending = null; st.screen = 'pairing' }
+  return r.ok
+}
+
+async function onKeyPairMode (term, st, key) {
+  const i = L(st)
+  const rows = pairModeRows(st, term.t)
+  const sels = rows.filter((r) => r.sel).map((r) => r.meta)
+  moveSel(st, key, 'pairmode', sels.length)
+  const cur = sels[Math.min(st.sel.pairmode, sels.length - 1)]
+  const ch = key.name === 'char' ? key.ch.toLowerCase() : null
+
+  if (key.name === 'escape' || ch === 'b') { st.screen = 'devices'; return true }
+  if (key.name !== 'enter' || !cur) return true
+
+  if (cur.mode === 'here') { await beginPairing(term, st, activeId(st)); return true }
+
+  // Cuenta nueva: se crea aquí, se ACTIVA (así aprobar/rechazar y las listas miran
+  // a la misma que el QR) y recién entonces se abre el emparejamiento contra ella.
+  setInput(st, {
+    label: i.newAccountLabel,
+    hint: i.newAccountHint,
+    onSubmit: async (name) => {
+      st.input = null
+      const nombre = name.trim()
+      if (!nombre) { flash(st, i.nameEmpty, 'danger'); return }
+      const r = await guard(term, st, i.creatingVault, () => vc.addProfile(nombre))
+      if (!r.ok) return
+      const nuevo = r.v?.id || (r.v?.profiles || []).find((p) => p.name === nombre)?.id
+      if (!nuevo) { flash(st, i.errNoReply, 'danger'); return }
+      const u = await guard(term, st, i.switchingVault, () => vc.useProfile(nuevo))
+      if (!u.ok) return
+      await refreshAll(term, st)
+      flash(st, i.accountCreated(nombre))
+      await beginPairing(term, st, nuevo)
+    },
+    onCancel: () => { st.input = null }
+  })
+  return true
+}
+
 function promptApprove (term, st) {
   const i = L(st)
   setInput(st, {
@@ -554,10 +624,15 @@ const helpSegs = (i, screen) => ({
   profiles: i.helpProfiles,
   devices: i.helpDevices,
   secrets: i.helpSecrets,
-  pairing: i.helpPairing
+  pairing: i.helpPairing,
+  pairmode: i.helpPairMode
 })[screen] || []
 
-const title = (i, screen) => (screen === 'profiles' ? i.titleProfiles : screen === 'pairing' ? i.titlePairing : '')
+const title = (i, screen) => ({
+  profiles: i.titleProfiles,
+  pairing: i.titlePairing,
+  pairmode: i.titlePairMode
+})[screen] || ''
 
 /** Barra de pestañas horizontal (Dispositivos | Scopes y variables) de la bóveda entrada. */
 function renderTabs (st, t) {
@@ -639,6 +714,7 @@ function render (term, st) {
   if (st.screen === 'profiles') body = renderList(profileRows(st, t), st.sel.profiles, contentH, cols, t, scrollRef)
   else if (st.screen === 'devices') body = renderList(deviceRows(st, t), st.sel.devices, contentH, cols, t, scrollRef)
   else if (st.screen === 'secrets') body = renderList(secretRows(st, t), st.sel.secrets, contentH, cols, t, scrollRef)
+  else if (st.screen === 'pairmode') body = renderList(pairModeRows(st, t), st.sel.pairmode, contentH, cols, t, scrollRef)
   else if (st.screen === 'pairing') {
     const pb = pairingBody(st, t, cols, contentH)
     body = pb.slice(0, contentH)
@@ -724,7 +800,7 @@ export async function runTui () {
   const st = {
     screen: 'profiles', // se arranca en la lista de bóvedas: hay que ENTRAR a una
     lang: loadLang(), // es/en — se conmuta con `l` y se recuerda en prefs.json
-    sel: { profiles: 0, devices: 0, secrets: 0 },
+    sel: { profiles: 0, devices: 0, secrets: 0, pairmode: 0 },
     scroll: {},
     profiles: null,
     devices: null,
@@ -788,6 +864,7 @@ export async function runTui () {
       if (st.screen === 'profiles') running = await onKeyProfiles(term, st, key)
       else if (st.screen === 'devices') running = await onKeyDevices(term, st, key)
       else if (st.screen === 'secrets') running = await onKeySecrets(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)
     }
   } finally {
@@ -796,4 +873,4 @@ export async function runTui () {
 }
 
 // Solo para pruebas headless (render sin terminal real). No usar en runtime.
-export const __test = { render, profileRows, deviceRows, secretRows, pairingBody, fitHelp, toggleLang }
+export const __test = { render, profileRows, deviceRows, secretRows, pairModeRows, pairingBody, fitHelp, toggleLang }

package/src/tui/i18n.js

@@ -37,6 +37,7 @@ const es = {
   tabsHint: '   (←→ cambiar)',
   titleProfiles: 'Bóvedas',
   titlePairing: 'Emparejar un dispositivo',
+  titlePairMode: 'Emparejar: ¿a qué cuenta entra?',
 
   // bóvedas (perfiles)
   noPassword: 'sin clave',
@@ -122,7 +123,17 @@ const es = {
   savingVar: 'Guardando variable…',
   varSaved: (ns, key) => `Guardado ${ns}/${key}`,
 
-  // emparejamiento
+  // emparejamiento — la PREGUNTA es del vault, que es quien lo inicia
+  pairModeIntro: 'Un dispositivo puede entrar a una cuenta que ya vive aquí, o estrenar una.',
+  pairModeHere: (name) => `Entrar a esta cuenta: ${name}`,
+  pairModeHereHint: 'el dispositivo pasa a ver y firmar lo de esta cuenta',
+  pairModeNew: 'Estrenar una cuenta nueva en este vault',
+  pairModeNewHint: 'se crea aquí, vacía, y el dispositivo entra a ELLA (las otras no se tocan)',
+  pairModeAdopt: 'Adoptar la cuenta que trae el dispositivo',
+  pairModeAdoptSoon: 'todavía no: el dispositivo aún no sabe entregar la suya',
+  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.`,
   pairUrl: 'URL: ',
@@ -144,6 +155,7 @@ const es = {
   helpDevices: ['←→ pestaña', '↑↓', 'p emparejar', 'a aprobar', 'x rechazar', 'v revocar', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
   helpSecrets: ['←→ pestaña', '↑↓', 'n nueva variable', 'x quitar (variable/scope)', 'r refrescar', 'Esc bóvedas', 'l English', 'q salir'],
   helpPairing: ['a aprobar', 'x rechazar', 'r reiniciar', 'Esc atrás', 'l English'],
+  helpPairMode: ['↑↓', 'Enter elegir', 'Esc atrás', 'l English', 'q salir'],
 
   // pantalla "daemon caído"
   downTitle: 'El daemon del vault no está corriendo.',
@@ -167,7 +179,8 @@ const es = {
   errNoReply: 'El daemon no respondió.',
   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.'
+  errPairFailed: 'El daemon no inició el emparejamiento.',
+  errMasterWithMembers: 'Esta cuenta la manda esta bóveda y tiene otros dispositivos: pásale primero el mando a uno que esté conectado. Si la borras así, se quedan con su llave y sin nadie que pueda volver a firmar el acta.'
 }
 
 // ---------------------------------- inglés ----------------------------------
@@ -190,6 +203,7 @@ const en = {
   tabsHint: '   (←→ switch)',
   titleProfiles: 'Vaults',
   titlePairing: 'Pair a device',
+  titlePairMode: 'Pairing: which account does it join?',
 
   noPassword: 'no password',
   locked: '🔒 locked',
@@ -272,6 +286,16 @@ const en = {
   savingVar: 'Saving variable…',
   varSaved: (ns, key) => `Saved ${ns}/${key}`,
 
+  pairModeIntro: 'A device can join an account that already lives here, or start a new one.',
+  pairModeHere: (name) => `Join this account: ${name}`,
+  pairModeHereHint: 'the device gets to see and sign for this account',
+  pairModeNew: 'Start a new account in this vault',
+  pairModeNewHint: 'created here, empty, and the device joins THAT one (the others are untouched)',
+  pairModeAdopt: 'Adopt the account the device brings',
+  pairModeAdoptSoon: 'not yet: the device cannot hand its own over',
+  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.`,
   pairUrl: 'URL: ',
@@ -288,6 +312,7 @@ const en = {
   helpDevices: ['←→ tab', '↑↓', 'p pair', 'a approve', 'x reject', 'v revoke', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
   helpSecrets: ['←→ tab', '↑↓', 'n new variable', 'x remove (variable/scope)', 'r refresh', 'Esc vaults', 'l Español', 'q quit'],
   helpPairing: ['a approve', 'x reject', 'r restart', 'Esc back', 'l Español'],
+  helpPairMode: ['↑↓', 'Enter choose', 'Esc back', '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',
@@ -309,7 +334,8 @@ const en = {
   errNoReply: 'The daemon did not answer.',
   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.'
+  errPairFailed: 'The daemon did not start the pairing.',
+  errMasterWithMembers: 'This vault is in charge of this account and it has other devices: hand the lead over to one that is online first. If you delete it like this, they keep their key with nobody able to sign the record again.'
 }
 
 // --------------------------- selección y persistencia -----------------------

package/src/vault.js

@@ -296,6 +296,8 @@ export async function startVault ({ dir = dataDir(), proxyUrl, log = console.log
     // Acta del perfil (quién es del perfil y qué puede cada uno): lo que muestran
     // `dotrino-vault members` y la consola de vault.dotrino.com.
     profileMembers: () => identity.profileMembers(),
+    // ¿Es ESTA bóveda la que sella el acta? Lo usa el freno de borrado (D12).
+    isMaster: () => identity.isMaster(),
     setCaps: (pub, caps) => identity.setCaps(pub, caps),
     revokeDevice: (nonce) => desk.revoke(nonce),
     close () { try { client.close() } catch (_) {} identity.destroy() }

package/src/vaultControl.js

@@ -149,7 +149,7 @@ async function profileOp (op, { profile, name, password } = {}) {
   signalOrCleanup('SIGUSR2', [F.profileReq])
   const d = await waitFor(F.profilesList)
   if (!d) throw coded('el daemon no respondió', 'NO_REPLY')
-  if (d.error) throw new Error(d.error)
+  if (d.error) throw coded(d.error, d.code) // p.ej. MASTER_WITH_MEMBERS (freno D12)
   return d // { profiles:[{id,name,protected,locked,current,fingerprint,iss,createdAt}], current, done? }
 }