@dotrino/vaultd 0.160.2 → 0.161.0

package/lib/src/core/backup.js

@@ -0,0 +1,244 @@
+/**
+ * EL RESPALDO DE LA BÓVEDA: un archivo cifrado con una contraseña, con lo que hay en los
+ * cajones y en la bóveda de contraseñas. Diseño: `docs/respaldo.md`.
+ *
+ * QUÉ LLEVA Y QUÉ NO (dueño, 2026-10-16: «como las llaves son de dispositivo, solo se
+ * respalda el contenido de sobres y cajones»):
+ *
+ *   · SÍ: los VALORES de cada cajón (`ns:<scope>`, `dev:<aparato>`, el perfil `@me`) y las
+ *     entradas de la bóveda de contraseñas, abiertos y vueltos a cerrar con la contraseña
+ *     del respaldo.
+ *   · NO: ninguna llave. Ni la maestra, ni la de comunicación, ni las de los aparatos, ni
+ *     el acta. Una llave es de su aparato; quien restaura en otra bóveda la reparte con sus
+ *     propias llaves, a los aparatos de SU acta.
+ *   · NO: el histórico. Un respaldo es lo vigente.
+ *
+ * Por qué los valores en claro (dentro del archivo cifrado) y no los sobres tal cual: los
+ * sobres van envueltos a los aparatos de ESTA cuenta y a su copia de recuperación. En otra
+ * bóveda no los abre nadie, y mover un cajón de una bóveda a otra es la mitad de lo que esto
+ * tiene que hacer.
+ *
+ * LAS DOS PUNTAS EXIGEN LA BÓVEDA ABIERTA. Exportar es leer —lo que guarda la frase—, e
+ * importar compara con lo que ya hay, que también es leer.
+ *
+ * CONFLICTOS. Importar NUNCA pisa en silencio: primero se hace un PLAN (`planImport`) que
+ * dice, valor por valor, qué es nuevo, qué es igual y qué choca. Si algo choca y quien
+ * importa no dijo qué hacer, no se escribe NADA y se devuelve la lista (`BACKUP_CONFLICTS`).
+ * Las dos respuestas posibles son `keep` (se queda lo de la bóveda) y `replace` (gana el
+ * respaldo), para todo de una vez o para cada choque.
+ *
+ * El cifrado del archivo es el de `@dotrino/passmanager` (PBKDF2-SHA256 600 000 + AES-GCM):
+ * corre igual en el navegador y en Node, así que lo que exporta una versión de la bóveda lo
+ * abre cualquiera de las otras (regla de las tres versiones).
+ */
+import { deriveKeyFromPassword, makeSalt, makeVerifier, checkVerifier, sealValue, openValue, toBase64, fromBase64 } from '@dotrino/passmanager'
+
+export const BACKUP_FORMAT = 'dotrino-vault-backup'
+export const BACKUP_VERSION = 1
+/** El nombre del cajón de las contraseñas en un respaldo. No choca con un `ns:`/`dev:`. */
+export const PASSWORDS_DRAWER = 'passwords'
+/** Mínimo de la contraseña del respaldo: el archivo se ataca fuera de línea, sin freno. */
+export const BACKUP_PWD_MIN = 12
+const KDF_ITERATIONS = 600_000
+const AAD = 'dotrino-vault-backup/v1'
+
+const coded = (message, code, extra = {}) => Object.assign(new Error(message), { code, ...extra })
+
+// --- el archivo ----------------------------------------------------------------
+
+/**
+ * CIERRA un respaldo con su contraseña. Devuelve el objeto que se escribe al archivo.
+ * Lo único en claro es el formato y la fecha: ni los nombres de los cajones salen.
+ */
+export async function sealBackup (payload, password) {
+  if (typeof password !== 'string' || password.length < BACKUP_PWD_MIN) {
+    throw coded(`the backup password must be at least ${BACKUP_PWD_MIN} characters`, 'WEAK_PASSWORD')
+  }
+  const salt = makeSalt()
+  const key = await deriveKeyFromPassword(password, salt, KDF_ITERATIONS)
+  return {
+    format: BACKUP_FORMAT,
+    v: BACKUP_VERSION,
+    createdAt: payload.createdAt,
+    kdf: { name: 'PBKDF2-SHA256', iterations: KDF_ITERATIONS, salt: toBase64(salt) },
+    verifier: await makeVerifier(key),
+    box: await sealValue(key, JSON.stringify(payload), AAD)
+  }
+}
+
+/**
+ * ABRE un respaldo. Distingue «no es un respaldo», «esa contraseña no es» y «está roto»,
+ * porque se arreglan de formas distintas.
+ */
+export async function openBackup (file, password) {
+  if (!file || file.format !== BACKUP_FORMAT) throw coded('this is not a vault backup file', 'NOT_A_BACKUP')
+  if (file.v !== BACKUP_VERSION) throw coded(`unknown backup version v${file.v}: update the vault`, 'BACKUP_VERSION')
+  if (file.kdf?.name !== 'PBKDF2-SHA256' || !file.kdf.salt || !file.kdf.iterations) {
+    throw coded('the backup file has no usable key derivation', 'BACKUP_CORRUPT')
+  }
+  const key = await deriveKeyFromPassword(String(password || ''), fromBase64(file.kdf.salt), file.kdf.iterations)
+  if (!(await checkVerifier(key, file.verifier))) throw coded('that password does not open this backup', 'WRONG_PASSWORD')
+  let payload
+  try { payload = JSON.parse(await openValue(key, file.box, AAD)) } catch (_) {
+    throw coded('the backup opens but its content cannot be read', 'BACKUP_CORRUPT')
+  }
+  if (!Array.isArray(payload?.drawers)) throw coded('the backup has no drawers', 'BACKUP_CORRUPT')
+  return payload
+}
+
+// --- qué cajones -----------------------------------------------------------------
+
+/**
+ * ¿Entra este cajón? `selected` es la lista que pidió quien exporta o importa (`null` =
+ * todos). Vale el dueño entero (`ns:proxy`, `dev:<pub>`, `passwords`) y `@me` como atajo.
+ */
+export function wants (selected, owner) {
+  if (!selected || !selected.length) return true
+  return selected.some((s) => s === owner || (s === '@me' && owner === 'ns:@me'))
+}
+
+/** Valida que todo lo pedido exista: pedir un cajón que no está no es «nada que hacer». */
+export function assertSelected (selected, available) {
+  if (!selected || !selected.length) return
+  const missing = selected.filter((s) => !available.some((o) => wants([s], o)))
+  if (missing.length) throw coded(`no such drawer: ${missing.join(', ')}`, 'NO_SUCH_DRAWER', { missing })
+}
+
+// --- importar: el plan -----------------------------------------------------------
+
+/** Lo que identifica un valor dentro de un plan: `<cajón destino> <clave>`. */
+export const itemRef = (owner, key) => `${owner} ${key}`
+
+/**
+ * EL PLAN DE IMPORTACIÓN. Puro: no lee ni escribe nada, recibe lo que hay.
+ *
+ * @param {object} payload el respaldo ya abierto
+ * @param {object} o
+ *   `selected`  qué cajones del respaldo (`null` = todos)
+ *   `map`       `{ <cajón del respaldo>: <cajón destino> }` para moverlo de nombre o de
+ *               aparato. Sin entrada, va al mismo nombre.
+ *   `current`   `{ <cajón destino>: { KEY: {value, public} } | null }` lo que ya hay
+ *   `devices`   pubs de los aparatos del acta de destino: un `dev:` solo entra si su
+ *               aparato existe aquí
+ *   `passwords` `{ entries: [...] }` lo que ya hay en la bóveda de contraseñas, abierto
+ */
+export function planImport (payload, { selected = null, map = {}, current = {}, devices = [], passwords = null } = {}) {
+  const available = payload.drawers.map((d) => d.owner)
+  assertSelected(selected, available)
+  const withDevice = new Set(devices)
+  const plan = { drawers: [], counts: { new: 0, same: 0, conflict: 0, skipped: 0 } }
+  for (const d of payload.drawers) {
+    if (!wants(selected, d.owner)) continue
+    const to = map[d.owner] || d.owner
+    if (d.owner === PASSWORDS_DRAWER) {
+      plan.drawers.push(planPasswords(d, passwords, plan.counts))
+      continue
+    }
+    const out = { from: d.owner, to, label: d.label || null, status: 'ok', items: [] }
+    if (to.startsWith('dev:') && !withDevice.has(to.slice(4))) {
+      // EL APARATO NO ESTÁ EN ESTA CUENTA. No se guarda «por si acaso»: un cajón de aparato
+      // sin aparato no lo lee nadie, y reaparecería solo si un día entra esa llave. Se dice,
+      // y se puede mover a otro aparato con `map`.
+      out.status = 'no-device'
+      plan.counts.skipped += Object.keys(d.vars || {}).length
+      plan.drawers.push(out)
+      continue
+    }
+    const have = current[to] || {}
+    for (const [key, v] of Object.entries(d.vars || {})) {
+      const existing = have[key]
+      const status = !existing ? 'new' : (existing.value === v.value ? 'same' : 'conflict')
+      plan.counts[status]++
+      out.items.push({ key, status, public: !!v.public, ...(existing ? { currentPublic: !!existing.public } : {}) })
+    }
+    plan.drawers.push(out)
+  }
+  return plan
+}
+
+/**
+ * Lo que dice que una entrada de contraseñas es «la misma» que otra: el mismo id, o los
+ * mismos sitios y el mismo usuario (una credencial por sitio y usuario).
+ */
+const sitesKey = (e) => [...(e.sites || [])].map((s) => String(s).toLowerCase()).sort().join(' ')
+const whoKey = (e) => `${sitesKey(e)}\u0000${String(e.username || '').toLowerCase()}\u0000${e.sites?.length ? '' : String(e.title || '')}`
+/** Lo que se compara para decir «igual»: el contenido, sin fechas. */
+export const entryContent = (e) => JSON.stringify({
+  type: e.type || 'login', title: e.title || '', sites: [...(e.sites || [])].sort(),
+  name: e.name || '', username: e.username || '', secret: e.secret || '', totp: e.totp || '',
+  notes: e.notes || '', fields: e.fields || '[]', webauthn: e.webauthn || null
+})
+
+function planPasswords (d, passwords, counts) {
+  const out = { from: PASSWORDS_DRAWER, to: PASSWORDS_DRAWER, status: 'ok', items: [] }
+  if (!passwords) {
+    // Sin bóveda de contraseñas en el destino no hay con quién comparar ni dónde guardar:
+    // se dice. No se inventa una llave de perfil a medias.
+    out.status = 'no-passwords'
+    counts.skipped += (d.entries || []).length
+    return out
+  }
+  const byId = new Map(passwords.entries.map((e) => [e.id, e]))
+  const byWho = new Map(passwords.entries.map((e) => [whoKey(e), e]))
+  for (const e of d.entries || []) {
+    const existing = byId.get(e.id) || byWho.get(whoKey(e)) || null
+    const status = !existing ? 'new' : (entryContent(existing) === entryContent(e) ? 'same' : 'conflict')
+    counts[status]++
+    out.items.push({ key: e.id, title: e.title || (e.sites || [])[0] || '', username: e.username || '', status, ...(existing ? { currentId: existing.id } : {}) })
+  }
+  return out
+}
+
+/**
+ * LA DECISIÓN DE CADA CHOQUE. `onConflict` vale para todos; `decisions` (por `itemRef`) manda
+ * sobre él. Si queda alguno sin decidir, se para con la lista entera: importar a medias y
+ * descubrir el resto después es peor que no importar.
+ */
+export function resolvePlan (plan, { onConflict = null, decisions = {} } = {}) {
+  if (onConflict && onConflict !== 'keep' && onConflict !== 'replace') {
+    throw coded(`unknown conflict policy "${onConflict}" (use keep or replace)`, 'BAD_POLICY')
+  }
+  const pending = []
+  for (const d of plan.drawers) {
+    for (const it of d.items) {
+      if (it.status !== 'conflict') continue
+      const r = decisions[itemRef(d.to, it.key)] || onConflict
+      if (r !== 'keep' && r !== 'replace') { pending.push({ drawer: d.to, key: it.key, ...(it.title ? { title: it.title } : {}) }); continue }
+      it.resolution = r
+    }
+  }
+  if (pending.length) {
+    throw coded(`${pending.length} conflict(s) without a decision: nothing was imported`, 'BACKUP_CONFLICTS', { conflicts: pending, plan })
+  }
+  return plan
+}
+
+/**
+ * LO QUE HAY QUE ESCRIBIR, ya resuelto: `[{ to, key, value, public }]` para los cajones y
+ * `[{ entry, replaces }]` para las contraseñas. Lo `same` y lo `keep` no se tocan.
+ *
+ * La VISIBILIDAD: si lo que había era privado, se queda privado aunque el respaldo diga
+ * público. Hacer público un secreto no puede colarse en una importación (es la misma regla
+ * de `PrivateStaysPrivate`), y se anota para decirlo.
+ */
+export function writesOf (plan, payload) {
+  const vars = []
+  const entries = []
+  const byOwner = new Map(payload.drawers.map((d) => [d.owner, d]))
+  for (const d of plan.drawers) {
+    if (d.status !== 'ok') continue
+    const src = byOwner.get(d.from)
+    for (const it of d.items) {
+      if (it.status === 'same' || (it.status === 'conflict' && it.resolution !== 'replace')) continue
+      if (d.from === PASSWORDS_DRAWER) {
+        const entry = src.entries.find((e) => e.id === it.key)
+        entries.push({ entry, replaces: it.status === 'conflict' ? it.currentId : null })
+        continue
+      }
+      const v = src.vars[it.key]
+      const keptPrivate = it.currentPublic === false && !!v.public
+      vars.push({ to: d.to, key: it.key, value: v.value, public: keptPrivate ? false : !!v.public, ...(keptPrivate ? { keptPrivate: true } : {}) })
+    }
+  }
+  return { vars, entries }
+}

