@safekb/mcp 0.6.0 → 0.7.0

package/dist/safekb-mcp.js

@@ -2359,7 +2359,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // package.json
 var package_default = {
   name: "@safekb/mcp",
-  version: "0.6.0",
+  version: "0.7.0",
   description: "SafeKB local MCP client: proxies the hosted SafeKB tools and adds zero-knowledge sealed documents.",
   license: "SEE LICENSE IN LICENSE",
   author: "Mustafa Öztürk",
@@ -6622,8 +6622,8 @@ async function authorize(request) {
 }
 
 // src/backup/console.ts
-import { createReadStream, existsSync as existsSync2, rmSync } from "node:fs";
-import { open as open3, stat as stat2 } from "node:fs/promises";
+import { createReadStream as createReadStream2, existsSync as existsSync2, rmSync } from "node:fs";
+import { open as open4, readFile, stat as stat3 } from "node:fs/promises";
 
 // src/printable.ts
 var UNPRINTABLE2 = /[\p{Cc}\p{Cf}]/gu;
@@ -6636,6 +6636,87 @@ function printableLines(text) {
 `);
 }
 
+// src/transfer/keyBundle.ts
+var KEY_BUNDLE_KIND = "safekb-key-export";
+var KEY_BUNDLE_VERSION = 1;
+var KEY_INFO = "safekb/key-export/v1";
+var EXPORT_KDF = MIN_KDF_PARAMS;
+var MAX_KDF = { m: 256 * 1024, t: 8, p: 4 };
+var OBJECT_ID = /^[0-9a-f]{24}$/;
+function malformed(why) {
+  return new ClientError(`Not a SafeKB key export: ${why}`);
+}
+function aadOf(salt, kdf) {
+  return `${KEY_INFO}|${salt}|${kdf.m}|${kdf.t}|${kdf.p}`;
+}
+async function bundleKey(passphrase, salt, kdf) {
+  return deriveKey(await derivePassphraseIkm(passphrase, salt, kdf), KEY_INFO);
+}
+function assertContent(value) {
+  const raw = value;
+  const names = raw?.names;
+  if (!Array.isArray(raw?.keys) || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([rootId, name]) => OBJECT_ID.test(rootId) && typeof name === "string" && name.length > 0)) {
+    throw malformed("its content is not keys and the names of their roots");
+  }
+  return { keys: raw.keys.map(assertKeyFile), names: { ...names } };
+}
+function parseBundle(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw malformed("it is not valid JSON");
+  }
+  const raw = value;
+  if (raw?.kind !== KEY_BUNDLE_KIND) {
+    throw malformed(`its kind is not '${KEY_BUNDLE_KIND}'`);
+  }
+  if (raw.v !== KEY_BUNDLE_VERSION) {
+    throw malformed(`its version is not ${KEY_BUNDLE_VERSION}; use the version of @safekb/mcp that wrote it`);
+  }
+  const { kdf, salt } = raw;
+  if (typeof kdf !== "object" || kdf === null || typeof salt !== "string") {
+    throw malformed("it has no KDF parameters and salt");
+  }
+  const params = assertKdfParams(kdf);
+  if (params.m > MAX_KDF.m || params.t > MAX_KDF.t || params.p > MAX_KDF.p) {
+    throw malformed("its KDF parameters are beyond what this client runs");
+  }
+  return {
+    v: raw.v,
+    kind: raw.kind,
+    kdf: params,
+    salt,
+    sealed: assertEnvelope(raw.sealed)
+  };
+}
+async function sealKeyBundle(content, passphrase) {
+  const saltBytes = randomBytes(SALT_BYTES);
+  const salt = toBase64(saltBytes);
+  const bundle = {
+    v: KEY_BUNDLE_VERSION,
+    kind: KEY_BUNDLE_KIND,
+    kdf: { ...EXPORT_KDF },
+    salt,
+    sealed: await sealEnvelope(await bundleKey(passphrase, saltBytes, EXPORT_KDF), utf8Encode(JSON.stringify(assertContent(content))), aadOf(salt, EXPORT_KDF))
+  };
+  return `${JSON.stringify(bundle, null, 2)}
+`;
+}
+async function openKeyBundle(text, passphrase) {
+  const bundle = parseBundle(text);
+  const key = await bundleKey(passphrase, fromBase64(bundle.salt), bundle.kdf);
+  let plaintext;
+  try {
+    plaintext = await openEnvelope(key, bundle.sealed, aadOf(bundle.salt, bundle.kdf));
+  } catch (error) {
+    if (!(error instanceof DecryptionError))
+      throw error;
+    throw new ClientError("Wrong passphrase, or the export file was changed or damaged");
+  }
+  return assertContent(JSON.parse(utf8Decode(plaintext)));
+}
+
 // src/transfer/passphrase.ts
 var RECOMMENDED_EXPORT_PASSPHRASE_LENGTH = 12;
 async function readNewPassphrase(reader, guarded) {
@@ -6657,10 +6738,9 @@ async function readNewPassphrase(reader, guarded) {
 `);
   }
 }
-function readPassphrase(reader) {
-  return reader.read("Passphrase of the export file (not shown): ", {
-    hidden: true
-  });
+var EXPORT_FILE = "the export file";
+function readPassphrase(reader, of) {
+  return reader.read(`Passphrase of ${of} (not shown): `, { hidden: true });
 }
 
 // src/backup/archive/container.ts
@@ -6767,9 +6847,9 @@ function readUint32(bytes) {
 var ARCHIVE_KIND = "safekb-export";
 var ARCHIVE_VERSION = 1;
 var COMPRESSIONS = ["none", "gzip"];
-var KEY_INFO = "safekb/export/v1";
+var KEY_INFO2 = "safekb/export/v1";
 var ARCHIVE_KDF = MIN_KDF_PARAMS;
-var MAX_KDF = { m: 256 * 1024, t: 8, p: 4 };
+var MAX_KDF2 = { m: 256 * 1024, t: 8, p: 4 };
 var PART_BYTES = 1024 * 1024;
 var TAG_BYTES2 = 16;
 var NONCE_PREFIX_BYTES2 = 8;
@@ -6777,12 +6857,12 @@ var MAX_PARTS = 2 ** 32;
 var MAX_HEADER_BYTES = 4096;
 var NEWLINE = 10;
 var CUT_SHORT = "The export file is cut short or damaged";
-function malformed(why) {
+function malformed2(why) {
   return new ClientError(`Not a SafeKB export: ${why}`);
 }
 async function archiveKey(passphrase, header) {
   const ikm = await derivePassphraseIkm(passphrase, fromBase64(header.salt), header.kdf);
-  return deriveKey(ikm, KEY_INFO);
+  return deriveKey(ikm, KEY_INFO2);
 }
 function partNonce(prefix, index) {
   if (index >= MAX_PARTS)
@@ -6790,7 +6870,7 @@ function partNonce(prefix, index) {
   return concatBytes(prefix, uint32(index));
 }
 function partAad(headerDigest, part, isLast) {
-  return utf8Encode(`${KEY_INFO}|${headerDigest}|${part}|${isLast ? 1 : 0}`);
+  return utf8Encode(`${KEY_INFO2}|${headerDigest}|${part}|${isLast ? 1 : 0}`);
 }
 async function* inParts(source, size) {
   let pieces = [];
@@ -6841,25 +6921,25 @@ function parseHeader(line) {
   try {
     value = JSON.parse(utf8Decode(line));
   } catch {
-    throw malformed("it does not start with a header");
+    throw malformed2("it does not start with a header");
   }
   const raw = value;
   if (raw?.kind !== ARCHIVE_KIND) {
-    throw malformed(`its kind is not '${ARCHIVE_KIND}'`);
+    throw malformed2(`its kind is not '${ARCHIVE_KIND}'`);
   }
   if (raw.v !== ARCHIVE_VERSION) {
-    throw malformed(`its version is not ${ARCHIVE_VERSION}; use the version of @safekb/mcp that wrote it`);
+    throw malformed2(`its version is not ${ARCHIVE_VERSION}; use the version of @safekb/mcp that wrote it`);
   }
   const { kdf, salt, nonce_prefix, compression } = raw;
   if (typeof kdf !== "object" || kdf === null || typeof salt !== "string" || typeof nonce_prefix !== "string" || !COMPRESSIONS.includes(compression)) {
-    throw malformed("its header is incomplete");
+    throw malformed2("its header is incomplete");
   }
   const params = assertKdfParams(kdf);
-  if (params.m > MAX_KDF.m || params.t > MAX_KDF.t || params.p > MAX_KDF.p) {
-    throw malformed("its KDF parameters are beyond what this client runs");
+  if (params.m > MAX_KDF2.m || params.t > MAX_KDF2.t || params.p > MAX_KDF2.p) {
+    throw malformed2("its KDF parameters are beyond what this client runs");
   }
   if (fromBase64(nonce_prefix).length !== NONCE_PREFIX_BYTES2) {
-    throw malformed("its header is incomplete");
+    throw malformed2("its header is incomplete");
   }
   return {
     kind: raw.kind,
@@ -6896,7 +6976,7 @@ async function* openArchive(file, passphrase) {
   const reader = new ByteReader(file, CUT_SHORT);
   const line = await reader.readUntil(NEWLINE, MAX_HEADER_BYTES);
   if (line === null)
-    throw malformed("it does not start with a header");
+    throw malformed2("it does not start with a header");
   const header = parseHeader(line);
   const key = await archiveKey(passphrase, header);
   const parts = openParts(reader, key, header, await sha256Hex(line));
@@ -6906,6 +6986,12 @@ async function* openArchive(file, passphrase) {
 // src/backup/archive/entries.ts
 var MAX_RECORD_BYTES = 512 * 1024 * 1024;
 var CUT_SHORT2 = "The export ends in the middle of a record";
+function carriesBlob(record) {
+  return record.kind === "attachment" || record.kind === "raw-sealed-attachment";
+}
+function nameOf(record) {
+  return record.kind === "attachment" ? `Attachment ${record.id} ('${record.file_name}')` : `Sealed attachment ${record.id}`;
+}
 async function* blobOf(record, blob) {
   let written = 0;
   for await (const piece of blob) {
@@ -6913,7 +6999,7 @@ async function* blobOf(record, blob) {
     yield piece;
   }
   if (written !== record.blob_bytes) {
-    throw new ClientError(`Attachment ${record.id} ('${record.file_name}') is ${written} bytes, not the ${record.blob_bytes} the server reports for it`);
+    throw new ClientError(`${nameOf(record)} is ${written} bytes, not the ${record.blob_bytes} the server reports for it`);
   }
 }
 async function* encodeEntries(entries) {
@@ -6947,7 +7033,7 @@ async function* decodeEntries(content) {
     if (size > MAX_RECORD_BYTES)
       throw new ClientError(CUT_SHORT2);
     const record = parseRecord(await reader.read(size));
-    if (record.kind !== "attachment") {
+    if (!carriesBlob(record)) {
       yield { record };
       continue;
     }
@@ -6966,7 +7052,8 @@ async function* decodeEntries(content) {
 }
 
 // src/backup/archive/records.ts
-var RECORD_FORMAT = 1;
+var RECORD_FORMAT = 2;
+var READABLE_FORMATS = [1, RECORD_FORMAT];
 var ENTITY_TYPES = ["doc", "task", "project", "decision"];
 
 // src/backup/import/labels.ts
@@ -7180,7 +7267,7 @@ class DatabaseImporter {
 }
 
 // src/backup/import/idMap.ts
-var OBJECT_ID = /\b[0-9a-f]{24}\b/g;
+var OBJECT_ID2 = /\b[0-9a-f]{24}\b/g;
 var TASK_LINK = "taskId";
 
 class IdMap {
@@ -7195,13 +7282,13 @@ class IdMap {
     return exported === null ? null : this.of(kind).get(exported) ?? null;
   }
   rewrite(text) {
-    return text.replace(OBJECT_ID, (id) => this.all.get(id) ?? id);
+    return text.replace(OBJECT_ID2, (id) => this.all.get(id) ?? id);
   }
   mentionsUnknown(text) {
-    return (text.match(OBJECT_ID) ?? []).some((id) => !this.all.has(id));
+    return (text.match(OBJECT_ID2) ?? []).some((id) => !this.all.has(id));
   }
   static mentionsId(text) {
-    return text.search(OBJECT_ID) >= 0;
+    return text.search(OBJECT_ID2) >= 0;
   }
   rewriteJson(value) {
     if (typeof value === "string")
@@ -7395,11 +7482,428 @@ class NodeImporter {
   }
 }
 
+// src/sealed/attachmentService.ts
+import { createReadStream } from "node:fs";
+import { open as open3, stat as stat2, unlink } from "node:fs/promises";
+import { basename as basename2 } from "node:path";
+
+// src/sealed/nodeAccess.ts
+function assertSeq(node, expectedSeq) {
+  if (node.seal_seq !== expectedSeq) {
+    throw new ClientError(`${node.id} changed: its seal_seq is ${node.seal_seq}, not ${expectedSeq}. Read it again before writing.`);
+  }
+}
+function assertAccepted(node) {
+  if (node.deposited) {
+    throw new ClientError(`${node.id} is a pending deposit; accept_sealed_deposit or reject_sealed_deposit it first`);
+  }
+}
+function writeResult(node) {
+  return {
+    id: node.id,
+    seal_root_id: node.seal_root_id,
+    seal_seq: node.seal_seq
+  };
+}
+
+class NodeAccess {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  nodeContext(nodeId) {
+    return { tenant: this.ctx.tenant, node: nodeId };
+  }
+  async dekOf(node) {
+    const { keys } = this.ctx.session.require(node.seal_root_id);
+    if (node.enc_dek !== null) {
+      return unwrapDek(keys, node.id, parseEnvelope(node.enc_dek));
+    }
+    if (node.box_dek !== null) {
+      return openBoxDek(keys, node.id, parseBoxDek(node.box_dek));
+    }
+    throw new ClientError(`Sealed node ${node.id} has no wrapped key`);
+  }
+  async open(nodeId) {
+    return this.openNode(await this.ctx.api.getNode(nodeId));
+  }
+  async openNode(node) {
+    const root = this.ctx.session.require(node.seal_root_id);
+    const dek = await this.dekOf(node);
+    const meta = await decryptMeta(dek, this.nodeContext(node.id), parseEnvelope(node.enc_meta));
+    return { node, root, dek, meta };
+  }
+  async sign(message, signerRootIds) {
+    const signers = signerRootIds.map((rootId) => this.ctx.session.require(rootId).keys);
+    return signMessage(await buildMessage(message), signers);
+  }
+  async signPlain(op, node) {
+    const sigs = await this.sign({
+      op,
+      tenant: this.ctx.tenant,
+      node: node.id,
+      root: node.seal_root_id,
+      baseSeq: node.seal_seq
+    }, [node.seal_root_id]);
+    return { base_seq: node.seal_seq, sigs };
+  }
+}
+
+// src/sealed/attachmentService.ts
+var DOWNLOAD_FILE_MODE = 384;
+var DEFAULT_MIME_TYPE = "application/octet-stream";
+async function* fileBytes(path) {
+  try {
+    for await (const chunk of createReadStream(path))
+      yield chunk;
+  } catch (error) {
+    throw fileError(error);
+  }
+}
+async function* verified(plaintext, meta) {
+  const hash = await createStreamingSha256();
+  let size = 0;
+  for await (const chunk of plaintext) {
+    hash.update(chunk);
+    size += chunk.length;
+    yield chunk;
+  }
+  if (size !== meta.size || hash.digestHex() !== meta.sha256_plain) {
+    throw new ClientError("Downloaded attachment does not match its sealed size and hash");
+  }
+}
+
+class AttachmentService {
+  ctx;
+  access;
+  constructor(ctx, access) {
+    this.ctx = ctx;
+    this.access = access;
+  }
+  async list(documentId) {
+    const opened = await this.access.open(documentId);
+    const attachments = [];
+    for (const record of await this.ctx.api.listAttachments(documentId)) {
+      const meta = await this.metaOf(opened, record);
+      attachments.push({
+        id: record.id,
+        filename: meta.filename,
+        mime: meta.mime,
+        size: meta.size
+      });
+    }
+    return {
+      document_id: documentId,
+      seal_seq: opened.node.seal_seq,
+      attachments
+    };
+  }
+  async upload(args) {
+    const opened = await this.access.open(args.document_id);
+    assertSeq(opened.node, args.expected_seq);
+    assertAccepted(opened.node);
+    const info = await stat2(args.file_path).catch((error) => {
+      throw fileError(error);
+    });
+    if (!info.isFile()) {
+      throw new ClientError(`${args.file_path} is not a regular file; only regular files can be attached`);
+    }
+    await this.assertWithinLimit(args.file_path, info.size);
+    return this.attachTo(opened, {
+      filename: basename2(args.file_path),
+      mime: args.mime_type,
+      bytes: fileBytes(args.file_path)
+    });
+  }
+  async attach(args) {
+    const opened = await this.access.open(args.document_id);
+    assertSeq(opened.node, args.expected_seq);
+    assertAccepted(opened.node);
+    await this.assertWithinLimit(`'${args.file.filename}'`, args.size);
+    return this.attachTo(opened, args.file);
+  }
+  async attachTo(opened, plain) {
+    const { node, dek } = opened;
+    const ctx = this.attachmentContext(node.id, newObjectId());
+    const file = await this.encrypt(dek, ctx, plain);
+    const attEncMeta = serializeEnvelope(await encryptAttachmentMeta(dek, ctx, file.meta));
+    const sigs = await this.access.sign({
+      op: "attach",
+      tenant: this.ctx.tenant,
+      node: node.id,
+      root: node.seal_root_id,
+      baseSeq: node.seal_seq,
+      attId: ctx.attId,
+      blobCtSha256: file.blobSha256,
+      attEncMeta
+    }, [node.seal_root_id]);
+    const stored = await this.ctx.api.attach(node.id, {
+      base_seq: node.seal_seq,
+      att_id: ctx.attId,
+      att_enc_meta: attEncMeta,
+      blob_sha256: file.blobSha256,
+      ciphertext: file.ciphertext,
+      sigs
+    });
+    return {
+      attachment_id: stored.id,
+      document_id: node.id,
+      seal_seq: stored.seal_seq,
+      size: file.meta.size
+    };
+  }
+  async files(documentId) {
+    const opened = await this.access.open(documentId);
+    const files = [];
+    for (const record of await this.ctx.api.listAttachments(documentId)) {
+      const meta = await this.metaOf(opened, record);
+      files.push({
+        id: record.id,
+        meta,
+        bytes: () => this.plaintextOf(opened, record.id, meta)
+      });
+    }
+    return files;
+  }
+  async* plaintextOf(opened, attachmentId, meta) {
+    const ciphertext = await this.ctx.api.downloadAttachment(opened.node.id, attachmentId);
+    yield* verified(decryptAttachment(opened.dek, this.attachmentContext(opened.node.id, attachmentId), ciphertext), meta);
+  }
+  async download(args) {
+    const opened = await this.access.open(args.document_id);
+    const record = (await this.ctx.api.listAttachments(args.document_id)).find((candidate) => candidate.id === args.attachment_id);
+    if (record === undefined) {
+      throw new ClientError(`${args.document_id} has no attachment ${args.attachment_id}`);
+    }
+    const meta = await this.metaOf(opened, record);
+    await this.write(args.out_path, this.plaintextOf(opened, args.attachment_id, meta));
+    return {
+      attachment_id: args.attachment_id,
+      out_path: args.out_path,
+      filename: meta.filename,
+      size: meta.size
+    };
+  }
+  async delete(args) {
+    const node = await this.ctx.api.getNode(args.document_id);
+    assertSeq(node, args.expected_seq);
+    const sigs = await this.access.sign({
+      op: "detach",
+      tenant: this.ctx.tenant,
+      node: node.id,
+      root: node.seal_root_id,
+      baseSeq: node.seal_seq,
+      attId: args.attachment_id
+    }, [node.seal_root_id]);
+    const changed = await this.ctx.api.detach(node.id, {
+      base_seq: node.seal_seq,
+      att_id: args.attachment_id,
+      sigs
+    });
+    return { document_id: node.id, seal_seq: changed.seal_seq, deleted: true };
+  }
+  attachmentContext(nodeId, attId) {
+    return { ...this.access.nodeContext(nodeId), attId };
+  }
+  metaOf(opened, record) {
+    if (!record.sealed || record.att_enc_meta === null) {
+      throw new ClientError(`Attachment ${record.id} is not sealed`);
+    }
+    return decryptAttachmentMeta(opened.dek, this.attachmentContext(opened.node.id, record.id), parseEnvelope(record.att_enc_meta));
+  }
+  async encrypt(dek, ctx, file) {
+    const plainHash = await createStreamingSha256();
+    const cipherHash = await createStreamingSha256();
+    let size = 0;
+    async function* plaintext() {
+      for await (const bytes of file.bytes) {
+        plainHash.update(bytes);
+        size += bytes.length;
+        yield bytes;
+      }
+    }
+    const parts = [];
+    for await (const part of encryptAttachment(dek, ctx, plaintext())) {
+      cipherHash.update(part);
+      parts.push(part);
+    }
+    return {
+      ciphertext: new Blob(parts),
+      blobSha256: cipherHash.digestHex(),
+      meta: {
+        filename: file.filename,
+        mime: file.mime,
+        size,
+        sha256_plain: plainHash.digestHex()
+      }
+    };
+  }
+  async assertWithinLimit(what, size) {
+    const { max_file_size_bytes: limit } = await this.ctx.api.limits();
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+      throw new ClientError("The server did not report a usable upload limit (max_file_size_bytes)");
+    }
+    const sealedSize = attachmentCiphertextSize(size);
+    if (sealedSize > limit) {
+      throw new ClientError(`${what} is too large to attach: it is ${size} bytes, ${sealedSize} bytes once sealed, and the server accepts at most ${limit} bytes`);
+    }
+  }
+  async write(path, plaintext) {
+    let handle;
+    try {
+      handle = await open3(path, "wx", DOWNLOAD_FILE_MODE);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new ClientError(`${path} already exists; choose a new out_path`);
+      }
+      throw fileError(error);
+    }
+    let complete = false;
+    try {
+      for await (const chunk of plaintext)
+        await handle.write(chunk);
+      complete = true;
+    } finally {
+      await handle.close();
+      if (!complete)
+        await unlink(path);
+    }
+  }
+}
+
+// src/backup/import/rawSealed.ts
+var LEFT_OUT = "sealed item(s) left out: their seal root could not be opened (see below)";
+
+class RawSealedImporter {
+  ctx;
+  sink;
+  keys;
+  opened = new Map;
+  unopened = new Set;
+  deks = new Map;
+  constructor(ctx, sink, keys) {
+    this.ctx = ctx;
+    this.sink = sink;
+    this.keys = keys;
+  }
+  async root(record) {
+    const opening = await this.keys.open(this.sourceTenant(), record.root_id, record.seal);
+    if ("keys" in opening) {
+      this.opened.set(record.root_id, opening.keys);
+      return;
+    }
+    this.unopened.add(record.root_id);
+    this.ctx.report.unopenedRoots.push({
+      id: record.root_id,
+      name: record.name,
+      reason: opening.reason
+    });
+  }
+  async node(record, spaceId) {
+    const keys = this.keysOf(record.seal_root_id);
+    if (keys === null)
+      return;
+    const ctx = this.nodeContext(record.id);
+    const dek = await unwrapDek(keys, record.id, parseEnvelope(record.enc_dek));
+    const meta = await decryptMeta(dek, ctx, parseEnvelope(record.enc_meta));
+    const placed = {
+      id: record.id,
+      space_id: record.space_id,
+      parent_id: record.parent_id,
+      title: meta.title,
+      position: record.position,
+      archived: record.archived,
+      seal_root_id: record.seal_root_id
+    };
+    if (record.is_folder) {
+      return this.sink.folder({ kind: "sealed-folder", ...placed }, spaceId);
+    }
+    const { enc_body: encBody, enc_index: encIndex } = record;
+    if (encBody === null || encIndex === null) {
+      throw new ClientError(`Sealed document ${record.id} has no body or index entry`);
+    }
+    const index = await decryptIndexEntry(dek, ctx, parseEnvelope(encIndex));
+    this.deks.set(record.id, dek);
+    await this.sink.document({
+      kind: "sealed-document",
+      ...placed,
+      tags: meta.tags,
+      body: await decryptBody(dek, ctx, parseEnvelope(encBody)),
+      summary: index.summary,
+      summary_short: meta.summary_short,
+      keywords: index.keywords
+    }, spaceId);
+  }
+  async attachment(entry) {
+    const { record } = entry;
+    const dek = this.deks.get(record.document_id);
+    if (dek === undefined) {
+      this.ctx.report.note(LEFT_OUT);
+      return;
+    }
+    const ctx = { ...this.nodeContext(record.document_id), attId: record.id };
+    const meta = await decryptAttachmentMeta(dek, ctx, parseEnvelope(record.att_enc_meta));
+    await this.sink.attachment({
+      record: {
+        kind: "attachment",
+        id: record.id,
+        owner: "sealed-document",
+        owner_id: record.document_id,
+        file_name: meta.filename,
+        mime_type: meta.mime,
+        blob_bytes: meta.size
+      },
+      blob: verified(decryptAttachment(dek, ctx, entry.blob), meta)
+    });
+  }
+  async credential(record, spaceId) {
+    const keys = this.keysOf(record.seal_root_id);
+    if (keys === null)
+      return;
+    const dek = await unwrapDek(keys, record.id, parseEnvelope(record.enc_dek));
+    const values = await unsealCredentialFields(dek, { tenant: this.sourceTenant(), credential: record.id }, record.enc_fields);
+    const {
+      kind: _kind,
+      enc_fields: _fields,
+      enc_dek: _dek,
+      ...visible
+    } = record;
+    await this.sink.credential({
+      ...visible,
+      kind: "credential",
+      password: values.password,
+      totp: values.totp,
+      sealed_notes: values.sealed_notes,
+      custom: [
+        ...record.custom.map((field) => ({ ...field, secret: false })),
+        ...values.custom.map((field) => ({ ...field, secret: true }))
+      ]
+    }, spaceId);
+  }
+  keysOf(rootId) {
+    const keys = this.opened.get(rootId);
+    if (keys !== undefined)
+      return keys;
+    if (!this.unopened.has(rootId)) {
+      throw new ClientError(`The export holds sealed items of seal root ${rootId} without the root's seal`);
+    }
+    this.ctx.report.note(LEFT_OUT);
+    return null;
+  }
+  nodeContext(nodeId) {
+    return { tenant: this.sourceTenant(), node: nodeId };
+  }
+  sourceTenant() {
+    return this.ctx.sourceTenantId;
+  }
+}
+
 // src/backup/import/report.ts
 class ImportReport {
   created = {};
   notes = new Map;
   sealRoots = [];
+  unopenedRoots = [];
   count(kind, by = 1) {
     this.created[kind] = (this.created[kind] ?? 0) + by;
   }
@@ -7422,7 +7926,7 @@ function passphraseNote(seal2) {
 // src/backup/import/sealed.ts
 var POSITION_DECIMALS = 6;
 var IMPORTED = "imported";
-var OBJECT_ID2 = /^[0-9a-f]{24}$/;
+var OBJECT_ID3 = /^[0-9a-f]{24}$/;
 
 class SealedImporter {
   ctx;
@@ -7536,7 +8040,7 @@ class SealedImporter {
   }
   async rootName(title) {
     const taken = new Set((await this.sealed.names.all()).values());
-    const usable = (name) => !OBJECT_ID2.test(name) && !taken.has(name);
+    const usable = (name) => !OBJECT_ID3.test(name) && !taken.has(name);
     if (usable(title))
       return title;
     for (let copy = 1;; copy++) {
@@ -7739,6 +8243,7 @@ class Importer {
   ctx;
   nodes;
   sealed;
+  raw;
   databases;
   work;
   progress;
@@ -7756,6 +8261,7 @@ class Importer {
     };
     this.nodes = new NodeImporter(this.ctx);
     this.sealed = new SealedImporter(this.ctx, targets.sealed, targets.services);
+    this.raw = new RawSealedImporter(this.ctx, this.sealed, targets.rawRootKeys);
     this.databases = new DatabaseImporter(this.ctx);
     this.work = new WorkImporter(this.ctx);
     this.progress = progress;
@@ -7817,11 +8323,14 @@ ${WHAT_STAYS}`, this.ctx.report);
     const { record } = entry;
     switch (record.kind) {
       case "manifest":
-        if (record.format !== RECORD_FORMAT) {
-          throw new ClientError(`The export has record format ${record.format}, this client reads ${RECORD_FORMAT}; use the version of @safekb/mcp that wrote it`);
+        if (!READABLE_FORMATS.includes(record.format)) {
+          throw new ClientError(`The export has record format ${record.format}, this client reads ${READABLE_FORMATS.join(" and ")}; use the version of @safekb/mcp that wrote it`);
         }
         this.ctx.sourceTenantId = record.source.tenant_id;
         return;
+      case "raw-seal-root":
+        this.announce("Seal roots the export holds as stored");
+        return this.raw.root(record);
       case "space":
         this.announce("Spaces");
         return this.nodes.space(record);
@@ -7842,6 +8351,9 @@ ${WHAT_STAYS}`, this.ctx.report);
       case "sealed-document":
         this.announce("Documents and folders");
         return this.sealed.document(record, this.nodes.spaceOf(record.space_id));
+      case "raw-sealed-node":
+        this.announce("Documents and folders");
+        return this.raw.node(record, this.nodes.spaceOf(record.space_id));
       case "database":
         this.announce("Documents and folders");
         return this.databases.database(record, this.nodes.spaceOf(record.space_id));
@@ -7849,11 +8361,16 @@ ${WHAT_STAYS}`, this.ctx.report);
         const file = entry;
         return record.owner === "sealed-document" ? this.sealed.attachment(file) : this.nodes.attachment(file);
       }
+      case "raw-sealed-attachment":
+        return this.raw.attachment(entry);
       case "credential": {
         this.announce("Credentials");
         const spaceId = this.nodes.spaceOf(record.space_id);
         return record.seal_root_id === null ? this.work.credential(record, spaceId) : this.sealed.credential(record, spaceId);
       }
+      case "raw-sealed-credential":
+        this.announce("Credentials");
+        return this.raw.credential(record, this.nodes.spaceOf(record.space_id));
       case "project":
         this.announce("Projects, tasks and decisions");
         return this.work.project(record);
@@ -7908,6 +8425,13 @@ var LABELS = [
   ],
   ["sealed-folder", "sealed folder(s)"],
   ["sealed-document", "sealed document(s)"],
+  ["raw-seal-root", "seal root(s) this machine cannot open, written as stored"],
+  [
+    "raw-sealed-node",
+    "sealed folder(s) and document(s) of those, still sealed"
+  ],
+  ["raw-sealed-attachment", "attachment(s) of those, still sealed"],
+  ["raw-sealed-credential", "sealed credential(s) of those, still sealed"],
   ["database", "database(s)"],
   ["rows", "database row(s)"],
   ["view", "database view(s)"],
@@ -7929,7 +8453,7 @@ function alreadyThere(path) {
 }
 async function* bytesOf(path) {
   try {
-    for await (const chunk of createReadStream(path))
+    for await (const chunk of createReadStream2(path))
       yield chunk;
   } catch (error) {
     throw fileError(error);
@@ -7950,7 +8474,7 @@ class BackupConsole {
       throw alreadyThere(path);
     const prepared = await exporter.prepare();
     const passphrase = await readNewPassphrase(this.reader, "everything in the file");
-    const file = await open3(path, "wx", EXPORT_FILE_MODE).catch((error) => {
+    const file = await open4(path, "wx", EXPORT_FILE_MODE).catch((error) => {
       throw error.code === "EEXIST" ? alreadyThere(path) : fileError(error);
     });
     let complete = false;
@@ -7979,11 +8503,27 @@ ${countLines(counts)}`);
 The file opens only with the passphrase you typed: keep both, and keep them apart.
 `);
   }
+  async keysFrom(paths) {
+    const keys = [];
+    for (const path of paths) {
+      const text = await readFile(path, "utf8").catch((error) => {
+        throw fileError(error);
+      });
+      const passphrase = await readPassphrase(this.reader, `key export ${path}`);
+      const bundle = await openKeyBundle(text, passphrase).catch((error) => {
+        if (!(error instanceof ClientError))
+          throw error;
+        throw new ClientError(`${path}: ${error.message}`);
+      });
+      keys.push(...bundle.keys);
+    }
+    return keys;
+  }
   async import(importer, path) {
-    await stat2(path).catch((error) => {
+    await stat3(path).catch((error) => {
       throw fileError(error);
     });
-    const passphrase = await readPassphrase(this.reader);
+    const passphrase = await readPassphrase(this.reader, EXPORT_FILE);
     const entries = decodeEntries(openArchive(bytesOf(path), passphrase));
     let report;
     try {
@@ -8001,6 +8541,7 @@ The file opens only with the passphrase you typed: keep both, and keep them apar
     this.reader.write(`${heading}:
 ${countLines(report.created)}`);
     this.writeNotes("Notes", [...report.notes].map(([reason, times]) => `${times} ${reason}`));
+    this.writeNotes("Seal roots the export holds as stored that had no key here, so everything in them was left out (to restore them, import again with --keys <their key export>; that creates everything else again too)", report.unopenedRoots.map(({ id, name, reason }) => `${name === null ? id : `"${name}" (${id})`}: ${reason}`));
     if (report.sealRoots.length === 0)
       return;
     this.reader.write(`New seal roots, each with a newly generated key. Back the keys up (safekb-mcp --export-keys): a lost key cannot be recovered.
@@ -8083,68 +8624,6 @@ class CredentialAccess {
   }
 }
 
-// src/sealed/nodeAccess.ts
-function assertSeq(node, expectedSeq) {
-  if (node.seal_seq !== expectedSeq) {
-    throw new ClientError(`${node.id} changed: its seal_seq is ${node.seal_seq}, not ${expectedSeq}. Read it again before writing.`);
-  }
-}
-function assertAccepted(node) {
-  if (node.deposited) {
-    throw new ClientError(`${node.id} is a pending deposit; accept_sealed_deposit or reject_sealed_deposit it first`);
-  }
-}
-function writeResult(node) {
-  return {
-    id: node.id,
-    seal_root_id: node.seal_root_id,
-    seal_seq: node.seal_seq
-  };
-}
-
-class NodeAccess {
-  ctx;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  nodeContext(nodeId) {
-    return { tenant: this.ctx.tenant, node: nodeId };
-  }
-  async dekOf(node) {
-    const { keys } = this.ctx.session.require(node.seal_root_id);
-    if (node.enc_dek !== null) {
-      return unwrapDek(keys, node.id, parseEnvelope(node.enc_dek));
-    }
-    if (node.box_dek !== null) {
-      return openBoxDek(keys, node.id, parseBoxDek(node.box_dek));
-    }
-    throw new ClientError(`Sealed node ${node.id} has no wrapped key`);
-  }
-  async open(nodeId) {
-    return this.openNode(await this.ctx.api.getNode(nodeId));
-  }
-  async openNode(node) {
-    const root = this.ctx.session.require(node.seal_root_id);
-    const dek = await this.dekOf(node);
-    const meta = await decryptMeta(dek, this.nodeContext(node.id), parseEnvelope(node.enc_meta));
-    return { node, root, dek, meta };
-  }
-  async sign(message, signerRootIds) {
-    const signers = signerRootIds.map((rootId) => this.ctx.session.require(rootId).keys);
-    return signMessage(await buildMessage(message), signers);
-  }
-  async signPlain(op, node) {
-    const sigs = await this.sign({
-      op,
-      tenant: this.ctx.tenant,
-      node: node.id,
-      root: node.seal_root_id,
-      baseSeq: node.seal_seq
-    }, [node.seal_root_id]);
-    return { base_seq: node.seal_seq, sigs };
-  }
-}
-
 // src/backup/export/credentials.ts
 var CUSTOM_FIELD = "custom:";
 
@@ -8152,18 +8631,27 @@ class CredentialExporter {
   kb;
   sealed;
   roots;
+  raw;
   exported;
-  constructor(kb, sealed, roots, exported) {
+  constructor(kb, sealed, roots, raw, exported) {
     this.kb = kb;
     this.sealed = sealed;
     this.roots = roots;
+    this.raw = raw;
     this.exported = exported;
   }
   async* entries(credentials, sealRoots) {
     for (const credential2 of credentials) {
       const sealRootId = sealRoots.get(credential2.id) ?? null;
-      if (sealRootId !== null && this.roots.isLocked(sealRootId))
+      const treatment = sealRootId === null ? "open" : this.roots.treatmentOf(sealRootId);
+      if (treatment === "left-out")
         continue;
+      if (treatment === "raw") {
+        yield {
+          record: await this.raw.credential(credential2, sealRootId)
+        };
+        continue;
+      }
       const secrets = sealRootId === null ? await this.revealed(credential2) : await this.unsealed(credential2.id);
       this.exported.count("credential");
       yield { record: this.record(credential2, sealRootId, secrets) };
@@ -8420,9 +8908,11 @@ class NodeExporter {
   }
   async* entries(planned) {
     if (planned.sealRootId !== null) {
-      if (!this.from.roots.isLocked(planned.sealRootId)) {
+      const treatment = this.from.roots.treatmentOf(planned.sealRootId);
+      if (treatment === "open")
         yield* this.sealed(planned);
-      }
+      if (treatment === "raw")
+        yield* this.from.raw.node(planned);
       return;
     }
     const document = await this.from.kb.document(planned.id);
@@ -8523,8 +9013,8 @@ class NodeExporter {
     }
   }
   async* sealed(planned) {
-    const open4 = await this.from.access.openNode(toSealedNode(await this.from.sealed.api.getDocument(planned.id)));
-    const { node, meta } = open4;
+    const open5 = await this.from.access.openNode(toSealedNode(await this.from.sealed.api.getDocument(planned.id)));
+    const { node, meta } = open5;
     const placed = {
       id: node.id,
       space_id: node.space_id,
@@ -8544,7 +9034,7 @@ class NodeExporter {
       kind: "sealed-document",
       ...placed,
       tags: meta.tags,
-      body: (await this.from.services.documents.storedBody(open4)).body,
+      body: (await this.from.services.documents.storedBody(open5)).body,
       summary: indexed?.summary ?? "",
       summary_short: meta.summary_short,
       keywords: indexed?.keywords ?? []
@@ -8659,6 +9149,202 @@ class ExportPlanner {
   }
 }
 
+// src/backup/export/rawSealed.ts
+function changedWhileRead(id) {
+  return new ClientError(`${id} changed while it was exported; try again`);
+}
+
+class RawSealedExporter {
+  ctx;
+  exported;
+  constructor(ctx, exported) {
+    this.ctx = ctx;
+    this.exported = exported;
+  }
+  async root(rootId) {
+    const root = toSealedNode(await this.ctx.api.getDocument(rootId));
+    if (root.seal === null) {
+      throw new ClientError(`${rootId} is not a seal root`);
+    }
+    this.exported.count("raw-seal-root");
+    return {
+      kind: "raw-seal-root",
+      root_id: rootId,
+      seal: root.seal,
+      name: await this.ctx.names.nameOf(rootId)
+    };
+  }
+  async* node(planned) {
+    const node = toSealedNode(await this.ctx.api.getDocument(planned.id));
+    if (node.deposited) {
+      this.exported.leftOut.push(`pending deposit ${node.id} of a seal root that could not be opened`);
+      return;
+    }
+    if (node.enc_dek === null) {
+      throw new ClientError(`Sealed node ${node.id} has no wrapped key`);
+    }
+    const record = {
+      kind: "raw-sealed-node",
+      id: node.id,
+      space_id: node.space_id,
+      parent_id: planned.parentId,
+      position: node.position,
+      archived: node.archived,
+      is_folder: node.is_folder,
+      seal_root_id: node.seal_root_id,
+      enc_dek: node.enc_dek,
+      enc_meta: node.enc_meta,
+      ...node.is_folder ? { enc_index: null, enc_body: null } : await this.content(node)
+    };
+    this.exported.count("raw-sealed-node");
+    yield { record };
+    if (!node.is_folder)
+      yield* this.attachments(node.id);
+  }
+  async credential(credential2, sealRootId) {
+    const stored = await this.ctx.api.fetchSealedCredential(credential2.id);
+    if (stored.seal_root_id !== sealRootId)
+      throw changedWhileRead(stored.id);
+    this.exported.count("raw-sealed-credential");
+    const visible = visibleOf(stored);
+    return {
+      kind: "raw-sealed-credential",
+      id: credential2.id,
+      space_id: credential2.space_id,
+      folder_id: credential2.folder_id,
+      seal_root_id: sealRootId,
+      title: visible.title,
+      username: visible.username,
+      url: visible.url,
+      tags: visible.tags,
+      icon: credential2.icon,
+      color: credential2.color,
+      favorite: credential2.favorite,
+      expires_at: credential2.expires_at,
+      external_refs: credential2.external_refs,
+      archived: credential2.archived,
+      notes: visible.notes,
+      custom: visible.custom,
+      enc_fields: stored.enc_fields,
+      enc_dek: stored.enc_dek
+    };
+  }
+  async content(node) {
+    const body = await this.ctx.api.getBody(node.id);
+    const [index] = await this.ctx.api.indexEntries(node.seal_root_id, [
+      node.id
+    ]);
+    if (body.seal_seq !== node.seal_seq || index === undefined || index.seal_seq !== node.seal_seq) {
+      throw changedWhileRead(node.id);
+    }
+    return { enc_index: index.enc_index, enc_body: body.body };
+  }
+  async* attachments(documentId) {
+    for (const stored of await this.ctx.api.listAttachments(documentId)) {
+      if (!stored.sealed || stored.att_enc_meta === null) {
+        throw new ClientError(`Attachment ${stored.id} is not sealed`);
+      }
+      this.exported.count("raw-sealed-attachment");
+      yield {
+        record: {
+          kind: "raw-sealed-attachment",
+          id: stored.id,
+          document_id: documentId,
+          att_enc_meta: stored.att_enc_meta,
+          blob_bytes: stored.size_bytes
+        },
+        blob: await this.ctx.api.downloadAttachment(documentId, stored.id)
+      };
+    }
+  }
+}
+
+// src/stores/secretStores.ts
+var HOW_TO_ENABLE = {
+  system: "The system keyring is not set up for this client; run: safekb-mcp --configure",
+  file: "No key file directory is set up; start the client with --keyring <dir>, or run: safekb-mcp --configure",
+  sidecar: "The sidecar is not available on this platform"
+};
+
+class SecretLookupError extends ClientError {
+  kind;
+  problem;
+  constructor(kind, problem, toolAdvice) {
+    super(`${problem}${toolAdvice}`);
+    this.kind = kind;
+    this.problem = problem;
+  }
+}
+
+class SecretStores {
+  set;
+  constructor(set) {
+    this.set = set;
+  }
+  async holds(rootId, kid) {
+    for (const store of this.enabled()) {
+      if (await store.holds(rootId, kid))
+        return true;
+    }
+    return false;
+  }
+  async find(seal2, only) {
+    const stores = only === undefined ? this.enabled() : [this.require(only)];
+    if (stores.length === 0) {
+      throw new SecretLookupError("no-store", "No secret given and no secret store is set up", ": pass secret_file, run safekb-mcp --configure, or start the client with --keyring <dir>");
+    }
+    const found = [];
+    const notes = [];
+    for (const store of stores) {
+      const { secrets, note } = await store.lookup(seal2);
+      if (secrets.length > 0)
+        found.push({ store: store.name, secrets });
+      else
+        notes.push(note);
+    }
+    const [first, ...others] = found;
+    if (first === undefined) {
+      throw new SecretLookupError("not-found", `No secret for seal root ${seal2.rootId} was found: ${[...new Set(notes)].join("; ")}`, ". Pass secret_file, or enter the secret at the sidecar (safekb-mcp --sidecar).");
+    }
+    if (others.length > 0) {
+      throw new SecretLookupError("ambiguous", `Seal root ${seal2.rootId} has a secret in more than one store (${found.map(({ store }) => store).join(", ")})`, "; pass store to say which one to use");
+    }
+    return first;
+  }
+  keyStore(name) {
+    if (name !== "default")
+      return this.require(name);
+    const { defaultKeyStore } = this.set;
+    if (defaultKeyStore === null) {
+      throw new SecretLookupError("no-default", "No default store is set up for new keys", "; run: safekb-mcp --configure. Or pass store (system, file, sidecar), key_out_path or passphrase.");
+    }
+    return this.require(defaultKeyStore);
+  }
+  noticeFor(store) {
+    return store === "file" ? this.set.keyFilesNotice ?? null : null;
+  }
+  keyStores() {
+    const { system, file } = this.set;
+    return [system, file].filter((store) => store !== null);
+  }
+  sidecar() {
+    return this.require("sidecar");
+  }
+  enabled() {
+    const { system, file, sidecar } = this.set;
+    return [system, file, sidecar].filter((store) => store !== null);
+  }
+  require(name) {
+    const store = this.set[name];
+    if (store === null)
+      throw new ClientError(HOW_TO_ENABLE[name]);
+    return store;
+  }
+}
+function isKeyStoreName(name) {
+  return KEY_STORE_NAMES.includes(name);
+}
+
 // src/backup/export/sealedRoots.ts
 function unanswered(error) {
   return error instanceof NetworkError || error instanceof ApiError;
@@ -8667,35 +9353,38 @@ function unanswered(error) {
 class SealedRoots {
   ctx;
   services;
-  locked = new Set;
-  constructor(ctx, services) {
+  skipLocked;
+  locked = new Map;
+  constructor(ctx, services, skipLocked) {
     this.ctx = ctx;
     this.services = services;
+    this.skipLocked = skipLocked;
   }
-  async unlock(rootIds, skipLocked) {
-    const refused = [];
+  async unlock(rootIds) {
     for (const rootId of rootIds) {
       try {
         await this.services.roots.unlock({ root_id: rootId });
       } catch (error) {
         if (!(error instanceof ClientError) || unanswered(error))
           throw error;
-        this.locked.add(rootId);
-        refused.push(`  ${printable2(await this.ctx.names.describe(rootId))}: ${error.message}`);
+        this.locked.set(rootId, error instanceof SecretLookupError ? error.problem : error.message);
       }
     }
-    if (refused.length > 0 && !skipLocked) {
-      throw new ClientError(`${refused.length} seal root(s) cannot be opened, so the export would be incomplete:
-${refused.join(`
-`)}
-Put their secrets where this machine finds them (a passphrase: safekb-mcp --sidecar, then 'add <name or id>'), or pass --skip-locked to export without them.`);
-    }
   }
-  isLocked(rootId) {
-    return this.locked.has(rootId);
+  treatmentOf(rootId) {
+    if (!this.locked.has(rootId))
+      return "open";
+    return this.skipLocked ? "left-out" : "raw";
   }
   lockedIds() {
-    return [...this.locked];
+    return [...this.locked.keys()];
+  }
+  async describeLocked() {
+    const described = [];
+    for (const [rootId, reason] of this.locked) {
+      described.push(`${printable2(await this.ctx.names.describe(rootId))}: ${reason}`);
+    }
+    return described;
   }
 }
 
@@ -8816,11 +9505,13 @@ class Exporter {
   progress;
   exported = new Exported;
   roots;
+  raw;
   constructor(from, request, progress) {
     this.from = from;
     this.request = request;
     this.progress = progress;
-    this.roots = new SealedRoots(from.sealed, from.services);
+    this.roots = new SealedRoots(from.sealed, from.services, request.skipLocked);
+    this.raw = new RawSealedExporter(from.sealed, this.exported);
   }
   async prepare() {
     const { kb } = this.from;
@@ -8840,13 +9531,19 @@ class Exporter {
       if (node.sealRootId !== null)
         needed.add(node.sealRootId);
     }
-    await this.roots.unlock(needed, this.request.skipLocked);
+    await this.roots.unlock(needed);
+    await this.announceLocked();
     return { plan, credentials, sealRoots };
   }
   async* entries(prepared) {
     const { kb, sealed, services } = this.from;
     const { plan } = prepared;
     yield { record: this.manifest() };
+    for (const rootId of this.roots.lockedIds()) {
+      if (this.roots.treatmentOf(rootId) === "raw") {
+        yield { record: await this.raw.root(rootId) };
+      }
+    }
     for (const space of plan.spaces) {
       this.exported.count("space");
       yield { record: spaceRecord(space) };
@@ -8857,12 +9554,13 @@ class Exporter {
       sealed,
       services,
       access: new NodeAccess(sealed),
-      roots: this.roots
+      roots: this.roots,
+      raw: this.raw
     }, this.exported);
     for (const node of plan.nodes)
       yield* nodes.entries(node);
     this.progress(`Credentials: ${prepared.credentials.length}`);
-    yield* new CredentialExporter(kb, new CredentialAccess(sealed), this.roots, this.exported).entries(prepared.credentials, prepared.sealRoots);
+    yield* new CredentialExporter(kb, new CredentialAccess(sealed), this.roots, this.raw, this.exported).entries(prepared.credentials, prepared.sealRoots);
     this.progress("Projects, tasks and decisions");
     yield* new WorkExporter(kb, this.exported).entries(plan);
     this.progress("Canvas blocks and database rows");
@@ -8888,13 +9586,22 @@ class Exporter {
       selection: this.request.selection
     };
   }
+  async announceLocked() {
+    const locked = await this.roots.describeLocked();
+    if (locked.length === 0)
+      return;
+    const how = this.request.skipLocked ? "left out (--skip-locked)" : "exported as stored, still sealed: an import opens them with their keys (--keys)";
+    this.progress(`${locked.length} seal root(s) cannot be opened here and are ${how}: ${locked.join("; ")}`);
+  }
   async end() {
-    const locked = [];
-    for (const rootId of this.roots.lockedIds()) {
-      locked.push(await this.from.sealed.names.describe(rootId));
-    }
-    if (locked.length > 0) {
-      this.exported.leftOut.push(`everything of ${locked.length} seal root(s) that could not be opened: ${locked.join(", ")}`);
+    if (this.request.skipLocked) {
+      const locked = [];
+      for (const rootId of this.roots.lockedIds()) {
+        locked.push(await this.from.sealed.names.describe(rootId));
+      }
+      if (locked.length > 0) {
+        this.exported.leftOut.push(`everything of ${locked.length} seal root(s) that could not be opened: ${locked.join(", ")}`);
+      }
     }
     return {
       kind: "end",
@@ -8936,24 +9643,85 @@ class Exporter {
     }
   }
 }
-function spaceRecord(space) {
-  return {
-    kind: "space",
-    id: space.id,
-    name: space.name,
-    icon: space.icon,
-    color: space.color,
-    description: space.description,
-    access_mode: space.access_mode,
-    workflow_states: space.workflow_states,
-    allow_client_uploads: space.allow_client_uploads,
-    encryption_policy: space.encryption_policy
-  };
-}
+function spaceRecord(space) {
+  return {
+    kind: "space",
+    id: space.id,
+    name: space.name,
+    icon: space.icon,
+    color: space.color,
+    description: space.description,
+    access_mode: space.access_mode,
+    workflow_states: space.workflow_states,
+    allow_client_uploads: space.allow_client_uploads,
+    encryption_policy: space.encryption_policy
+  };
+}
+
+// src/backup/import/rawRootKeys.ts
+var NOT_KEPT = [
+  "not-found",
+  "no-store"
+];
+
+class RawRootKeys {
+  given;
+  storesOf;
+  stores = new Map;
+  constructor(given, storesOf) {
+    this.given = given;
+    this.storesOf = storesOf;
+  }
+  async open(tenant, rootId, sealValue) {
+    const seal2 = assertSeal(sealValue);
+    const ctx = { tenant, root: rootId };
+    const forRoot = this.given.filter((file) => file.root_id === rootId);
+    const fitting = forRoot.find((file) => file.tenant_id === tenant && file.kid === seal2.kid);
+    if (fitting !== undefined) {
+      return { keys: await unlockSealRoot(ctx, seal2, fitting.key) };
+    }
+    const kept = await this.kept(tenant, rootId, seal2);
+    if ("keys" in kept || forRoot.length === 0)
+      return kept;
+    const why = forRoot.some((file) => file.tenant_id === tenant) ? "the key given for it is outdated: its secret was changed since" : "the key given for it belongs to another account";
+    return { reason: `${why}; ${kept.reason}` };
+  }
+  async kept(tenant, rootId, seal2) {
+    const stores = await this.storesFor(tenant);
+    let secrets;
+    try {
+      ({ secrets } = await stores.find({ rootId, kid: seal2.kid, secretKind: seal2.secret_kind }, undefined));
+    } catch (error) {
+      if (error instanceof SecretLookupError && NOT_KEPT.includes(error.kind)) {
+        return { reason: error.problem };
+      }
+      throw error;
+    }
+    for (const secret2 of secrets) {
+      try {
+        return {
+          keys: await unlockSealRoot({ tenant, root: rootId }, seal2, secret2)
+        };
+      } catch (error) {
+        if (!(error instanceof WrongSecretError))
+          throw error;
+      }
+    }
+    return { reason: "the secret this machine keeps for it does not open it" };
+  }
+  storesFor(tenant) {
+    let stores = this.stores.get(tenant);
+    if (stores === undefined) {
+      stores = this.storesOf(tenant);
+      this.stores.set(tenant, stores);
+    }
+    return stores;
+  }
+}
 
 // src/claudeCode.ts
 import { spawn as spawn2 } from "node:child_process";
-import { basename as basename2 } from "node:path";
+import { basename as basename3 } from "node:path";
 var SERVER_NAME = "safekb";
 var PACKAGE_NAME = "@safekb/mcp";
 var BIN_NAME = "safekb-mcp";
@@ -9026,7 +9794,7 @@ function words(registration) {
   return [registration.command, ...registration.args.split(/\s+/)];
 }
 function startsThisClient(registration) {
-  return words(registration).some((word) => word === PACKAGE_NAME || word.startsWith(`${PACKAGE_NAME}@`) || [BIN_NAME, `${BIN_NAME}.js`].includes(basename2(word)));
+  return words(registration).some((word) => word === PACKAGE_NAME || word.startsWith(`${PACKAGE_NAME}@`) || [BIN_NAME, `${BIN_NAME}.js`].includes(basename3(word)));
 }
 function pinnedBeforeServeFlag(registration) {
   for (const word of words(registration)) {
@@ -22939,7 +23707,7 @@ class HostedProxy {
 }
 
 // src/keyring.ts
-import { readdir, stat as stat3 } from "node:fs/promises";
+import { readdir, stat as stat4 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 var KEY_FILE_SUFFIX = ".json";
 async function readEntry(path) {
@@ -22968,7 +23736,7 @@ class Keyring {
     this.dir = dir;
   }
   async load() {
-    const info = await stat3(this.dir).catch(() => null);
+    const info = await stat4(this.dir).catch(() => null);
     if (info === null || !info.isDirectory()) {
       throw new ClientError(`Keyring ${this.dir} is not a directory`);
     }
@@ -23012,92 +23780,6 @@ class Keyring {
   }
 }
 
-// src/stores/secretStores.ts
-var HOW_TO_ENABLE = {
-  system: "The system keyring is not set up for this client; run: safekb-mcp --configure",
-  file: "No key file directory is set up; start the client with --keyring <dir>, or run: safekb-mcp --configure",
-  sidecar: "The sidecar is not available on this platform"
-};
-
-class SecretLookupError extends ClientError {
-  kind;
-  problem;
-  constructor(kind, problem, toolAdvice) {
-    super(`${problem}${toolAdvice}`);
-    this.kind = kind;
-    this.problem = problem;
-  }
-}
-
-class SecretStores {
-  set;
-  constructor(set2) {
-    this.set = set2;
-  }
-  async holds(rootId, kid) {
-    for (const store of this.enabled()) {
-      if (await store.holds(rootId, kid))
-        return true;
-    }
-    return false;
-  }
-  async find(seal2, only) {
-    const stores = only === undefined ? this.enabled() : [this.require(only)];
-    if (stores.length === 0) {
-      throw new SecretLookupError("no-store", "No secret given and no secret store is set up", ": pass secret_file, run safekb-mcp --configure, or start the client with --keyring <dir>");
-    }
-    const found = [];
-    const notes = [];
-    for (const store of stores) {
-      const { secrets, note } = await store.lookup(seal2);
-      if (secrets.length > 0)
-        found.push({ store: store.name, secrets });
-      else
-        notes.push(note);
-    }
-    const [first, ...others] = found;
-    if (first === undefined) {
-      throw new SecretLookupError("not-found", `No secret for seal root ${seal2.rootId} was found: ${[...new Set(notes)].join("; ")}`, ". Pass secret_file, or enter the secret at the sidecar (safekb-mcp --sidecar).");
-    }
-    if (others.length > 0) {
-      throw new SecretLookupError("ambiguous", `Seal root ${seal2.rootId} has a secret in more than one store (${found.map(({ store }) => store).join(", ")})`, "; pass store to say which one to use");
-    }
-    return first;
-  }
-  keyStore(name) {
-    if (name !== "default")
-      return this.require(name);
-    const { defaultKeyStore } = this.set;
-    if (defaultKeyStore === null) {
-      throw new SecretLookupError("no-default", "No default store is set up for new keys", "; run: safekb-mcp --configure. Or pass store (system, file, sidecar), key_out_path or passphrase.");
-    }
-    return this.require(defaultKeyStore);
-  }
-  noticeFor(store) {
-    return store === "file" ? this.set.keyFilesNotice ?? null : null;
-  }
-  keyStores() {
-    const { system, file: file2 } = this.set;
-    return [system, file2].filter((store) => store !== null);
-  }
-  sidecar() {
-    return this.require("sidecar");
-  }
-  enabled() {
-    const { system, file: file2, sidecar } = this.set;
-    return [system, file2, sidecar].filter((store) => store !== null);
-  }
-  require(name) {
-    const store = this.set[name];
-    if (store === null)
-      throw new ClientError(HOW_TO_ENABLE[name]);
-    return store;
-  }
-}
-function isKeyStoreName(name) {
-  return KEY_STORE_NAMES.includes(name);
-}
-
 // src/keys/heldKeys.ts
 async function heldKeys(stores) {
   const held = [];
@@ -23414,6 +24096,7 @@ Usage:
   safekb-mcp --export <file> [--space <space id>]... [--doc <document id>]... [--compress]
                      [--skip-locked]
   safekb-mcp --import <file> [--into-space <space id>] [--store system|file]
+                     [--keys <key export>]...
 
 Without arguments this text is printed.
 
@@ -23463,13 +24146,15 @@ Options:
   --export <file>    Write what this token reaches to a new file, encrypted under a passphrase you
                      type: spaces, folders, documents, attachments, databases, credentials,
                      projects, tasks, decisions and links. Sealed content and credential secrets
-                     are decrypted on this machine and are in the file, so every seal root in
-                     the selection must be openable with a secret this machine keeps or its
-                     sidecar holds. Without --space and --doc everything is exported. Needs a
-                     terminal.
+                     are decrypted on this machine and are in the file. A seal root that no
+                     secret this machine keeps or its sidecar holds opens is written as the
+                     server stores it, still sealed. Without --space and --doc everything is
+                     exported. Needs a terminal.
   --import <file>    Create what such a file holds, as new things with new ids, in the account
                      of this token: nothing that exists is changed. Each exported space becomes
-                     a new space, each seal root a new seal root with a newly generated key.
+                     a new space, each seal root a new seal root with a newly generated key. A
+                     seal root the file holds as stored is opened with a key from --keys or
+                     one this machine keeps; without one, everything in it is left out.
                      Needs a terminal.
   --space <space id>  With --create-key: the space of the new seal root. With --export: export
                      this space with everything in it; may be repeated.
@@ -23477,7 +24162,10 @@ Options:
                      it; may be repeated, and combined with --space.
   --compress         With --export: compress (gzip) before encrypting.
   --skip-locked      With --export: leave out what belongs to a seal root that cannot be opened,
-                     instead of stopping.
+                     instead of writing it as stored.
+  --keys <file>      With --import: a key export (--export-keys) whose keys open the seal roots
+                     the file holds as stored. Its passphrase is asked; its keys are used for
+                     this import only and are not kept. May be repeated.
   --into-space <space id>  With --import: put everything into this one existing space instead of
                      creating the exported spaces again.
   --name <new name>  With --rename-key: the new name.
@@ -23561,7 +24249,13 @@ var MODIFIERS = {
     "compress",
     "skip-locked"
   ],
-  import: [...KEY_MODE_MODIFIERS, "into-space", "store"]
+  import: [
+    ...KEY_MODE_MODIFIERS,
+    "sidecar-socket",
+    "into-space",
+    "store",
+    "keys"
+  ]
 };
 var A_SEAL_ROOT = "the name or the id of a seal root";
 var MODE_VALUES = {
@@ -23666,6 +24360,7 @@ ${USAGE}`);
     exportDocumentIds: several(values.doc),
     compress: values.compress === true,
     skipLocked: values["skip-locked"] === true,
+    keyExports: several(values.keys),
     intoSpaceId: nonEmpty(values["into-space"]),
     store: keyStoreOf(values.store),
     confirm: values.confirm === true,
@@ -23707,6 +24402,7 @@ function parse5(argv) {
       compress: { type: "boolean" },
       "skip-locked": { type: "boolean" },
       "into-space": { type: "string" },
+      keys: { type: "string", multiple: true },
       name: { type: "string" },
       store: { type: "string" },
       help: { type: "boolean" },
@@ -23716,329 +24412,104 @@ function parse5(argv) {
 }
 
 // src/rootNames.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
-var ROOT_NAMES_FILE = "roots.json";
-var ROOT_NAMES_VERSION = 1;
-var OBJECT_ID3 = /^[0-9a-f]{24}$/;
-function rootNamesPath(tokenConfigPath) {
-  return join5(dirname3(tokenConfigPath), ROOT_NAMES_FILE);
-}
-function assertNames(value, path) {
-  const raw = value;
-  const names = raw?.names;
-  if (raw?.v !== ROOT_NAMES_VERSION || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([id, name]) => OBJECT_ID3.test(id) && typeof name === "string" && name.length > 0)) {
-    throw new ClientError(`Seal root names ${path} are malformed`);
-  }
-  return new Map(Object.entries(names));
-}
-
-class RootNames {
-  path;
-  changes = Promise.resolve();
-  constructor(path) {
-    this.path = path;
-  }
-  async all() {
-    if (!existsSync3(this.path))
-      return new Map;
-    const text = await readPrivateFile(this.path, "Seal root names");
-    let parsed;
-    try {
-      parsed = JSON.parse(text);
-    } catch {
-      throw new ClientError(`Seal root names ${this.path} are not valid JSON`);
-    }
-    return assertNames(parsed, this.path);
-  }
-  async nameOf(rootId) {
-    return (await this.all()).get(rootId) ?? null;
-  }
-  async describe(rootId) {
-    const name = await this.nameOf(rootId);
-    return name === null ? rootId : `"${name}" (${rootId})`;
-  }
-  remember(rootId, name) {
-    if (name.length === 0 || OBJECT_ID3.test(name))
-      return this.forget(rootId);
-    return this.change(async () => {
-      const names = await this.all();
-      if (names.get(rootId) === name)
-        return;
-      names.set(rootId, name);
-      await this.save(names);
-    });
-  }
-  forget(rootId) {
-    return this.change(async () => {
-      const names = await this.all();
-      if (names.delete(rootId))
-        await this.save(names);
-    });
-  }
-  change(apply) {
-    const done = this.changes.then(apply);
-    this.changes = done.catch(() => {});
-    return done;
-  }
-  follow(done, change) {
-    return followUp(done, "its name could not be updated on this machine", change);
-  }
-  async assertUsable(name, rootId) {
-    if (OBJECT_ID3.test(name)) {
-      throw new ClientError(`"${name}" has the shape of an id, so it cannot be the name of a seal root`);
-    }
-    for (const [id, taken] of await this.all()) {
-      if (taken === name && id !== rootId) {
-        throw new ClientError(`Seal root ${id} is already named "${name}" on this machine; choose another name`);
-      }
-    }
-  }
-  async isName(reference) {
-    return [...(await this.all()).values()].includes(reference);
-  }
-  async resolve(reference) {
-    if (OBJECT_ID3.test(reference))
-      return reference;
-    const ids = [...await this.all()].filter(([, name]) => name === reference).map(([id]) => id);
-    const [first, ...others] = ids;
-    if (first === undefined) {
-      throw new ClientError(`No seal root is known as "${reference}"; use its id`);
-    }
-    if (others.length > 0) {
-      throw new ClientError(`${ids.length} seal roots are named "${reference}" (${ids.join(", ")}); use the id`);
-    }
-    return first;
-  }
-  save(names) {
-    const sorted = Object.fromEntries([...names].sort(([a], [b]) => a.localeCompare(b)));
-    return writePrivateFile(this.path, `${JSON.stringify({ v: ROOT_NAMES_VERSION, names: sorted }, null, 2)}
-`);
-  }
-}
-
-// src/sealed/attachmentService.ts
-import { createReadStream as createReadStream2 } from "node:fs";
-import { open as open4, stat as stat4, unlink } from "node:fs/promises";
-import { basename as basename3 } from "node:path";
-var DOWNLOAD_FILE_MODE = 384;
-var DEFAULT_MIME_TYPE = "application/octet-stream";
-async function* fileBytes(path) {
-  try {
-    for await (const chunk of createReadStream2(path))
-      yield chunk;
-  } catch (error48) {
-    throw fileError(error48);
-  }
-}
-async function* verified(plaintext, meta3) {
-  const hash2 = await createStreamingSha256();
-  let size = 0;
-  for await (const chunk of plaintext) {
-    hash2.update(chunk);
-    size += chunk.length;
-    yield chunk;
-  }
-  if (size !== meta3.size || hash2.digestHex() !== meta3.sha256_plain) {
-    throw new ClientError("Downloaded attachment does not match its sealed size and hash");
-  }
-}
-
-class AttachmentService {
-  ctx;
-  access;
-  constructor(ctx, access) {
-    this.ctx = ctx;
-    this.access = access;
-  }
-  async list(documentId) {
-    const opened = await this.access.open(documentId);
-    const attachments = [];
-    for (const record2 of await this.ctx.api.listAttachments(documentId)) {
-      const meta3 = await this.metaOf(opened, record2);
-      attachments.push({
-        id: record2.id,
-        filename: meta3.filename,
-        mime: meta3.mime,
-        size: meta3.size
-      });
-    }
-    return {
-      document_id: documentId,
-      seal_seq: opened.node.seal_seq,
-      attachments
-    };
-  }
-  async upload(args) {
-    const opened = await this.access.open(args.document_id);
-    assertSeq(opened.node, args.expected_seq);
-    assertAccepted(opened.node);
-    const info = await stat4(args.file_path).catch((error48) => {
-      throw fileError(error48);
-    });
-    if (!info.isFile()) {
-      throw new ClientError(`${args.file_path} is not a regular file; only regular files can be attached`);
-    }
-    await this.assertWithinLimit(args.file_path, info.size);
-    return this.attachTo(opened, {
-      filename: basename3(args.file_path),
-      mime: args.mime_type,
-      bytes: fileBytes(args.file_path)
-    });
-  }
-  async attach(args) {
-    const opened = await this.access.open(args.document_id);
-    assertSeq(opened.node, args.expected_seq);
-    assertAccepted(opened.node);
-    await this.assertWithinLimit(`'${args.file.filename}'`, args.size);
-    return this.attachTo(opened, args.file);
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+var ROOT_NAMES_FILE = "roots.json";
+var ROOT_NAMES_VERSION = 1;
+var OBJECT_ID4 = /^[0-9a-f]{24}$/;
+function rootNamesPath(tokenConfigPath) {
+  return join5(dirname3(tokenConfigPath), ROOT_NAMES_FILE);
+}
+function assertNames(value, path) {
+  const raw = value;
+  const names = raw?.names;
+  if (raw?.v !== ROOT_NAMES_VERSION || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([id, name]) => OBJECT_ID4.test(id) && typeof name === "string" && name.length > 0)) {
+    throw new ClientError(`Seal root names ${path} are malformed`);
   }
-  async attachTo(opened, plain) {
-    const { node, dek } = opened;
-    const ctx = this.attachmentContext(node.id, newObjectId());
-    const file2 = await this.encrypt(dek, ctx, plain);
-    const attEncMeta = serializeEnvelope(await encryptAttachmentMeta(dek, ctx, file2.meta));
-    const sigs = await this.access.sign({
-      op: "attach",
-      tenant: this.ctx.tenant,
-      node: node.id,
-      root: node.seal_root_id,
-      baseSeq: node.seal_seq,
-      attId: ctx.attId,
-      blobCtSha256: file2.blobSha256,
-      attEncMeta
-    }, [node.seal_root_id]);
-    const stored = await this.ctx.api.attach(node.id, {
-      base_seq: node.seal_seq,
-      att_id: ctx.attId,
-      att_enc_meta: attEncMeta,
-      blob_sha256: file2.blobSha256,
-      ciphertext: file2.ciphertext,
-      sigs
-    });
-    return {
-      attachment_id: stored.id,
-      document_id: node.id,
-      seal_seq: stored.seal_seq,
-      size: file2.meta.size
-    };
+  return new Map(Object.entries(names));
+}
+
+class RootNames {
+  path;
+  changes = Promise.resolve();
+  constructor(path) {
+    this.path = path;
   }
-  async files(documentId) {
-    const opened = await this.access.open(documentId);
-    const files = [];
-    for (const record2 of await this.ctx.api.listAttachments(documentId)) {
-      const meta3 = await this.metaOf(opened, record2);
-      files.push({
-        id: record2.id,
-        meta: meta3,
-        bytes: () => this.plaintextOf(opened, record2.id, meta3)
-      });
+  async all() {
+    if (!existsSync3(this.path))
+      return new Map;
+    const text = await readPrivateFile(this.path, "Seal root names");
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new ClientError(`Seal root names ${this.path} are not valid JSON`);
     }
-    return files;
+    return assertNames(parsed, this.path);
   }
-  async* plaintextOf(opened, attachmentId, meta3) {
-    const ciphertext = await this.ctx.api.downloadAttachment(opened.node.id, attachmentId);
-    yield* verified(decryptAttachment(opened.dek, this.attachmentContext(opened.node.id, attachmentId), ciphertext), meta3);
+  async nameOf(rootId) {
+    return (await this.all()).get(rootId) ?? null;
   }
-  async download(args) {
-    const opened = await this.access.open(args.document_id);
-    const record2 = (await this.ctx.api.listAttachments(args.document_id)).find((candidate) => candidate.id === args.attachment_id);
-    if (record2 === undefined) {
-      throw new ClientError(`${args.document_id} has no attachment ${args.attachment_id}`);
-    }
-    const meta3 = await this.metaOf(opened, record2);
-    await this.write(args.out_path, this.plaintextOf(opened, args.attachment_id, meta3));
-    return {
-      attachment_id: args.attachment_id,
-      out_path: args.out_path,
-      filename: meta3.filename,
-      size: meta3.size
-    };
+  async describe(rootId) {
+    const name = await this.nameOf(rootId);
+    return name === null ? rootId : `"${name}" (${rootId})`;
   }
-  async delete(args) {
-    const node = await this.ctx.api.getNode(args.document_id);
-    assertSeq(node, args.expected_seq);
-    const sigs = await this.access.sign({
-      op: "detach",
-      tenant: this.ctx.tenant,
-      node: node.id,
-      root: node.seal_root_id,
-      baseSeq: node.seal_seq,
-      attId: args.attachment_id
-    }, [node.seal_root_id]);
-    const changed = await this.ctx.api.detach(node.id, {
-      base_seq: node.seal_seq,
-      att_id: args.attachment_id,
-      sigs
+  remember(rootId, name) {
+    if (name.length === 0 || OBJECT_ID4.test(name))
+      return this.forget(rootId);
+    return this.change(async () => {
+      const names = await this.all();
+      if (names.get(rootId) === name)
+        return;
+      names.set(rootId, name);
+      await this.save(names);
     });
-    return { document_id: node.id, seal_seq: changed.seal_seq, deleted: true };
   }
-  attachmentContext(nodeId, attId) {
-    return { ...this.access.nodeContext(nodeId), attId };
+  forget(rootId) {
+    return this.change(async () => {
+      const names = await this.all();
+      if (names.delete(rootId))
+        await this.save(names);
+    });
   }
-  metaOf(opened, record2) {
-    if (!record2.sealed || record2.att_enc_meta === null) {
-      throw new ClientError(`Attachment ${record2.id} is not sealed`);
-    }
-    return decryptAttachmentMeta(opened.dek, this.attachmentContext(opened.node.id, record2.id), parseEnvelope(record2.att_enc_meta));
+  change(apply) {
+    const done = this.changes.then(apply);
+    this.changes = done.catch(() => {});
+    return done;
   }
-  async encrypt(dek, ctx, file2) {
-    const plainHash = await createStreamingSha256();
-    const cipherHash = await createStreamingSha256();
-    let size = 0;
-    async function* plaintext() {
-      for await (const bytes of file2.bytes) {
-        plainHash.update(bytes);
-        size += bytes.length;
-        yield bytes;
-      }
-    }
-    const parts = [];
-    for await (const part of encryptAttachment(dek, ctx, plaintext())) {
-      cipherHash.update(part);
-      parts.push(part);
-    }
-    return {
-      ciphertext: new Blob(parts),
-      blobSha256: cipherHash.digestHex(),
-      meta: {
-        filename: file2.filename,
-        mime: file2.mime,
-        size,
-        sha256_plain: plainHash.digestHex()
-      }
-    };
+  follow(done, change) {
+    return followUp(done, "its name could not be updated on this machine", change);
   }
-  async assertWithinLimit(what, size) {
-    const { max_file_size_bytes: limit } = await this.ctx.api.limits();
-    if (!Number.isSafeInteger(limit) || limit <= 0) {
-      throw new ClientError("The server did not report a usable upload limit (max_file_size_bytes)");
+  async assertUsable(name, rootId) {
+    if (OBJECT_ID4.test(name)) {
+      throw new ClientError(`"${name}" has the shape of an id, so it cannot be the name of a seal root`);
     }
-    const sealedSize = attachmentCiphertextSize(size);
-    if (sealedSize > limit) {
-      throw new ClientError(`${what} is too large to attach: it is ${size} bytes, ${sealedSize} bytes once sealed, and the server accepts at most ${limit} bytes`);
+    for (const [id, taken] of await this.all()) {
+      if (taken === name && id !== rootId) {
+        throw new ClientError(`Seal root ${id} is already named "${name}" on this machine; choose another name`);
+      }
     }
   }
-  async write(path, plaintext) {
-    let handle;
-    try {
-      handle = await open4(path, "wx", DOWNLOAD_FILE_MODE);
-    } catch (error48) {
-      if (error48.code === "EEXIST") {
-        throw new ClientError(`${path} already exists; choose a new out_path`);
-      }
-      throw fileError(error48);
+  async isName(reference) {
+    return [...(await this.all()).values()].includes(reference);
+  }
+  async resolve(reference) {
+    if (OBJECT_ID4.test(reference))
+      return reference;
+    const ids = [...await this.all()].filter(([, name]) => name === reference).map(([id]) => id);
+    const [first, ...others] = ids;
+    if (first === undefined) {
+      throw new ClientError(`No seal root is known as "${reference}"; use its id`);
     }
-    let complete = false;
-    try {
-      for await (const chunk of plaintext)
-        await handle.write(chunk);
-      complete = true;
-    } finally {
-      await handle.close();
-      if (!complete)
-        await unlink(path);
+    if (others.length > 0) {
+      throw new ClientError(`${ids.length} seal roots are named "${reference}" (${ids.join(", ")}); use the id`);
     }
+    return first;
+  }
+  save(names) {
+    const sorted = Object.fromEntries([...names].sort(([a], [b]) => a.localeCompare(b)));
+    return writePrivateFile(this.path, `${JSON.stringify({ v: ROOT_NAMES_VERSION, names: sorted }, null, 2)}
+`);
   }
 }
 
@@ -26457,7 +26928,7 @@ class SecretHolder {
 import { chmod, lstat, rm as rm3 } from "node:fs/promises";
 import { connect as connect2, createServer } from "node:net";
 var SOCKET_MODE = 384;
-var OBJECT_ID4 = /^[0-9a-f]{24}$/;
+var OBJECT_ID5 = /^[0-9a-f]{24}$/;
 var MAX_REQUEST_BYTES = 4096;
 var CLIENT_GONE = "The client that asked is gone";
 var MAX_SOCKET_PATH_BYTES = 103;
@@ -26488,7 +26959,7 @@ async function clearSocketPath(socketPath) {
   await rm3(socketPath);
 }
 function requireRootId2(value) {
-  if (typeof value !== "string" || !OBJECT_ID4.test(value)) {
+  if (typeof value !== "string" || !OBJECT_ID5.test(value)) {
     throw new ClientError("root_id must be a 24-character id");
   }
   return value;
@@ -27398,7 +27869,7 @@ class TransferConsole {
 `);
   }
   async import(path) {
-    const passphrase = await readPassphrase(this.reader);
+    const passphrase = await readPassphrase(this.reader, EXPORT_FILE);
     const { imported, store, present } = await this.transfer.import(path, passphrase);
     if (store !== null) {
       this.reader.write(`Imported ${imported.length} key(s) into ${KEY_STORE_LABELS[store]}:
@@ -27420,90 +27891,7 @@ class TransferConsole {
 }
 
 // src/transfer/keyTransfer.ts
-import { readFile } from "node:fs/promises";
-
-// src/transfer/keyBundle.ts
-var KEY_BUNDLE_KIND = "safekb-key-export";
-var KEY_BUNDLE_VERSION = 1;
-var KEY_INFO2 = "safekb/key-export/v1";
-var EXPORT_KDF = MIN_KDF_PARAMS;
-var MAX_KDF2 = { m: 256 * 1024, t: 8, p: 4 };
-var OBJECT_ID5 = /^[0-9a-f]{24}$/;
-function malformed2(why) {
-  return new ClientError(`Not a SafeKB key export: ${why}`);
-}
-function aadOf(salt, kdf) {
-  return `${KEY_INFO2}|${salt}|${kdf.m}|${kdf.t}|${kdf.p}`;
-}
-async function bundleKey(passphrase, salt, kdf) {
-  return deriveKey(await derivePassphraseIkm(passphrase, salt, kdf), KEY_INFO2);
-}
-function assertContent(value) {
-  const raw = value;
-  const names = raw?.names;
-  if (!Array.isArray(raw?.keys) || typeof names !== "object" || names === null || Array.isArray(names) || !Object.entries(names).every(([rootId, name]) => OBJECT_ID5.test(rootId) && typeof name === "string" && name.length > 0)) {
-    throw malformed2("its content is not keys and the names of their roots");
-  }
-  return { keys: raw.keys.map(assertKeyFile), names: { ...names } };
-}
-function parseBundle(text) {
-  let value;
-  try {
-    value = JSON.parse(text);
-  } catch {
-    throw malformed2("it is not valid JSON");
-  }
-  const raw = value;
-  if (raw?.kind !== KEY_BUNDLE_KIND) {
-    throw malformed2(`its kind is not '${KEY_BUNDLE_KIND}'`);
-  }
-  if (raw.v !== KEY_BUNDLE_VERSION) {
-    throw malformed2(`its version is not ${KEY_BUNDLE_VERSION}; use the version of @safekb/mcp that wrote it`);
-  }
-  const { kdf, salt } = raw;
-  if (typeof kdf !== "object" || kdf === null || typeof salt !== "string") {
-    throw malformed2("it has no KDF parameters and salt");
-  }
-  const params = assertKdfParams(kdf);
-  if (params.m > MAX_KDF2.m || params.t > MAX_KDF2.t || params.p > MAX_KDF2.p) {
-    throw malformed2("its KDF parameters are beyond what this client runs");
-  }
-  return {
-    v: raw.v,
-    kind: raw.kind,
-    kdf: params,
-    salt,
-    sealed: assertEnvelope(raw.sealed)
-  };
-}
-async function sealKeyBundle(content, passphrase) {
-  const saltBytes = randomBytes(SALT_BYTES);
-  const salt = toBase64(saltBytes);
-  const bundle = {
-    v: KEY_BUNDLE_VERSION,
-    kind: KEY_BUNDLE_KIND,
-    kdf: { ...EXPORT_KDF },
-    salt,
-    sealed: await sealEnvelope(await bundleKey(passphrase, saltBytes, EXPORT_KDF), utf8Encode(JSON.stringify(assertContent(content))), aadOf(salt, EXPORT_KDF))
-  };
-  return `${JSON.stringify(bundle, null, 2)}
-`;
-}
-async function openKeyBundle(text, passphrase) {
-  const bundle = parseBundle(text);
-  const key = await bundleKey(passphrase, fromBase64(bundle.salt), bundle.kdf);
-  let plaintext;
-  try {
-    plaintext = await openEnvelope(key, bundle.sealed, aadOf(bundle.salt, bundle.kdf));
-  } catch (error48) {
-    if (!(error48 instanceof DecryptionError))
-      throw error48;
-    throw new ClientError("Wrong passphrase, or the export file was changed or damaged");
-  }
-  return assertContent(JSON.parse(utf8Decode(plaintext)));
-}
-
-// src/transfer/keyTransfer.ts
+import { readFile as readFile2 } from "node:fs/promises";
 function idOf(file2) {
   return `${file2.tenant_id}/${file2.root_id}/${file2.kid}`;
 }
@@ -27533,7 +27921,7 @@ class KeyTransfer {
     return keys;
   }
   async import(path, passphrase) {
-    const text = await readFile(path, "utf8").catch((error48) => {
+    const text = await readFile2(path, "utf8").catch((error48) => {
       throw fileError(error48);
     });
     const { keys, names } = await openKeyBundle(text, passphrase);
@@ -27630,9 +28018,9 @@ async function openStores(options, tenant, systemKeyring, chosen) {
     sidecar: SIDECAR_SUPPORTED ? new SidecarStore(new SidecarClient(sidecarSocketOf(options)), tenant) : null
   });
 }
-async function openKeyStoresOnly(options, tenant, systemKeyring) {
+async function openKeyStoresOnly(options, tenant, systemKeyring, chosen) {
   return new SecretStores({
-    ...await openKeyStores(options, tenant, systemKeyring, await storesOf(options, systemKeyring, toStderr)),
+    ...await openKeyStores(options, tenant, systemKeyring, chosen),
     sidecar: null
   });
 }
@@ -27640,7 +28028,7 @@ async function transferKeys(options, reader, systemKeyring = new OsKeyring) {
   const transferFile = parsed(options.transferFile);
   const { tenant_id: tenant } = await loadTokenConfig(options.configPath);
   const names = namesOf(options);
-  const terminal = new TransferConsole(reader, new KeyTransfer(await openKeyStoresOnly(options, tenant, systemKeyring), names), names);
+  const terminal = new TransferConsole(reader, new KeyTransfer(await openKeyStoresOnly(options, tenant, systemKeyring, await storesOf(options, systemKeyring, toStderr)), names), names);
   await (options.mode === "export-keys" ? terminal.export(transferFile) : terminal.import(transferFile));
 }
 var WHILE_IT_RUNS = Number.POSITIVE_INFINITY;
@@ -27650,11 +28038,12 @@ async function runBackup(options, reader, systemKeyring = new OsKeyring) {
   const url2 = apiUrlFor(options, config2);
   const http = new HttpClient(url2, config2.token);
   const tenant = config2.tenant_id;
+  const chosen = await storesOf(options, systemKeyring, toStderr);
   const sealed = {
     api: new SealedApi(http),
     session: new SealedSession(WHILE_IT_RUNS),
     tenant,
-    stores: options.mode === "export" ? await openStores(options, tenant, systemKeyring, await storesOf(options, systemKeyring, toStderr)) : await openKeyStoresOnly(options, tenant, systemKeyring),
+    stores: options.mode === "export" ? await openStores(options, tenant, systemKeyring, chosen) : await openKeyStoresOnly(options, tenant, systemKeyring, chosen),
     names: namesOf(options)
   };
   const parts = {
@@ -27677,7 +28066,8 @@ async function runBackup(options, reader, systemKeyring = new OsKeyring) {
       await terminal.export(exporter, file2, options.compress ? "gzip" : "none");
       return;
     }
-    const importer = new Importer(parts, {
+    const rawRootKeys = new RawRootKeys(await terminal.keysFrom(options.keyExports), (sourceTenant) => openStores(options, sourceTenant, systemKeyring, chosen));
+    const importer = new Importer({ ...parts, rawRootKeys }, {
       tenantId: tenant,
       intoSpaceId: options.intoSpaceId,
       store: options.store ?? "default"
@@ -27734,7 +28124,7 @@ async function withKeyCommands(options, systemKeyring, run) {
     api: new SealedApi(new HttpClient(apiUrlFor(options, config2), config2.token)),
     session: new SealedSession(options.idleTtlMs),
     tenant: config2.tenant_id,
-    stores: await openKeyStoresOnly(options, config2.tenant_id, systemKeyring),
+    stores: await openKeyStoresOnly(options, config2.tenant_id, systemKeyring, await storesOf(options, systemKeyring, toStderr)),
     names: namesOf(options)
   };
   try {