package/lib/src/core/libVersion.js

@@ -5,4 +5,4 @@
  * si no coincide con la del paquete: una versión anunciada que no es la que corre es peor
  * que no anunciar ninguna.
  */
-export const LIB_VERSION = '0.88.1'
+export const LIB_VERSION = '0.89.0'

package/lib/src/core/passwords.js

@@ -52,18 +52,7 @@ export function createPasswordDesk (opts = {}) {
     log = () => {},
   } = opts
 
-  const sealed = new SealedStore(store, {
-    recipients: (kind) => members(kind),
-    /**
-     * ¿LA FIRMÓ QUIEN DICE, Y PUEDE ESCRIBIR? Es lo único que la bóveda puede comprobar
-     * sobre una entrada cuyo contenido no ve. Las dos mitades importan: la firma ata el
-     * sobre a una llave, y el acta dice si esa llave tiene algo que hacer aquí.
-     */
-    verifyAuthor: async ({ body, author }) => {
-      if (!canWrite(author?.pub)) return false
-      return verifyDeviceSig({ publickey: author.pub, data: body, signature: author.sig })
-    },
-  })
+  const sealed = openSealedPasswords({ store, members, canWrite })
 
   const responder = new SealedResponder({
     client,
@@ -103,6 +92,30 @@ export function createPasswordDesk (opts = {}) {
   }
 }
 
+/**
+ * EL ALMACÉN SELLADO DE LAS CONTRASEÑAS, sin el mostrador. Lo usa el mostrador y lo usa el
+ * respaldo (`backup.js`): el respaldo tiene que poder leer y escribir aunque ningún aparato
+ * tenga todavía `passwords` y el mostrador no se haya levantado. Una sola pieza, para que
+ * la regla de quién puede escribir no se escriba dos veces.
+ */
+/**
+ * @param {{ store?: any, members?: (kind: string) => any[], canWrite?: (pub: string) => boolean }} [o]
+ */
+export function openSealedPasswords ({ store, members = () => [], canWrite = () => false } = {}) {
+  return new SealedStore(store, {
+    recipients: (kind) => members(kind),
+    /**
+     * ¿LA FIRMÓ QUIEN DICE, Y PUEDE ESCRIBIR? Es lo único que la bóveda puede comprobar
+     * sobre una entrada cuyo contenido no ve. Las dos mitades importan: la firma ata el
+     * sobre a una llave, y el acta dice si esa llave tiene algo que hacer aquí.
+     */
+    verifyAuthor: async ({ body, author }) => {
+      if (!canWrite(author?.pub)) return false
+      return verifyDeviceSig({ publickey: author.pub, data: body, signature: author.sig })
+    },
+  })
+}
+
 /**
  * CONVERTIR LO QUE HAY (§2.7). Es un acto único y es **segundo trabajo de la maestra**: se
  * hace al ABRIR la bóveda, que es cuando la frase está a mano y hay con qué reescribirlo
@@ -122,3 +135,66 @@ export async function convertPasswords ({ store, sealed, cek, recipients, author
     log: (m) => log('[vault] ' + m)
   })
 }
+
+/**
+ * LAS CONTRASEÑAS DEL RESPALDO, abiertas con la copia de recuperación (`backup.js`).
+ *
+ * Es lectura, así que pide lo mismo que ver una variable: `openRecovery(wrap)` → la CEK, que
+ * solo funciona con la bóveda abierta. Cada entrada sale entera, con la forma de siempre
+ * (`newEntry`), para poder volver a sellarla en OTRA bóveda con sus propias llaves.
+ *
+ * Lo que no abre la copia de recuperación no se calla: `unreadable` cuenta las entradas sin
+ * envoltura `#recovery` (guardadas antes de que existiera), y `withheld` los campos sueltos
+ * que tampoco la tienen. Un respaldo que se deja cosas tiene que decirlo.
+ */
+export async function exportPasswordEntries ({ sealed, openRecovery }) {
+  const { RECOVERY, openSealedEntry } = await import('@dotrino/passmanager/sealed')
+  const { decryptWithCek } = await import('@dotrino/identity/content')
+  const stats = await sealed.stats()
+  if (!stats.sealed) return { entries: [], unreadable: stats.entries, withheld: 0 }
+  const openSealed = async ({ wrap, envelope }) => decryptWithCek({ cek: await openRecovery(wrap), envelope })
+  const views = await sealed.views({ pub: RECOVERY })
+  const entries = []
+  let withheld = 0
+  for (const v of views) {
+    const got = await sealed.get(v.id, { pub: RECOVERY })
+    const { withheld: lost = [], ...plain } = await openSealedEntry({ got, openSealed })
+    withheld += lost.length
+    entries.push(plain)
+  }
+  return { entries, unreadable: stats.entries - views.length, withheld }
+}
+
+/**
+ * VUELVE A SELLAR entradas de un respaldo en ESTA bóveda: a los aparatos de su acta y a su
+ * copia de recuperación, con la llave del perfil de aquí (la que hace las huellas de sitio).
+ *
+ * Si esta bóveda todavía no tiene llave de perfil (nunca guardó una contraseña), se estrena
+ * aquí: es lo mismo que haría al convertir, y sin ella no hay dónde guardar.
+ *
+ * `writes`: `[{ entry, replaces }]` de `writesOf`. `replaces` es el id de la entrada de aquí
+ * que se pisa; la entrada nueva toma ese id, así que el almacén la reemplaza en su sitio.
+ * `author` firma cada entrada (`{ publickey, sign }`), como cualquier aparato que escribe.
+ */
+export async function importPasswordEntries ({ sealed, openRecovery, recipients, author, writes = [] }) {
+  if (!writes.length) return { written: 0 }
+  const { RECOVERY, profileKeys, buildSealedEntry, buildProfileKey } = await import('@dotrino/passmanager/sealed')
+  const { decryptWithCek } = await import('@dotrino/identity/content')
+  let base
+  if ((await sealed.stats()).sealed) {
+    const p = await sealed.profile({ pub: RECOVERY })
+    base = await decryptWithCek({ cek: await openRecovery(p.wrap), envelope: p.envelope })
+  } else {
+    const k = await buildProfileKey({ recipients })
+    await sealed.setProfile({ envelope: k.envelope, wraps: k.wraps })
+    base = k.base
+  }
+  const keys = await profileKeys(base)
+  let written = 0
+  for (const { entry, replaces } of writes) {
+    const built = await buildSealedEntry({ plain: { ...entry, id: replaces || entry.id }, keys, recipients, author })
+    await sealed.putSealed({ ...built, by: author.publickey })
+    written++
+  }
+  return { written }
+}

package/lib/src/core/secretsStore.js

@@ -96,6 +96,16 @@ export function assertProfileKey (key) {
   }
 }
 
+/** Lo más largo que puede ser un dato del perfil (una foto pequeña cabe). */
+const MAX_PROFILE_LEN = 200000
+
+/** Valida un dato del perfil: su nombre (`assertProfileKey`) y su valor. */
+export function assertProfileValue (key, value) {
+  assertProfileKey(key)
+  if (typeof value !== 'string' || !value) throw new Error('value must be a non-empty string')
+  if (value.length > MAX_PROFILE_LEN) throw new Error(`profile value too long (max ${MAX_PROFILE_LEN})`)
+}
+
 /** Cuántas versiones anteriores se conservan, en total. Ver «EL HISTÓRICO» arriba. */
 const MAX_HISTORY = 500
 
@@ -555,6 +565,52 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
       return out
     },
 
+    /**
+     * UN CAJÓN ENTERO, ABIERTO. Es para el RESPALDO (`backup.js`), y por eso pide lo mismo
+     * que ver un valor: la copia de recuperación, o sea la bóveda abierta. Se abre UNA vez
+     * y se usa para todas las variables.
+     *
+     * Lo público del perfil (`cls: 'public'`) no tiene sobre: se guarda en claro y firmado,
+     * y sale tal cual. El histórico no sale: un respaldo es lo vigente.
+     *
+     * @returns {Promise<Object<string,{value:string, public:boolean}>|null>} `null` si el
+     *   cajón no existe.
+     */
+    async exportDrawer (owner, adminKey = null) {
+      const [kind, k] = splitOwner(owner)
+      const bag = kind === 'ns' ? data.ns : data.dev
+      if (!bag[k]) return null
+      if (needsMigration()) throw new NeedsMigration()
+      const vars = varsOf(bag, k)
+      /** @type {Object<string,{value:string, public:boolean}>} */
+      const out = {}
+      let priv = null
+      for (const [key, e] of Object.entries(vars)) {
+        if (e?.cls === 'public' && typeof e.pubv === 'string') { out[key] = { value: e.pubv, public: true }; continue }
+        if (isLegacy()) { out[key] = { value: e.v, public: !!e.pub }; continue }
+        if (!priv) priv = await openRecovery(adminKey)
+        out[key] = { value: await sealer.openValue(await this._cekOf(bag, k, e.gen, priv), e.e), public: !!e.pub }
+      }
+      return out
+    },
+
+    /**
+     * ESCRIBE UN VALOR IMPORTADO en cualquier cajón, también en el del perfil.
+     *
+     * Es escribir y nada más (no pide la frase): lo de `@me` público va por
+     * `profilePutPublic`, como lo escribiría un aparato; lo demás, por el mismo camino que
+     * `set`. Lo que decide si se escribe —el conflicto con lo que ya había— lo decide
+     * `backup.js` antes de llegar aquí.
+     */
+    async importValue (owner, key, value, isPublic, { by = null } = {}) {
+      if (owner === PROFILE_OWNER && isPublic) return this.profilePutPublic(key, value, { by })
+      const [kind, k] = splitOwner(owner)
+      if (kind === 'ns' && owner !== PROFILE_OWNER) assertNs(k)
+      else if (kind === 'dev') assertPub(k)
+      else if (kind !== 'ns') throw new Error('invalid drawer: expected "ns:<name>" or "dev:<pubkey>"')
+      return this._put(kind === 'ns' ? data.ns : data.dev, k, owner, key, value, isPublic, by)
+    },
+
     // --- escritura: NO pide la frase (§8.1) --------------------------------------
     /**
      * Escribe en un cajón. `isPublic` es OPCIONAL a propósito: sin decir nada se
@@ -575,7 +631,10 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
     async _put (...a) { return enFila(() => this._putRaw(...a)) },
     /** @private El cuerpo, ya en fila (ver `enFila`). */
     async _putRaw (bag, k, owner, key, value, isPublic, by) {
-      assertKeyValue(key, value)
+      // El cajón del perfil tiene su propio alfabeto (`nickname`, no `NICKNAME`). Por aquí
+      // solo llega con `importValue`: `set` ya rechaza `@me` como nombre de cajón.
+      if (owner === PROFILE_OWNER) assertProfileValue(key, value)
+      else assertKeyValue(key, value)
       const vars = ensureBag(bag, k)
       const before = vars[key]
       const pub = isPublic === undefined ? !!before?.pub : !!isPublic
@@ -949,7 +1008,7 @@ export function openSecretsStore (disk, { sealer = null, recipients = null, sign
         if (isLegacy()) throw new Error('profile: this store is still v3 (run `migrate` first)')
         if (needsMigration()) throw new NeedsMigration()
         assertProfileKey(key)
-        if (typeof value !== 'string' || value.length > 200000) {
+        if (typeof value !== 'string' || value.length > MAX_PROFILE_LEN) {
           throw new Error('a public profile field must be a string of at most 200 kB')
         }
         const vars = ensureBag(data.ns, PROFILE_NS)

package/lib/src/core/vault.js

@@ -40,6 +40,7 @@ import { createApprovals, createGrants, lastApproverGone, PENDING_TTL_MS, GRANT_
 import { sanitizeContext, commandFingerprint, commandLine } from '../procContext.js'
 import { makeContentKey, encryptWithCek, wrapForMember } from '@dotrino/identity/content'
 import { makeSealer } from './sealer.js'
+import { BACKUP_VERSION, PASSWORDS_DRAWER, wants, assertSelected, planImport, resolvePlan, writesOf } from './backup.js'
 import { openSealKeys } from './sealKey.js'
 import { openCommKey, COMM_CN, COMM_CAPS } from './commKey.js'
 import { seal } from '../sealed.js'
@@ -317,6 +318,14 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
    * queda fuera y se ve en `incompleteMembers`.
    */
   const noEsLaBoveda = (pub) => pub !== master && pub !== commKey.pub()
+  /**
+   * ¿PUEDE ESCRIBIR UNA CONTRASEÑA? Un aparato del acta con `passwords`… y la MAESTRA de esta
+   * bóveda, que es quien reescribe al convertir (`sealPasswords`) y al importar un respaldo.
+   * Las dos cosas pasan con la bóveda abierta y son rehacer sobres, su segundo trabajo. Sin
+   * ella, las dos fallaban con `bad-author`: firmaban con la maestra y la regla solo miraba
+   * el acta. Escribir no le da a la bóveda ninguna envoltura: sigue sin poder leer nada.
+   */
+  const canWritePasswords = (pub) => !!pub && (pub === master || (!!actaCache && Acta.memberCan(actaCache, pub, 'passwords')))
   const passwordRecipients = (_kind = 'main') => (actaCache?.members || [])
     .filter((m) => m.encPub && noEsLaBoveda(m.pub) && Acta.memberCan(actaCache, m.pub, 'passwords'))
     .map((m) => ({ pub: m.pub, encPub: m.encPub }))
@@ -2330,7 +2339,7 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
       // aparato—. Ninguna de las dos abre nada por sí sola.
       members: (kind) => passwordRecipients(kind),
       recoveryPub: () => secrets.recoveryPub(),
-      canWrite: (pub) => !!actaCache && !!pub && Acta.memberCan(actaCache, pub, 'passwords'),
+      canWrite: canWritePasswords,
       // UNA sola condición, y es del ACTA: el aparato tiene la capacidad `passwords`.
       // Quitársela —o quitar el aparato— le corta esto en la siguiente pasada, sin
       // que haya una segunda lista que acordarse de tocar.
@@ -3946,6 +3955,163 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     return secrets.openBundle(ns, devicePub, adminKey)
   }
 
+  // --- EL RESPALDO (`backup.js`, `docs/respaldo.md`) ------------------------------------
+  //
+  // Las dos puntas son de BÓVEDA ABIERTA (dueño, 2026-10-16): exportar lee todo, e importar
+  // compara con lo que ya hay. Cerrada se para y se dice, sin intentar con la llave de la
+  // máquina.
+
+  const needOpen = () => {
+    if (isLocked()) throw Object.assign(new Error('the vault is locked: open it to back up or restore'), { code: 'VAULT_LOCKED' })
+  }
+  /** El almacén sellado de las contraseñas: el del mostrador si está, o uno igual. */
+  const sealedPasswords = async () => {
+    if (passwords?.sealed) return passwords.sealed
+    const { openSealedPasswords } = await import('./passwords.js')
+    return openSealedPasswords({ store: passwordsStore, members: (kind) => passwordRecipients(kind), canWrite: canWritePasswords })
+  }
+  const passwordsRecovery = (adminKey) => (wrap) => secrets.openRecoveryWrap(wrap, adminKey)
+  /** Lo que hay en las contraseñas, abierto. `null` si no hay ni una. */
+  async function passwordEntries (adminKey) {
+    const { exportPasswordEntries } = await import('./passwords.js')
+    return exportPasswordEntries({ sealed: await sealedPasswords(), openRecovery: passwordsRecovery(adminKey) })
+  }
+  /** Cómo se llama un cajón para quien lo lee: el del aparato, con su ID y su nombre. */
+  const drawerLabel = (owner) => {
+    if (!owner.startsWith('dev:')) return null
+    const pub = owner.slice(4)
+    const m = (actaCache?.members || []).find((x) => x.pub === pub)
+    return { id: pubkeyId(pub), label: m?.label || m?.cn || null }
+  }
+
+  /**
+   * LOS CAJONES QUE HAY, con cuántos valores tiene cada uno. Es lo que se enseña antes de
+   * elegir qué respaldar: nombres y cuentas, nunca valores.
+   */
+  async function backupDrawers () {
+    const out = secrets.owners().map((owner) => ({
+      owner,
+      count: owner.startsWith('dev:')
+        ? (secrets.listDevices()[owner.slice(4)] || []).length
+        : (secrets.list()[owner.slice(3)] || []).length,
+      ...(drawerLabel(owner) ? { device: drawerLabel(owner) } : {})
+    }))
+    const st = await (await sealedPasswords()).stats()
+    if (st.entries) out.push({ owner: PASSWORDS_DRAWER, count: st.entries })
+    return out
+  }
+
+  /**
+   * EXPORTA un respaldo: todo, o los cajones pedidos (`drawers`). Devuelve lo que se va a
+   * cifrar (`payload`) y el resumen de lo que lleva — quien llama lo cifra con la contraseña
+   * del respaldo (`sealBackup`), que no tiene por qué pasar por aquí.
+   */
+  async function exportBackup ({ drawers = null, adminKey = null } = {}) {
+    needOpen()
+    await refreshActa()
+    const owners = secrets.owners()
+    const pwd = (!drawers || wants(drawers, PASSWORDS_DRAWER)) ? await passwordEntries(adminKey) : null
+    const available = [...owners, ...(pwd && (pwd.entries.length || pwd.unreadable) ? [PASSWORDS_DRAWER] : [])]
+    assertSelected(drawers, available)
+    /** @type {Array<{owner: string, label?: any, vars?: Object<string,{value:string, public:boolean}>, entries?: any[]}>} */
+    const out = []
+    for (const owner of owners) {
+      if (!wants(drawers, owner)) continue
+      const vars = await secrets.exportDrawer(owner, adminKey)
+      if (!vars) continue
+      const label = drawerLabel(owner)
+      out.push({ owner, ...(label ? { label } : {}), vars })
+    }
+    if (pwd && wants(drawers, PASSWORDS_DRAWER) && pwd.entries.length) out.push({ owner: PASSWORDS_DRAWER, entries: pwd.entries })
+    const payload = { v: BACKUP_VERSION, createdAt: Date.now(), account: fp || null, drawers: out }
+    const summary = {
+      drawers: out.map((d) => ({ owner: d.owner, count: d.entries ? d.entries.length : Object.keys(d.vars).length, ...(d.label ? { device: d.label } : {}) })),
+      ...(pwd?.unreadable ? { passwordsUnreadable: pwd.unreadable } : {}),
+      ...(pwd?.withheld ? { passwordFieldsWithheld: pwd.withheld } : {})
+    }
+    audit('backup.export', { drawers: out.length })
+    return { payload, summary }
+  }
+
+  /** Lo que ya hay en los cajones de destino del plan, abierto, para compararlo. */
+  async function currentFor (payload, { selected, map, adminKey }) {
+    const current = {}
+    for (const d of payload.drawers) {
+      if (d.owner === PASSWORDS_DRAWER || !wants(selected, d.owner)) continue
+      const to = map[d.owner] || d.owner
+      if (!(to in current)) current[to] = await secrets.exportDrawer(to, adminKey)
+    }
+    return current
+  }
+
+  /**
+   * EL PLAN de importar un respaldo ya abierto: qué es nuevo, qué es igual y qué choca. No
+   * escribe nada. `map` mueve un cajón a otro nombre (o a otro aparato).
+   */
+  async function planBackupImport (payload, { drawers = null, map = {}, adminKey = null } = {}) {
+    needOpen()
+    await refreshActa()
+    const current = await currentFor(payload, { selected: drawers, map, adminKey })
+    const withPasswords = payload.drawers.some((d) => d.owner === PASSWORDS_DRAWER && wants(drawers, d.owner))
+    const pwd = withPasswords ? await passwordEntries(adminKey) : null
+    return planImport(payload, {
+      selected: drawers,
+      map,
+      current,
+      devices: (actaCache?.members || []).map((m) => m.pub),
+      passwords: pwd ? { entries: pwd.entries } : null
+    })
+  }
+
+  /**
+   * IMPORTA. Rehace el plan aquí mismo —no se fía de uno viejo: entre el plan y el sí, la
+   * bóveda pudo cambiar— y si queda algún choque sin decidir no escribe nada
+   * (`BACKUP_CONFLICTS`, con la lista).
+   *
+   * Todo lo de los cajones entra en UN guardado por cajón y con un solo aviso a sus
+   * servicios, como una carga en grupo.
+   */
+  async function importBackup (payload, { drawers = null, map = {}, onConflict = null, decisions = {}, adminKey = null } = {}) {
+    const plan = resolvePlan(await planBackupImport(payload, { drawers, map, adminKey }), { onConflict, decisions })
+    const { vars, entries } = writesOf(plan, payload)
+    const touched = new Set()
+    await secrets.batch(async () => {
+      for (const w of vars) {
+        await secrets.importValue(w.to, w.key, w.value, w.public, { by: null })
+        touched.add(w.to)
+      }
+    })
+    let pwdWritten = 0
+    if (entries.length) {
+      const { importPasswordEntries } = await import('./passwords.js')
+      const r = await importPasswordEntries({
+        sealed: await sealedPasswords(),
+        openRecovery: passwordsRecovery(adminKey),
+        recipients: { recoveryPub: secrets.recoveryPub(), main: passwordRecipients('main'), passkeys: passwordRecipients('passkeys') },
+        // LA MAESTRA FIRMA LO QUE ESCRIBE, igual que al convertir (`sealPasswords`): la bóveda
+        // está abierta y esto es rehacer sobres. Lo que se le envuelve sigue siendo nada.
+        author: { publickey: master, sign: (body) => identity.signData(body) },
+        writes: entries
+      })
+      pwdWritten = r.written
+    }
+    // Como cualquier carga en grupo: saldar lo que se deba y un solo aviso por cajón.
+    for (const owner of touched) {
+      await settleDebts(owner)
+      if (owner.startsWith('dev:')) scheduleDeviceNotice(owner.slice(4))
+      else if (owner !== PROFILE_OWNER) scheduleNotice(owner.slice(3))
+    }
+    const result = {
+      written: vars.length + pwdWritten,
+      kept: plan.drawers.reduce((n, d) => n + d.items.filter((i) => i.resolution === 'keep').length, 0),
+      same: plan.counts.same,
+      skipped: plan.drawers.filter((d) => d.status !== 'ok').map((d) => ({ from: d.from, to: d.to, status: d.status })),
+      keptPrivate: vars.filter((w) => w.keptPrivate).map((w) => ({ drawer: w.to, key: w.key }))
+    }
+    audit('backup.import', { written: result.written, kept: result.kept, drawers: touched.size + (pwdWritten ? 1 : 0) })
+    return result
+  }
+
   /**
    * CAMBIA LOS PERMISOS DE UNO O VARIOS APARATOS EN UNA SOLA ACTA. `changes`: `[{ pub, caps }]`,
    * cada `caps` la lista COMPLETA de ese aparato.
@@ -4274,6 +4440,8 @@ export async function startVault ({ platform, proxyUrl, log = console.log, onEnr
     // frontera de verdad (que el valor de una privada no salga ni dentro del sobre).
     vars: varsDesk,
     setSecret, deleteSecret, renameSecret, renameDeviceSecret, listSecrets, setSecretVisibility, openSecrets,
+    // El respaldo: exportar, ver el plan e importar. Las tres con la bóveda abierta.
+    backupDrawers, exportBackup, planBackupImport, importBackup,
     // Sella un `secrets.json` v3 entero. Es el punto de no retorno del despliegue y
     // por eso es una operación con nombre propio, no algo que ocurra de refilón al
     // desbloquear: deja `secrets.json.v3.bak` para poder volver.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/vaultd",
-  "version": "0.160.2",
+  "version": "0.161.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": {
@@ -24,7 +24,7 @@
     "@dotrino/compat": "0.4.0",
     "@dotrino/identity": "^0.118.0",
     "@dotrino/opaque": "0.1.0",
-    "@dotrino/passmanager": "0.18.3",
+    "@dotrino/passmanager": "0.18.4",
     "@dotrino/proxy-client": "^0.36.1",
     "@dotrino/roadmap": "0.4.26",
     "@dotrino/store": "0.11.0",

package/src/ctl.js

@@ -2305,6 +2305,226 @@ async function cmdTui () {
   await runTui()
 }
 
+// ---------------------------------------------------------------------------
+// EL RESPALDO (`docs/respaldo.md`): un archivo cifrado con una contraseña propia con los
+// valores de los cajones y las contraseñas. Las llaves no van: son de cada aparato.
+//
+// Las dos puntas son de bóveda ABIERTA. El archivo lo cierra el daemon, así que lo que
+// llega aquí ya va cifrado; y al importar, lo que se enseña son nombres y estados.
+// ---------------------------------------------------------------------------
+
+const DEVICE_ID_RE = /^[0-9A-F]{4}-[0-9A-F]{4}$/i
+
+/** Cómo se llama un cajón para quien lee. */
+function drawerName (owner, device) {
+  if (owner === 'passwords') return 'contraseñas'
+  if (owner === 'ns:@me') return '@me (tu perfil)'
+  if (owner.startsWith('ns:')) return owner.slice(3)
+  const d = device || {}
+  return `aparato ${d.id || pubkeyId(owner.slice(4))}${d.label ? ' (' + d.label + ')' : ''}`
+}
+
+/**
+ * De lo que escribe quien usa el comando al nombre del cajón. `devices`: `[{id, owner}]`
+ * para traducir un ID de aparato. Lo que no se reconoce se queda como está y lo rechaza
+ * la bóveda con su nombre (`NO_SUCH_DRAWER`), en vez de adivinar.
+ */
+function drawerArg (word, devices = []) {
+  const w = String(word)
+  if (/^(contrase(n|ñ)as|passwords)$/i.test(w)) return 'passwords'
+  if (w === '@me' || w === 'perfil' || w === 'ns:@me') return 'ns:@me'
+  if (w.startsWith('ns:') || w.startsWith('dev:')) return w
+  if (DEVICE_ID_RE.test(w)) return devices.find((d) => d.id === w.toUpperCase())?.owner || `dev:?${w.toUpperCase()}`
+  return 'ns:' + w
+}
+
+/** Una orden de respaldo al daemon, y su respuesta (o su error, con código). */
+async function backupRequest (req, { timeoutMs = 120_000 } = {}) {
+  const s = requireDaemon()
+  const listFile = path.join(dataDir(), 'secrets-list.json')
+  const id = crypto.randomBytes(8).toString('hex')
+  try { fs.rmSync(listFile, { force: true }) } catch (_) {}
+  writeReq('secret-request.json', { ...req, id })
+  writeReq('dump-request.json', {})
+  sendSignal(s.pid, 'SIGUSR2')
+  for (let i = 0; i < timeoutMs / 100; i++) {
+    await sleep(100)
+    const d = ipcRead(listFile, null)
+    if (!d?.at) continue
+    try { fs.rmSync(listFile, { force: true }) } catch (_) {}
+    assertOpen(d)
+    if (d.backup?.id === id) return d.backup
+    if (d.secretError?.id === id) throw Object.assign(new Error(d.secretError.error), d.secretError)
+  }
+  throw Object.assign(new Error('the daemon did not reply'), { code: 'NO_REPLY' })
+}
+
+function backupFail (e) {
+  const msg = {
+    VAULT_LOCKED: 'La bóveda está cerrada. Ábrela con:  dotrino-vault unlock',
+    WRONG_PASSWORD: 'Esa contraseña no abre este respaldo.',
+    NOT_A_BACKUP: 'Ese archivo no es un respaldo de la bóveda.',
+    BACKUP_CORRUPT: 'El respaldo está dañado: no se puede leer.',
+    WEAK_PASSWORD: 'La contraseña del respaldo tiene que tener al menos 12 caracteres.',
+    NO_SUCH_DRAWER: `No existe ese cajón: ${(e.missing || []).join(', ')}. Míralos con:  dotrino-vault backup list`,
+    NO_REPLY: 'El daemon no respondió.'
+  }[e.code]
+  console.error(msg || `No se pudo: ${e.message}`)
+  process.exit(1)
+}
+
+async function askBackupPassword ({ twice }) {
+  let pwd
+  try {
+    pwd = await askPassword('Contraseña del respaldo: ')
+    if (twice) {
+      if (pwd.length < 12) { console.error('Tiene que tener al menos 12 caracteres. Varias palabras al azar funcionan bien.'); process.exit(1) }
+      const again = await askPassword('Repítela: ')
+      if (again !== pwd) { console.error('No coinciden.'); process.exit(1) }
+    }
+  } catch (_) {
+    console.error('Hace falta un terminal para escribir la contraseña del respaldo.')
+    process.exit(1)
+  }
+  if (!pwd) { console.error('Cancelado.'); process.exit(1) }
+  return pwd
+}
+
+async function cmdBackup (rest) {
+  const [sub, ...args] = rest
+  const flag = (name) => { const i = args.indexOf(name); if (i < 0) return null; const v = args[i + 1]; args.splice(i, 2); return v }
+  const has = (name) => { const i = args.indexOf(name); if (i < 0) return false; args.splice(i, 1); return true }
+
+  if (sub === 'list') {
+    const r = await backupRequest({ op: 'backup-drawers' }).catch(backupFail)
+    if (!r.drawers.length) { console.log('No hay nada que respaldar todavía.'); return }
+    console.log('\n%sCajones%s\n', B, Z)
+    for (const d of r.drawers) console.log('  %s  %s', drawerName(d.owner, d.device).padEnd(36), `${d.count} ${d.owner === 'passwords' ? 'entrada(s)' : 'valor(es)'}`)
+    console.log('\nTodo:          dotrino-vault backup export')
+    console.log('Solo algunos:  dotrino-vault backup export proxy @me contrasenas <ID>\n')
+    return
+  }
+
+  if (sub === 'export') {
+    let out = flag('-o') || flag('--out')
+    let selected = null
+    if (args.length) {
+      const known = (await backupRequest({ op: 'backup-drawers' }).catch(backupFail)).drawers
+        .filter((d) => d.device).map((d) => ({ id: d.device.id, owner: d.owner }))
+      selected = args.map((a) => drawerArg(a, known))
+    }
+    if (!out) out = `dotrino-vault-backup-${new Date().toISOString().slice(0, 10)}.json`
+    if (fs.existsSync(out)) { console.error('%s ya existe. Elige otro nombre con:  -o <archivo>', out); process.exit(1) }
+    const backupPassword = await askBackupPassword({ twice: true })
+    const r = await backupRequest({ op: 'backup-export', drawers: selected, backupPassword }).catch(backupFail)
+    fs.writeFileSync(out, JSON.stringify(r.file, null, 2) + '\n', { mode: 0o600 })
+    console.log('\nRespaldo guardado en %s%s%s\n', B, out, Z)
+    for (const d of r.summary.drawers) console.log('  %s  %d', drawerName(d.owner, d.device).padEnd(36), d.count)
+    if (r.summary.passwordsUnreadable) {
+      console.log('\n%s¡OJO!%s %d contraseña(s) NO entran en el respaldo: se guardaron antes de que existiera', B, Z, r.summary.passwordsUnreadable)
+      console.log('la copia de recuperación. Ábrelas una vez desde un aparato con «contraseñas» y repite el respaldo.')
+    }
+    if (r.summary.passwordFieldsWithheld) {
+      console.log('\n%s¡OJO!%s %d campo(s) de contraseñas no se pudieron abrir y faltan en el respaldo.', B, Z, r.summary.passwordFieldsWithheld)
+    }
+    console.log('\nLa contraseña del respaldo no se puede recuperar. Sin ella el archivo no se abre.\n')
+    return
+  }
+
+  if (sub === 'import') {
+    const onConflict = flag('--on-conflict')
+    if (onConflict && onConflict !== 'keep' && onConflict !== 'replace') {
+      console.error('--on-conflict es keep (conserva lo de aquí) o replace (gana el respaldo).'); process.exit(2)
+    }
+    const yes = has('--yes') || has('-y')
+    const maps = []
+    for (let a; (a = flag('--as'));) maps.push(a)
+    const [file, ...wanted] = args
+    if (!file) { console.error('Uso:  dotrino-vault backup import <archivo> [cajón…] [--as <de>=<a>] [--on-conflict keep|replace]'); process.exit(2) }
+    let sealed
+    try { sealed = JSON.parse(fs.readFileSync(file, 'utf8')) } catch (e) { console.error('No se pudo leer %s: %s', file, e.message); process.exit(1) }
+    const backupPassword = await askBackupPassword({ twice: false })
+
+    // Primero lo que trae el respaldo, para poder nombrar sus cajones (y sus aparatos).
+    const all = (await backupRequest({ op: 'backup-plan', file: sealed, backupPassword }).catch(backupFail)).plan
+    const fromDevices = all.drawers.filter((d) => d.label?.id).map((d) => ({ id: d.label.id, owner: d.from }))
+    const drawers = wanted.length ? wanted.map((w) => drawerArg(w, fromDevices)) : null
+    const map = {}
+    for (const m of maps) {
+      const [from, to] = m.split('=')
+      if (!from || !to) { console.error('--as va así:  --as proxy=proxy-nuevo  (o --as <ID>=<ID> para un aparato)'); process.exit(2) }
+      const target = DEVICE_ID_RE.test(to) ? `dev:${(await findMember(to)).pub}` : drawerArg(to)
+      map[drawerArg(from, fromDevices)] = target
+    }
+
+    const plan = (await backupRequest({ op: 'backup-plan', file: sealed, backupPassword, drawers, map }).catch(backupFail)).plan
+    const label = { new: 'nuevo', same: 'igual', conflict: 'CHOCA' }
+    console.log('')
+    for (const d of plan.drawers) {
+      const dest = d.from === d.to ? drawerName(d.to, d.label) : `${drawerName(d.from, d.label)} → ${drawerName(d.to)}`
+      if (d.status === 'no-device') { console.log('%s%s%s  no entra: ese aparato no está en esta cuenta (muévelo con --as <ID>=<ID>)', B, dest, Z); continue }
+      console.log('%s%s%s', B, dest, Z)
+      for (const it of d.items) console.log('  %s %s', (label[it.status] || it.status).padEnd(7), it.title ? `${it.title}${it.username ? ' · ' + it.username : ''}` : it.key)
+    }
+    const c = plan.counts
+    console.log('\n%d nuevo(s) · %d igual(es) · %d choque(s)%s\n', c.new, c.same, c.conflict, c.skipped ? ` · ${c.skipped} sin destino` : '')
+
+    // LOS CHOQUES: o los decide la bandera, o se preguntan uno a uno. Sin terminal y sin
+    // bandera se para: decidir por defecto sería pisar (o perder) algo sin que nadie lo vea.
+    const decisions = {}
+    if (c.conflict && !onConflict) {
+      if (!process.stdin.isTTY) {
+        console.error('Hay choques y no dijiste qué hacer. Repite con  --on-conflict keep  (conserva lo de aquí)')
+        console.error('o  --on-conflict replace  (gana el respaldo). No se importó nada.')
+        process.exit(1)
+      }
+      let forAll = null
+      for (const d of plan.drawers) {
+        for (const it of d.items) {
+          if (it.status !== 'conflict') continue
+          if (!forAll) {
+            const name = it.title ? `${it.title}${it.username ? ' · ' + it.username : ''}` : it.key
+            const a = (await askText(`${drawerName(d.to, d.label)} · ${name}: [c]onservar lo de aquí, [r]eemplazar, [C]/[R] todos los demás: `)).trim()
+            if (a === 'C') forAll = 'keep'
+            else if (a === 'R') forAll = 'replace'
+            else if (a === 'c' || a === 'r') { decisions[`${d.to} ${it.key}`] = a === 'c' ? 'keep' : 'replace'; continue }
+            else { console.error('Cancelado. No se importó nada.'); process.exit(1) }
+          }
+          decisions[`${d.to} ${it.key}`] = forAll
+        }
+      }
+    }
+    if (!c.new && !Object.values(decisions).includes('replace') && onConflict !== 'replace') { console.log('No hay nada que importar.'); return }
+    if (!yes) {
+      const a = (await askText('¿Importar? [s/N] ')).trim().toLowerCase()
+      if (a !== 's' && a !== 'si' && a !== 'sí') { console.log('No se importó nada.'); return }
+    }
+    let r
+    try {
+      r = await backupRequest({ op: 'backup-import', file: sealed, backupPassword, drawers, map, onConflict, decisions })
+    } catch (e) {
+      if (e.code === 'BACKUP_CONFLICTS') {
+        // La bóveda cambió entre el plan y el sí: hay un choque que no estaba.
+        console.error('Apareció un choque nuevo mientras decidías (la bóveda cambió). No se importó nada; repite la orden.')
+        process.exit(1)
+      }
+      backupFail(e)
+    }
+    console.log('\nImportado: %d escrito(s), %d conservado(s), %d ya igual(es).', r.result.written, r.result.kept, r.result.same)
+    for (const k of r.result.keptPrivate) console.log('  %s · %s se queda privada: aquí ya era privada.', drawerName(k.drawer), k.key)
+    console.log('')
+    return
+  }
+
+  console.error(`Uso:
+  dotrino-vault backup list                          qué cajones hay
+  dotrino-vault backup export [cajón…] [-o archivo]  todo, o solo esos cajones
+  dotrino-vault backup import <archivo> [cajón…] [--as <de>=<a>] [--on-conflict keep|replace] [--yes]
+
+  Un cajón es el nombre de un scope (proxy), @me (tu perfil), contrasenas, o el ID de un aparato.`)
+  process.exit(2)
+}
+
 function help () {
   console.log(`dotrino-vault — control del certificador personal
 
@@ -2369,6 +2589,17 @@ function help () {
                                     privada, y una privada NO se vuelve pública.
   secret visibility <ns> <CLAVE> private               tapa una pública sin tocar el valor
   secret device visibility <ID> <CLAVE> private
+  backup list         qué cajones hay para respaldar (nombres y cuántos valores)
+  backup export [cajón…] [-o archivo]
+                      un archivo cifrado con una contraseña propia, con los valores de
+                      TODOS los cajones o solo de los que digas (proxy, @me, contrasenas,
+                      el ID de un aparato). Las llaves no van: son de cada aparato.
+                      Bóveda abierta
+  backup import <archivo> [cajón…] [--as <de>=<a>] [--on-conflict keep|replace] [--yes]
+                      lo trae a esta bóveda y lo vuelve a sellar con sus llaves. Primero
+                      enseña qué es nuevo, qué es igual y qué choca; un choque se decide
+                      (conservar o reemplazar) o no se importa nada. --as mueve un cajón a
+                      otro nombre o a otro aparato. Bóveda abierta
   join <invitación> [--name <n>] [--kms <config.json>]
                       ESTA bóveda ENTRA en la cuenta de otra (el papel contrario a pair).
                       Entra con su propia llave, así que después se le puede dar +sella
@@ -2575,6 +2806,7 @@ export async function runCtl (argv) {
     case 'logins': return cmdLogins(rest)
     case 'update': return cmdUpdate(rest)
     case 'secret': return cmdSecret(rest)
+    case 'backup': return cmdBackup(rest)
     // `approval` se quitó el 2026-09-01 (ahora es el permiso `unattended`), pero la ruta se
     // quedó apuntando a una función que ya no existía: reventaba con un ReferenceError. Se
     // rechaza en voz alta, igual que `caps +approval`.

package/src/daemon.js

@@ -31,6 +31,7 @@ import { readSettings } from './settings.js'
 import { approversOfAll, firstYes, readAsked, writeAsked, clearAsked, shouldAsk, resultOfNo, readRootTold, writeRootTold, shouldTellRoot } from './updateApproval.js'
 import { UPDATE_TTL_MS } from '../lib/src/core/approvals.js'
 import crypto from 'node:crypto'
+import { sealBackup, openBackup } from '../lib/src/core/backup.js'
 
 const readJsonSafe = (f) => ipcRead(f, null)
 const rm = (f) => { try { fs.rmSync(f, { force: true }) } catch (_) {} }
@@ -366,6 +367,12 @@ export async function runDaemon () {
   let lastSecretValue = null
   /** Y las versiones anteriores que se acaban de pedir. Mismo camino, mismo volcado. */
   let lastSecretHistory = null
+  /**
+   * Lo que contestó la última orden de RESPALDO (`dotrino-vault backup`). Mismo camino que
+   * `lastSecretValue`. Lo que viaja nunca es un valor en claro: el respaldo sale YA CIFRADO
+   * con su contraseña, y el plan de importar lleva nombres y estados, no valores.
+   */
+  let lastBackup = null
   // ENTRAR CON USUARIO Y CONTRASEÑA, desde esta máquina (`dotrino-vault logins`).
   //
   // La respuesta NO se llama `logins.json`: ese nombre ya es el almacén del escritorio en
@@ -802,6 +809,26 @@ export async function runDaemon () {
             const value = await vault.revealSecret(sec.owner, sec.key, ak)
             lastSecretValue = { owner: sec.owner, key: sec.key, value }
           }
+          // EL RESPALDO. Bóveda abierta (lo comprueba la bóveda) y la contraseña del RESPALDO,
+          // que no es la del perfil: con ella se cierra el archivo aquí mismo, para que lo que
+          // salga de este proceso ya vaya cifrado.
+          else if (sec.op === 'backup-drawers') {
+            lastBackup = { op: sec.op, id: sec.id || null, drawers: await vault.backupDrawers() }
+          } else if (sec.op === 'backup-export') {
+            const { payload, summary } = await vault.exportBackup({ drawers: sec.drawers || null, adminKey: ak })
+            lastBackup = { op: sec.op, id: sec.id || null, file: await sealBackup(payload, sec.backupPassword), summary }
+            console.log('[vault] backup exported: %d drawer(s)', summary.drawers.length)
+          } else if (sec.op === 'backup-plan' || sec.op === 'backup-import') {
+            const payload = await openBackup(sec.file, sec.backupPassword)
+            const opts = { drawers: sec.drawers || null, map: sec.map || {}, adminKey: ak }
+            if (sec.op === 'backup-plan') {
+              lastBackup = { op: sec.op, id: sec.id || null, plan: await vault.planBackupImport(payload, opts) }
+            } else {
+              const result = await vault.importBackup(payload, { ...opts, onConflict: sec.onConflict || null, decisions: sec.decisions || {} })
+              lastBackup = { op: sec.op, id: sec.id || null, result }
+              console.log('[vault] backup imported: %d value(s) written, %d kept', result.written, result.kept)
+            }
+          }
           // Qué versiones anteriores hay (sin valores: son sobres).
           else if (sec.op === 'history') {
             lastSecretHistory = { owner: sec.owner || null, key: sec.key || null, items: vault.secretHistory(sec.owner || null, sec.key || null) }
@@ -818,7 +845,11 @@ export async function runDaemon () {
         } catch (e) {
           lastSecretError = {
             error: e.message,
-            code: e.code || (/wrong password/i.test(e.message) ? 'WRONG_PASSWORD' : 'SECRET_FAILED')
+            code: e.code || (/wrong password/i.test(e.message) ? 'WRONG_PASSWORD' : 'SECRET_FAILED'),
+            // Los choques de una importación viajan con el error: son lo que hay que decidir.
+            ...(e.conflicts ? { conflicts: e.conflicts } : {}),
+            ...(e.missing ? { missing: e.missing } : {}),
+            ...(sec.op?.startsWith('backup-') ? { op: sec.op, id: sec.id || null } : {})
           }
           console.error('[vault] secret failed:', e.message)
         } finally { wipe(ak) }
@@ -928,11 +959,13 @@ export async function runDaemon () {
           incomplete: await t.vault.incompleteMembers(),
           ...(lastSecretError ? { secretError: lastSecretError } : {}),
           ...(lastSecretValue ? { revealed: lastSecretValue } : {}),
-          ...(lastSecretHistory ? { history: lastSecretHistory } : {})
+          ...(lastSecretHistory ? { history: lastSecretHistory } : {}),
+          ...(lastBackup ? { backup: lastBackup } : {})
         })
         lastSecretError = null
         lastSecretValue = null
         lastSecretHistory = null
+        lastBackup = null
         ipcWrite(devFile, { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.listDevices()) })
         // Acta del perfil: quién es del perfil y qué puede hacer cada uno (`members`/`caps`).
         try { ipcWrite(path.join(dir, 'acta.json'), { v: 1, at: Date.now(), req: reqId, profile: t.id, ...(await t.vault.profileMembers()), blocked: t.vault.listBlocked?.() || [] }) } catch (_) {}