From 3ac9a9d7c8a9df4ce6e20d4b2cfc6cb25a079f2e Mon Sep 17 00:00:00 2001
From: Phelipe Lorran <112786693+httpsphl@users.noreply.github.com>
Date: Mon, 5 Oct 2026 14:49:20 -0300
Subject: [PATCH 1/2] feat(backup): import a backup, swapped in on the next
 start

backup.stage opens a backup with the passphrase into <home>/restore and
checks its manifest and database; backup.confirm marks it, and on the
next start, before the database opens, the daemon unpacks it, moves the
current database and the whole workspaces_root aside (never deleted),
and puts the backup's in place. backup.cancel drops it. A marker is
cleared first, so a failing backup is not tried forever. Spec 14.2.
---
 app/src/lib/fakeBackup.ts                     |  55 +++--
 app/src/lib/protocol.gen.ts                   |   8 +
 crates/botloft-core/src/protocol/backup.rs    |   9 +
 .../src/protocol/export_backup.rs             |   8 +
 crates/botloft-core/src/protocol/mod.rs       |   3 +
 crates/botloftd/src/backup/mod.rs             |   1 +
 crates/botloftd/src/backup/restore.rs         | 198 ++++++++++++++++++
 crates/botloftd/src/main.rs                   |   8 +
 crates/botloftd/src/rpc/dispatch.rs           |   3 +
 crates/botloftd/src/service/backup.rs         |  33 ++-
 crates/botloftd/tests/backup_restore.rs       |  89 ++++++++
 docs/spec.md                                  |   5 +-
 12 files changed, 397 insertions(+), 23 deletions(-)
 create mode 100644 crates/botloftd/src/backup/restore.rs
 create mode 100644 crates/botloftd/tests/backup_restore.rs

diff --git a/app/src/lib/fakeBackup.ts b/app/src/lib/fakeBackup.ts
index 81ec2ea3..a415784f 100644
--- a/app/src/lib/fakeBackup.ts
+++ b/app/src/lib/fakeBackup.ts
@@ -1,39 +1,54 @@
 // The fake daemon's backups (spec 14.2): what an export would hold, from
-// the fake crews, at a made-up path. Nothing is sealed or written.
+// the fake crews, at a made-up path, and a backup that opens only with
+// `FAKE_PASSPHRASE`. Nothing is sealed, written or restored.
 
 import type { FakeBotloft, Handlers } from "./fake";
-import { RpcErrorCode } from "./protocol.gen";
+import { type BackupManifest, RpcErrorCode } from "./protocol.gen";
 import { RpcError } from "./rpc";
 
 type BackupMethods = Extract<keyof Handlers, `backup.${string}`>;
 
+/** The passphrase the fake's backups open with. */
+export const FAKE_PASSPHRASE = "correct horse";
+
+function refused(reason: string, message: string): RpcError {
+  return new RpcError(RpcErrorCode.validation, message, reason);
+}
+
+function manifestOf(fake: FakeBotloft): BackupManifest {
+  return {
+    format: 1,
+    createdAt: fake.now,
+    version: "0.10.0",
+    crews: [...fake.crews.values()].map((crew) => ({
+      name: crew.name,
+      bots: [...fake.bots.values()]
+        .filter((bot) => bot.crewId === crew.id && bot.archivedAt === null)
+        .map((bot) => bot.name),
+      workFolder: crew.workFolderChosen ? crew.workFolder : null,
+    })),
+  };
+}
+
 export function backupHandlers(fake: FakeBotloft): Pick<Handlers, BackupMethods> {
   return {
     "backup.export": ({ passphrase }) => {
       if ([...passphrase].length < 8) {
-        throw new RpcError(
-          RpcErrorCode.validation,
-          "the passphrase must have at least 8 characters",
-          "short_passphrase",
-        );
+        throw refused("short_passphrase", "the passphrase must have at least 8 characters");
       }
-      const crews = [...fake.crews.values()];
       return {
         path: "C:\\Users\\owner\\AppData\\Local\\Botloft\\exports\\botloft-2026-10-05-1430.botloft",
         size: 1_234_567,
-        manifest: {
-          format: 1,
-          createdAt: fake.now,
-          version: "0.10.0",
-          crews: crews.map((crew) => ({
-            name: crew.name,
-            bots: [...fake.bots.values()]
-              .filter((bot) => bot.crewId === crew.id && bot.archivedAt === null)
-              .map((bot) => bot.name),
-            workFolder: crew.workFolderChosen ? crew.workFolder : null,
-          })),
-        },
+        manifest: manifestOf(fake),
       };
     },
+    "backup.stage": ({ passphrase }) => {
+      if (passphrase !== FAKE_PASSPHRASE) {
+        throw refused("wrong_passphrase", "the passphrase is wrong, or the file is damaged");
+      }
+      return manifestOf(fake);
+    },
+    "backup.confirm": () => null,
+    "backup.cancel": () => null,
   };
 }
diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts
index 4a584c48..793b7949 100644
--- a/app/src/lib/protocol.gen.ts
+++ b/app/src/lib/protocol.gen.ts
@@ -1079,6 +1079,11 @@ export type BackupExported = { path: string,
  */
 size: number, manifest: BackupManifest, };
 
+/**
+ * `backup.stage`: a backup file the owner picked, and its passphrase.
+ */
+export type BackupStageParams = { path: string, passphrase: string, };
+
 export type ApprovalItem = { approvalId: ApprovalId, toolName: string, summary: string, 
 /**
  * What the bot says the command is for, as in `ToolItem`. The bot
@@ -1778,6 +1783,9 @@ export interface RpcMethods {
   "crewAccess.list": { params: CrewAccessListParams; result: Array<CrewAccess> };
   "crewAccess.revoke": { params: CrewAccessIdParams; result: Array<CrewAccess> };
   "backup.export": { params: BackupExportParams; result: BackupExported };
+  "backup.stage": { params: BackupStageParams; result: BackupManifest };
+  "backup.confirm": { params: undefined; result: null };
+  "backup.cancel": { params: undefined; result: null };
   "routines.list": { params: RoutinesListParams; result: Array<Routine> };
   "routines.create": { params: RoutinesCreateParams; result: Routine };
   "routines.update": { params: RoutinesUpdateParams; result: Routine };
diff --git a/crates/botloft-core/src/protocol/backup.rs b/crates/botloft-core/src/protocol/backup.rs
index 11d6bd59..a2d685ce 100644
--- a/crates/botloft-core/src/protocol/backup.rs
+++ b/crates/botloft-core/src/protocol/backup.rs
@@ -35,6 +35,15 @@ pub struct BackupExportParams {
     pub passphrase: String,
 }
 
+/// `backup.stage`: a backup file the owner picked, and its passphrase.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct BackupStageParams {
+    pub path: String,
+    pub passphrase: String,
+}
+
 /// A backup written and ready for the owner to save elsewhere.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
diff --git a/crates/botloft-core/src/protocol/export_backup.rs b/crates/botloft-core/src/protocol/export_backup.rs
index e6103bc7..009520b2 100644
--- a/crates/botloft-core/src/protocol/export_backup.rs
+++ b/crates/botloft-core/src/protocol/export_backup.rs
@@ -8,6 +8,7 @@ pub(super) fn decls(out: &mut Out) {
     out.decl::<BackupManifest>();
     out.decl::<BackupExportParams>();
     out.decl::<BackupExported>();
+    out.decl::<BackupStageParams>();
 }
 
 pub(super) fn methods(out: &mut Out) {
@@ -16,4 +17,11 @@ pub(super) fn methods(out: &mut Out) {
         &out.name::<BackupExportParams>(),
         &out.name::<BackupExported>(),
     );
+    out.method(
+        method::BACKUP_STAGE,
+        &out.name::<BackupStageParams>(),
+        &out.name::<BackupManifest>(),
+    );
+    out.method(method::BACKUP_CONFIRM, "undefined", "null");
+    out.method(method::BACKUP_CANCEL, "undefined", "null");
 }
diff --git a/crates/botloft-core/src/protocol/mod.rs b/crates/botloft-core/src/protocol/mod.rs
index 05b0e970..becfa437 100644
--- a/crates/botloft-core/src/protocol/mod.rs
+++ b/crates/botloft-core/src/protocol/mod.rs
@@ -129,6 +129,9 @@ pub mod method {
     pub const RULES_LIST: &str = "rules.list";
     pub const RULES_DELETE: &str = "rules.delete";
     pub const BACKUP_EXPORT: &str = "backup.export";
+    pub const BACKUP_STAGE: &str = "backup.stage";
+    pub const BACKUP_CONFIRM: &str = "backup.confirm";
+    pub const BACKUP_CANCEL: &str = "backup.cancel";
     pub const CREW_ACCESS_LIST: &str = "crewAccess.list";
     pub const CREW_ACCESS_REVOKE: &str = "crewAccess.revoke";
     pub const DESKTOP_GRANTS: &str = "desktop.grants";
diff --git a/crates/botloftd/src/backup/mod.rs b/crates/botloftd/src/backup/mod.rs
index 22f43e56..0818da0b 100644
--- a/crates/botloftd/src/backup/mod.rs
+++ b/crates/botloftd/src/backup/mod.rs
@@ -2,6 +2,7 @@
 //! crew's folder, in one file sealed with a passphrase only the owner has.
 
 pub mod export;
+pub mod restore;
 pub mod seal;
 
 /// The extension of a backup file.
diff --git a/crates/botloftd/src/backup/restore.rs b/crates/botloftd/src/backup/restore.rs
new file mode 100644
index 00000000..2d8ae2bc
--- /dev/null
+++ b/crates/botloftd/src/backup/restore.rs
@@ -0,0 +1,198 @@
+//! Importing a backup (spec 14.2). The file is opened and staged while
+//! Botloft runs, and only swapped in on the next start, before the
+//! database opens: nothing has the old data open then. What was there goes
+//! aside, never deleted.
+
+use std::fs::{self, File};
+use std::io::{self, BufReader, BufWriter, Read};
+use std::path::{Path, PathBuf};
+
+use botloft_core::protocol::BackupManifest;
+use tracing::{info, warn};
+use zip::ZipArchive;
+
+use super::seal::{SealError, open};
+use super::{DATABASE_ENTRY, MANIFEST_ENTRY, WORKSPACES_ENTRY};
+use crate::paths::Paths;
+
+const STAGED: &str = "staged.zip";
+/// Written when the owner confirms: the next start applies the backup.
+const READY: &str = "READY";
+/// What the archive unpacks into before the swap.
+const UNPACKED: &str = "unpacked";
+
+fn restore_dir(paths: &Paths) -> PathBuf {
+    paths.home.join("restore")
+}
+
+fn other(err: impl std::fmt::Display) -> io::Error {
+    io::Error::other(err.to_string())
+}
+
+/// "0.10.0" as numbers, to compare.
+fn version(text: &str) -> Vec<u64> {
+    text.split('.')
+        .map(|part| part.trim().parse().unwrap_or(0))
+        .collect()
+}
+
+/// Opens the backup with the passphrase, checks it, and keeps it staged.
+/// Nothing changes until `confirm` and a restart.
+pub fn stage(paths: &Paths, file: &Path, passphrase: &str) -> Result<BackupManifest, SealError> {
+    let dir = restore_dir(paths);
+    let _ = fs::remove_dir_all(&dir);
+    fs::create_dir_all(&dir)?;
+    let staged = dir.join(STAGED);
+    let opened = {
+        let mut sealed = BufReader::new(File::open(file)?);
+        let mut out = BufWriter::new(File::create(&staged)?);
+        open(&mut sealed, &mut out, passphrase)
+    };
+    if let Err(err) = opened {
+        let _ = fs::remove_dir_all(&dir);
+        return Err(err);
+    }
+    let checked = check(&staged);
+    if checked.is_err() {
+        let _ = fs::remove_dir_all(&dir);
+    }
+    checked
+}
+
+fn check(staged: &Path) -> Result<BackupManifest, SealError> {
+    let mut zip = ZipArchive::new(File::open(staged)?).map_err(|_| SealError::NotABackup)?;
+    let mut text = String::new();
+    zip.by_name(MANIFEST_ENTRY)
+        .map_err(|_| SealError::NotABackup)?
+        .read_to_string(&mut text)?;
+    let manifest: BackupManifest =
+        serde_json::from_str(&text).map_err(|_| SealError::NotABackup)?;
+    if manifest.format != 1 || version(&manifest.version) > version(env!("CARGO_PKG_VERSION")) {
+        return Err(SealError::Newer);
+    }
+    zip.by_name(DATABASE_ENTRY)
+        .map_err(|_| SealError::NotABackup)?;
+    Ok(manifest)
+}
+
+/// The owner said yes: the staged backup replaces everything on the next
+/// start.
+pub fn confirm(paths: &Paths) -> io::Result<()> {
+    let dir = restore_dir(paths);
+    if !dir.join(STAGED).is_file() {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "no backup is ready to restore; open it again",
+        ));
+    }
+    fs::write(dir.join(READY), b"")
+}
+
+/// The owner changed their mind: the staged backup goes.
+pub fn cancel(paths: &Paths) {
+    let _ = fs::remove_dir_all(restore_dir(paths));
+}
+
+/// On start, before the database opens: swaps in a confirmed backup. The
+/// database and the crews' folders that were there move aside, to
+/// `<home>\before-restore\<time>` and `<workspaces_root>-before-restore-<time>`.
+/// Returns where the old data went, if a backup was applied.
+pub fn apply_pending(paths: &Paths, stamp: &str) -> io::Result<Option<PathBuf>> {
+    let dir = restore_dir(paths);
+    if !dir.join(READY).is_file() {
+        return Ok(None);
+    }
+    // Once only: a backup that cannot be applied is not tried forever.
+    fs::remove_file(dir.join(READY))?;
+    let unpacked = dir.join(UNPACKED);
+    let _ = fs::remove_dir_all(&unpacked);
+    unpack(&dir.join(STAGED), &unpacked)?;
+
+    let aside = paths.home.join("before-restore").join(stamp);
+    fs::create_dir_all(&aside)?;
+    let db = paths.db();
+    for suffix in ["", "-wal", "-shm"] {
+        let file = PathBuf::from(format!("{}{suffix}", db.display()));
+        if file.exists() {
+            let name = file.file_name().ok_or_else(|| other("no file name"))?;
+            fs::rename(&file, aside.join(name))?;
+        }
+    }
+    let root = &paths.workspaces_root;
+    if root.exists() {
+        let name = root.file_name().ok_or_else(|| other("no folder name"))?;
+        let moved =
+            root.with_file_name(format!("{}-before-restore-{stamp}", name.to_string_lossy()));
+        move_dir(root, &moved)?;
+        info!(to = %moved.display(), "the crews' folders were moved aside");
+    }
+    let workspaces = unpacked.join(WORKSPACES_ENTRY);
+    if workspaces.exists() {
+        move_dir(&workspaces, root)?;
+    } else {
+        fs::create_dir_all(root)?;
+    }
+    fs::rename(unpacked.join(DATABASE_ENTRY), &db)?;
+    if let Err(err) = fs::remove_dir_all(&dir) {
+        warn!("could not clean up after restoring: {err}");
+    }
+    Ok(Some(aside))
+}
+
+/// Every entry of the archive under `to`, refusing any that would land
+/// outside it.
+fn unpack(archive: &Path, to: &Path) -> io::Result<()> {
+    let mut zip = ZipArchive::new(File::open(archive)?).map_err(other)?;
+    for index in 0..zip.len() {
+        let mut entry = zip.by_index(index).map_err(other)?;
+        let Some(relative) = entry.enclosed_name() else {
+            return Err(other("the backup has a file outside its folders"));
+        };
+        let target = to.join(relative);
+        if entry.is_dir() {
+            fs::create_dir_all(&target)?;
+            continue;
+        }
+        if let Some(parent) = target.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        io::copy(&mut entry, &mut BufWriter::new(File::create(&target)?))?;
+    }
+    Ok(())
+}
+
+/// Renames, or copies and removes when the two are on different drives.
+fn move_dir(from: &Path, to: &Path) -> io::Result<()> {
+    if fs::rename(from, to).is_ok() {
+        return Ok(());
+    }
+    copy_dir(from, to)?;
+    fs::remove_dir_all(from)
+}
+
+fn copy_dir(from: &Path, to: &Path) -> io::Result<()> {
+    fs::create_dir_all(to)?;
+    for entry in fs::read_dir(from)? {
+        let entry = entry?;
+        let kind = entry.file_type()?;
+        let target = to.join(entry.file_name());
+        if kind.is_dir() {
+            copy_dir(&entry.path(), &target)?;
+        } else if kind.is_file() {
+            fs::copy(entry.path(), target)?;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn versions_compare_by_number() {
+        assert!(version("0.10.0") > version("0.9.1"));
+        assert!(version("1.0.0") > version("0.10.0"));
+        assert_eq!(version("0.10.0"), version("0.10.0"));
+    }
+}
diff --git a/crates/botloftd/src/main.rs b/crates/botloftd/src/main.rs
index 528c59e8..8cb49847 100644
--- a/crates/botloftd/src/main.rs
+++ b/crates/botloftd/src/main.rs
@@ -114,6 +114,14 @@ fn run(paths: Paths, config: Config, config_path: PathBuf, scheduled: bool) -> a
 
     let owner_token = secrets::load_or_create_owner_token(&paths.secrets())
         .context("cannot prepare the owner token")?;
+    // A backup the owner confirmed replaces the data before anything opens
+    // it (14.2); what was there goes aside.
+    let stamp = jiff::Zoned::now().strftime("%Y-%m-%d-%H%M%S").to_string();
+    match botloftd::backup::restore::apply_pending(&paths, &stamp) {
+        Ok(Some(aside)) => info!(aside = %aside.display(), "a backup was restored"),
+        Ok(None) => {}
+        Err(err) => error!("could not restore the backup, so nothing changed: {err}"),
+    }
     let store = Store::open(&paths.db()).context("cannot open the database")?;
     std::fs::create_dir_all(&paths.workspaces_root)
         .with_context(|| format!("cannot create {}", paths.workspaces_root.display()))?;
diff --git a/crates/botloftd/src/rpc/dispatch.rs b/crates/botloftd/src/rpc/dispatch.rs
index 1282f909..3706ac95 100644
--- a/crates/botloftd/src/rpc/dispatch.rs
+++ b/crates/botloftd/src/rpc/dispatch.rs
@@ -55,6 +55,9 @@ pub fn dispatch(daemon: &Daemon, name: &str, params: Option<Value>) -> Result<Va
         method::RULES_LIST => reply(rules::list(daemon, parse(params)?)),
         method::RULES_DELETE => reply(rules::delete(daemon, parse(params)?)),
         method::BACKUP_EXPORT => reply(backup::export(daemon, parse(params)?)),
+        method::BACKUP_STAGE => reply(backup::stage(daemon, parse(params)?)),
+        method::BACKUP_CONFIRM => reply(backup::confirm(daemon).map(|()| Value::Null)),
+        method::BACKUP_CANCEL => reply(backup::cancel(daemon).map(|()| Value::Null)),
         method::CREW_ACCESS_LIST => reply(crew_access::list(daemon, parse(params)?)),
         method::CREW_ACCESS_REVOKE => reply(crew_access::revoke(daemon, parse(params)?)),
         method::DESKTOP_GRANTS => reply(desktop::grants(daemon, parse(params)?)),
diff --git a/crates/botloftd/src/service/backup.rs b/crates/botloftd/src/service/backup.rs
index 2d64307f..f10371b4 100644
--- a/crates/botloftd/src/service/backup.rs
+++ b/crates/botloftd/src/service/backup.rs
@@ -1,10 +1,12 @@
 //! `backup.*` (spec 14.2).
 
-use botloft_core::protocol::{BackupExportParams, BackupExported};
+use botloft_core::protocol::{
+    BackupExportParams, BackupExported, BackupManifest, BackupStageParams,
+};
 use tracing::info;
 
 use super::{ApiError, ApiResult};
-use crate::backup::{export, seal::SealError};
+use crate::backup::{export, restore, seal::SealError};
 use crate::state::Daemon;
 
 /// A problem the owner can fix, with a `reason` the app words (spec 20.8).
@@ -28,3 +30,30 @@ pub fn export(daemon: &Daemon, params: BackupExportParams) -> ApiResult<BackupEx
     info!(bytes = exported.size, "backup exported");
     Ok(exported)
 }
+
+/// `backup.stage`: opens a backup the owner picked and keeps it ready.
+/// Nothing changes yet.
+pub fn stage(daemon: &Daemon, params: BackupStageParams) -> ApiResult<BackupManifest> {
+    let file = std::path::Path::new(params.path.trim());
+    if !file.is_file() {
+        return Err(ApiError::NotFound(format!(
+            "there is no file at {}",
+            params.path
+        )));
+    }
+    restore::stage(&daemon.paths, file, &params.passphrase).map_err(api)
+}
+
+/// `backup.confirm`: the staged backup replaces everything when Botloft
+/// starts again, which the app does next.
+pub fn confirm(daemon: &Daemon) -> ApiResult<()> {
+    restore::confirm(&daemon.paths).map_err(ApiError::Workspace)?;
+    info!("a backup will be restored on the next start");
+    Ok(())
+}
+
+/// `backup.cancel`: the staged backup goes.
+pub fn cancel(daemon: &Daemon) -> ApiResult<()> {
+    restore::cancel(&daemon.paths);
+    Ok(())
+}
diff --git a/crates/botloftd/tests/backup_restore.rs b/crates/botloftd/tests/backup_restore.rs
new file mode 100644
index 00000000..958f05c5
--- /dev/null
+++ b/crates/botloftd/tests/backup_restore.rs
@@ -0,0 +1,89 @@
+//! Importing a backup (spec 14.2): staged with the passphrase while Botloft
+//! runs, swapped in on the next start, with what was there moved aside.
+
+mod common;
+
+use std::fs;
+
+use botloft_store::Store;
+use botloftd::backup::restore;
+use botloftd::paths::Paths;
+use common::TestDaemon;
+use serde_json::json;
+
+#[tokio::test]
+async fn a_backup_from_one_computer_replaces_another_after_a_restart() {
+    // The computer the backup comes from.
+    let t = TestDaemon::start().await;
+    let mut app = t.session().await;
+    let crew = app
+        .call("crews.create", json!({ "name": "Ops" }))
+        .await
+        .expect("crew");
+    let bot = json!({ "crewId": crew["id"], "name": "Scout", "role": "Finds", "instructions": "" });
+    app.call("bots.create", bot).await.expect("bot");
+    let memory = t.paths.bot_workspace("ops", "scout").join("CLAUDE.md");
+    fs::write(&memory, "The client likes short reports.").expect("memory");
+    let exported = app
+        .call("backup.export", json!({ "passphrase": "correct horse" }))
+        .await
+        .expect("export");
+    let file = std::path::PathBuf::from(exported["path"].as_str().expect("path"));
+
+    // The other computer, with data of its own.
+    let other = tempfile::tempdir().expect("tempdir");
+    let paths = Paths::new(other.path().join("Data"), other.path().join("Bots"));
+    fs::create_dir_all(&paths.home).expect("home");
+    drop(Store::open(&paths.db()).expect("its own database"));
+    fs::create_dir_all(paths.workspaces_root.join("old")).expect("old crew");
+    fs::write(paths.workspaces_root.join("old").join("note.md"), "mine").expect("note");
+
+    assert!(restore::stage(&paths, &file, "wrong horse").is_err());
+    assert!(
+        !paths.home.join("restore").exists(),
+        "nothing kept from a failed try"
+    );
+    assert_eq!(
+        restore::apply_pending(&paths, "t1").expect("nothing to do"),
+        None,
+        "nothing staged"
+    );
+
+    let manifest = restore::stage(&paths, &file, "correct horse").expect("stage");
+    assert_eq!(manifest.crews[0].name, "Ops");
+    assert_eq!(manifest.crews[0].bots, ["Scout"]);
+    assert_eq!(
+        restore::apply_pending(&paths, "t2").expect("not confirmed"),
+        None,
+        "staged but not confirmed"
+    );
+    restore::confirm(&paths).expect("confirm");
+
+    let aside = restore::apply_pending(&paths, "t3")
+        .expect("apply")
+        .expect("applied");
+    assert!(
+        aside.join("botloft.db").is_file(),
+        "the old database is kept"
+    );
+    let moved = other.path().join("Bots-before-restore-t3");
+    assert_eq!(
+        fs::read_to_string(moved.join("old").join("note.md")).expect("old note"),
+        "mine",
+        "the old folders are kept"
+    );
+    let store = Store::open(&paths.db()).expect("restored database");
+    let crews = store.crews(true).expect("crews");
+    assert_eq!(crews.len(), 1);
+    assert_eq!(crews[0].name, "Ops");
+    assert_eq!(
+        fs::read_to_string(paths.bot_workspace("ops", "scout").join("CLAUDE.md")).expect("memory"),
+        "The client likes short reports."
+    );
+    assert!(!paths.home.join("restore").exists());
+    assert_eq!(
+        restore::apply_pending(&paths, "t4").expect("once"),
+        None,
+        "applied once"
+    );
+}
diff --git a/docs/spec.md b/docs/spec.md
index cfe3ec76..fb77efd4 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -817,7 +817,10 @@ Formatar o computador ou perder a pasta do Botloft não pode levar as equipes ju
 - **O que fica:** o que o Botloft escreve de novo a cada início (`.botloft\` e `.claude\settings.json` de cada bot, 7.5); os segredos, os logs e os perfis dos navegadores dos bots, que estão na pasta de dados e não em `workspaces_root`; e as pastas de trabalho que o dono escolheu fora do Botloft (5), que são dele. O manifesto lista essas pastas, para a importação avisar. O login do Claude também é de cada computador e se faz de novo.
 - **Lacre:** o arquivo começa com `BOTLOFTBAK`, um byte de versão (1), o sal do Argon2id (16 bytes), os custos (64 MiB, 3 passadas, 1 faixa, em `u32` little-endian) e o nonce (19 bytes). Depois vem o zip, em blocos de 64 KiB cifrados com XChaCha20-Poly1305 na construção STREAM (contador big-endian de 32 bits e marca do último bloco), com a chave de 32 bytes que o Argon2id tira da senha. Senha errada, arquivo cortado ou blocos trocados não abrem, e nada de um bloco que não abre é escrito. A senha tem ao menos 8 caracteres e nunca é guardada nem vai para o log: quem a perde perde a cópia.
 - **Exportar:** `backup.export {passphrase}` fecha a cópia em `<home>\exports\botloft-AAAA-MM-DD-HHMM.botloft` (só a mais nova fica ali) e devolve `{path, size, manifest}`. O app então oferece "Salvar como…" (`save_file_as`, 15.2) para o dono guardar onde quiser. Os erros que o dono resolve vêm com `reason` (20.8): `short_passphrase`, `wrong_passphrase`, `not_a_backup` e `newer_backup`.
-- **Importar** e a tela no app vêm nas próximas partes.
+- **Importar:** em duas etapas, para nada mudar com o Botloft rodando. `backup.stage {path, passphrase}` abre o arquivo com a senha em `<home>\restore\staged.zip`, confere o manifesto (formato 1, de um Botloft que não é mais novo) e o banco, e devolve o manifesto para o app mostrar o que vem. Senha errada ou arquivo que não é cópia não deixam nada. `backup.cancel` desiste. `backup.confirm` marca a cópia para o próximo início, e o app reinicia o Botloft (`restartDaemon`).
+- **Troca no início:** antes de abrir o banco, o daemon vê a marca e a apaga, para não tentar de novo uma cópia que falhou. Depois desempacota tudo em `<home>\restore\unpacked`, recusando arquivo que cairia fora dela. Só então move o banco atual (`botloft.db`, `-wal`, `-shm`) para `<home>\before-restore\<data>` e a pasta `workspaces_root` inteira para `<workspaces_root>-before-restore-<data>`, ao lado dela. Por fim põe os do backup no lugar; entre discos diferentes, copia e apaga. Nada é apagado: o dono volta atrás pondo as pastas de volta. Se algo falha, o log diz, e o Botloft abre com o que houver.
+- **Depois:** as migrações levam o banco à versão atual, como em toda abertura. Os bots começam conversa nova no Claude Code, com a memória e o histórico do chat de volta. Pastas de trabalho escolhidas que não existem no computador novo são criadas vazias, e o dono põe os arquivos de volta. Permissões de desktop apontam para caminhos de programas que podem não existir lá: o bot pede de novo.
+- A tela no app vem na próxima parte.
 
 ## 15. App desktop
 

From f1c4e45bfb8564e98400aafd5b9f3082ff452c95 Mon Sep 17 00:00:00 2001
From: Phelipe Lorran <112786693+httpsphl@users.noreply.github.com>
Date: Mon, 5 Oct 2026 14:54:33 -0300
Subject: [PATCH 2/2] feat(app): Backup in Settings, to save a copy and restore
 one

Save a copy: the passphrase twice, then the system's Save dialog for the
file the daemon sealed. Restore a copy: the system's Open dialog for a
.botloft file, its passphrase, what the copy holds (crews, bots, the
work folders that are not in it) and Restore and restart. Errors are
worded from the daemon's reasons. The host gains pickFile. Spec 14.2.
---
 app/src/features/account/BackupRestore.tsx  | 142 ++++++++++++++++++++
 app/src/features/account/BackupSettings.tsx | 111 +++++++++++++++
 app/src/features/account/SettingsDialog.tsx |  10 +-
 app/src/features/account/backup.test.tsx    |  65 +++++++++
 app/src/i18n/en/account.ts                  |  42 ++++++
 app/src/i18n/es/account.ts                  |  42 ++++++
 app/src/i18n/pt-BR/account.ts               |  42 ++++++
 app/src/lib/fakeHost.ts                     |   8 ++
 app/src/lib/host.ts                         |   5 +
 app/src/lib/tauriHost.ts                    |   9 ++
 docs/spec.md                                |   2 +-
 11 files changed, 474 insertions(+), 4 deletions(-)
 create mode 100644 app/src/features/account/BackupRestore.tsx
 create mode 100644 app/src/features/account/BackupSettings.tsx
 create mode 100644 app/src/features/account/backup.test.tsx

diff --git a/app/src/features/account/BackupRestore.tsx b/app/src/features/account/BackupRestore.tsx
new file mode 100644
index 00000000..cb608cb3
--- /dev/null
+++ b/app/src/features/account/BackupRestore.tsx
@@ -0,0 +1,142 @@
+// Restoring a copy (spec 14.2): the owner picks the file and types its
+// passphrase; the daemon opens it and says what it holds; only after the
+// owner confirms does Botloft restart and swap it in.
+
+import { FolderOpen, RotateCcw } from "lucide-react";
+import { useState } from "react";
+import { useT } from "../../i18n";
+import { when } from "../../lib/format";
+import type { BackupManifest } from "../../lib/protocol.gen";
+import { useApi, useHost } from "../../store/context";
+import { Button } from "../../ui/Button";
+import { Callout } from "../../ui/Callout";
+import { TextField } from "../../ui/Field";
+import { backupError } from "./BackupSettings";
+
+export function BackupRestore() {
+  const b = useT().account.backup;
+  const api = useApi();
+  const host = useHost();
+  const [file, setFile] = useState<string | null>(null);
+  const [passphrase, setPassphrase] = useState("");
+  const [manifest, setManifest] = useState<BackupManifest | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [failed, setFailed] = useState<{ title: string; text: string } | null>(null);
+
+  const pick = async () => {
+    const picked = await host.pickFile(b.pickTitle, b.kind, ["botloft"]);
+    if (picked) {
+      setFile(picked);
+      setManifest(null);
+      setFailed(null);
+    }
+  };
+
+  const open = async () => {
+    if (!file) {
+      return;
+    }
+    setBusy(true);
+    setFailed(null);
+    try {
+      setManifest(await api.call("backup.stage", { path: file, passphrase }));
+    } catch (failure) {
+      setFailed({ title: b.openFailed, text: backupError(failure, b.reasons) });
+    }
+    setBusy(false);
+  };
+
+  const restore = async () => {
+    setBusy(true);
+    setFailed(null);
+    try {
+      await api.call("backup.confirm");
+      await host.restartDaemon();
+    } catch (failure) {
+      setFailed({ title: b.restoreFailed, text: backupError(failure, b.reasons) });
+      setBusy(false);
+    }
+  };
+
+  const cancel = async () => {
+    await api.call("backup.cancel").catch(() => null);
+    setManifest(null);
+    setFile(null);
+    setPassphrase("");
+  };
+
+  const folders = (manifest?.crews ?? []).flatMap((crew) =>
+    crew.workFolder ? [crew.workFolder] : [],
+  );
+
+  return (
+    <div className="flex flex-col gap-3">
+      {!manifest && (
+        <>
+          <div className="flex items-center gap-3">
+            <Button icon={FolderOpen} onClick={pick} disabled={busy}>
+              {b.pick}
+            </Button>
+            {file && (
+              <span className="min-w-0 truncate font-mono text-muted text-xs" title={file}>
+                {file}
+              </span>
+            )}
+          </div>
+          {file && (
+            <div className="flex items-end gap-3">
+              <div className="min-w-0 flex-1">
+                <TextField
+                  type="password"
+                  autoComplete="current-password"
+                  label={b.copyPassphrase}
+                  value={passphrase}
+                  onChange={(event) => setPassphrase(event.target.value)}
+                />
+              </div>
+              <Button disabled={busy || passphrase.length === 0} onClick={open}>
+                {busy ? b.opening : b.open}
+              </Button>
+            </div>
+          )}
+        </>
+      )}
+      {manifest && (
+        <div className="flex flex-col gap-2 rounded-lg border border-line bg-sunken px-3 py-2.5 text-sm">
+          <p className="font-medium">{b.from(when(manifest.createdAt))}</p>
+          <ul className="flex flex-col gap-0.5 text-ink-soft">
+            {manifest.crews.map((crew) => (
+              <li key={crew.name}>{b.crew(crew.name, crew.bots.length)}</li>
+            ))}
+          </ul>
+          {folders.length > 0 && (
+            <div className="text-muted text-xs">
+              <p>{b.workFolders}</p>
+              <ul className="mt-1 font-mono" data-selectable>
+                {folders.map((folder) => (
+                  <li key={folder} className="break-all">
+                    {folder}
+                  </li>
+                ))}
+              </ul>
+            </div>
+          )}
+          <p className="text-warn text-xs">{b.replaces}</p>
+          <div className="mt-1 flex flex-wrap gap-2">
+            <Button variant="danger" icon={RotateCcw} disabled={busy} onClick={restore}>
+              {busy ? b.restoring : b.restore}
+            </Button>
+            <Button variant="ghost" disabled={busy} onClick={cancel}>
+              {b.cancel}
+            </Button>
+          </div>
+        </div>
+      )}
+      {failed && (
+        <Callout tone="danger" title={failed.title}>
+          {failed.text}
+        </Callout>
+      )}
+    </div>
+  );
+}
diff --git a/app/src/features/account/BackupSettings.tsx b/app/src/features/account/BackupSettings.tsx
new file mode 100644
index 00000000..0f016c17
--- /dev/null
+++ b/app/src/features/account/BackupSettings.tsx
@@ -0,0 +1,111 @@
+// Settings, "Backup" (spec 14.2): save everything to one file locked with
+// a passphrase, and restore such a file. The daemon makes the copy; the
+// owner picks where it goes with the system's Save dialog.
+
+import { Download } from "lucide-react";
+import { useState } from "react";
+import { useT } from "../../i18n";
+import { errorText } from "../../lib/api";
+import { fileSize } from "../../lib/format";
+import { RpcError } from "../../lib/rpc";
+import { useApi, useHost } from "../../store/context";
+import { Button } from "../../ui/Button";
+import { Callout } from "../../ui/Callout";
+import { TextField } from "../../ui/Field";
+import { BackupRestore } from "./BackupRestore";
+import { Section } from "./settingsParts";
+
+/** A failure as the owner reads it: the daemon's reason, worded, or the error. */
+export function backupError(failure: unknown, reasons: Record<string, string>): string {
+  const reason = failure instanceof RpcError ? failure.reason : undefined;
+  return (reason && reasons[reason]) || errorText(failure);
+}
+
+type Outcome = { saved: string } | { notSaved: true } | { failed: string } | null;
+
+export function BackupSettings() {
+  const b = useT().account.backup;
+  return (
+    <>
+      <Section title={b.exportTitle}>
+        <p className="text-ink-soft text-sm leading-relaxed">{b.exportIntro}</p>
+        <ExportCopy />
+      </Section>
+      <Section title={b.importTitle}>
+        <p className="text-ink-soft text-sm leading-relaxed">{b.importIntro}</p>
+        <BackupRestore />
+      </Section>
+    </>
+  );
+}
+
+function ExportCopy() {
+  const b = useT().account.backup;
+  const api = useApi();
+  const host = useHost();
+  const [passphrase, setPassphrase] = useState("");
+  const [repeat, setRepeat] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [outcome, setOutcome] = useState<Outcome>(null);
+  const mismatch = repeat.length > 0 && repeat !== passphrase;
+  const ready = [...passphrase].length >= 8 && repeat === passphrase;
+
+  const save = async () => {
+    setBusy(true);
+    setOutcome(null);
+    try {
+      const exported = await api.call("backup.export", { passphrase });
+      const kept = await host.saveFileAs(exported.path);
+      setOutcome(kept ? { saved: fileSize(exported.size) } : { notSaved: true });
+      if (kept) {
+        setPassphrase("");
+        setRepeat("");
+      }
+    } catch (failure) {
+      setOutcome({ failed: backupError(failure, b.reasons) });
+    }
+    setBusy(false);
+  };
+
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="grid grid-cols-2 gap-3">
+        <TextField
+          type="password"
+          autoComplete="new-password"
+          label={b.passphrase}
+          value={passphrase}
+          onChange={(event) => setPassphrase(event.target.value)}
+        />
+        <TextField
+          type="password"
+          autoComplete="new-password"
+          label={b.repeat}
+          value={repeat}
+          onChange={(event) => setRepeat(event.target.value)}
+        />
+      </div>
+      <p className={`text-xs ${mismatch ? "text-danger" : "text-muted"}`}>
+        {mismatch ? b.mismatch : b.passphraseHint}
+      </p>
+      <Button icon={Download} className="self-start" disabled={!ready || busy} onClick={save}>
+        {busy ? b.exporting : b.export}
+      </Button>
+      {outcome && "saved" in outcome && (
+        <p role="status" className="text-ok text-sm">
+          {b.saved(outcome.saved)}
+        </p>
+      )}
+      {outcome && "notSaved" in outcome && (
+        <p role="status" className="text-muted text-sm">
+          {b.notSaved}
+        </p>
+      )}
+      {outcome && "failed" in outcome && (
+        <Callout tone="danger" title={b.exportFailed}>
+          {outcome.failed}
+        </Callout>
+      )}
+    </div>
+  );
+}
diff --git a/app/src/features/account/SettingsDialog.tsx b/app/src/features/account/SettingsDialog.tsx
index c5128067..a0d65c2c 100644
--- a/app/src/features/account/SettingsDialog.tsx
+++ b/app/src/features/account/SettingsDialog.tsx
@@ -1,11 +1,12 @@
 // Settings (spec 15.1), in parts listed on the left: general (what
 // Botloft does in the background, the language), the chat, notifications,
-// the look, what was archived, and the versions for when something needs
-// reporting.
+// the look, what was archived, backups, and the versions for when
+// something needs reporting.
 
 import {
   Archive,
   Bell,
+  DatabaseBackup,
   Info,
   type LucideIcon,
   MessageSquare,
@@ -19,10 +20,11 @@ import { AboutSettings } from "./AboutSettings";
 import { AlertsSettings } from "./AlertsSettings";
 import { AppearanceSettings } from "./AppearanceSettings";
 import { ArchivedSettings } from "./ArchivedSettings";
+import { BackupSettings } from "./BackupSettings";
 import { ChatSettings } from "./ChatSettings";
 import { GeneralSettings } from "./GeneralSettings";
 
-type Page = "general" | "chat" | "alerts" | "appearance" | "archived" | "about";
+type Page = "general" | "chat" | "alerts" | "appearance" | "archived" | "backup" | "about";
 
 const PAGES: { id: Page; icon: LucideIcon }[] = [
   { id: "general", icon: SlidersHorizontal },
@@ -30,6 +32,7 @@ const PAGES: { id: Page; icon: LucideIcon }[] = [
   { id: "alerts", icon: Bell },
   { id: "appearance", icon: Palette },
   { id: "archived", icon: Archive },
+  { id: "backup", icon: DatabaseBackup },
   { id: "about", icon: Info },
 ];
 
@@ -79,6 +82,7 @@ export function SettingsDialog({ onClose }: { onClose(): void }) {
           {page === "alerts" && <AlertsSettings />}
           {page === "appearance" && <AppearanceSettings />}
           {page === "archived" && <ArchivedSettings />}
+          {page === "backup" && <BackupSettings />}
           {page === "about" && <AboutSettings />}
         </div>
       </div>
diff --git a/app/src/features/account/backup.test.tsx b/app/src/features/account/backup.test.tsx
new file mode 100644
index 00000000..b833311f
--- /dev/null
+++ b/app/src/features/account/backup.test.tsx
@@ -0,0 +1,65 @@
+import { cleanup, fireEvent, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+import { FakeBotloft } from "../../lib/fake";
+import { FAKE_PASSPHRASE } from "../../lib/fakeBackup";
+import { FakeHost } from "../../lib/fakeHost";
+import { crewOpened, renderApp } from "../../test/app";
+
+afterEach(cleanup);
+
+async function openBackup() {
+  const fake = new FakeBotloft();
+  const ops = fake.addCrew("Ops");
+  fake.addBot(ops.id, "Scout");
+  fake.addBot(ops.id, "Writer");
+  const host = new FakeHost();
+  renderApp(fake, host);
+  await crewOpened("Ops");
+  fireEvent.click(await screen.findByRole("button", { name: /Ana Lima/ }));
+  fireEvent.click(screen.getByRole("menuitem", { name: "Settings" }));
+  const dialog = screen.getByRole("dialog", { name: "Settings" });
+  fireEvent.click(within(dialog).getByRole("tab", { name: "Backup" }));
+  return { fake, host, dialog };
+}
+
+const type = (field: HTMLElement, value: string) => fireEvent.change(field, { target: { value } });
+
+describe("backup", () => {
+  test("a copy is saved where the owner picks, once both passphrases match", async () => {
+    const { fake, host, dialog } = await openBackup();
+    const save = within(dialog).getByRole("button", { name: "Save a copy…" });
+    expect(save).toHaveProperty("disabled", true);
+    type(within(dialog).getByLabelText("Passphrase"), "correct horse");
+    type(within(dialog).getByLabelText("Passphrase again"), "correct hors");
+    expect(within(dialog).getByText("The two passphrases are not the same.")).toBeDefined();
+    expect(save).toHaveProperty("disabled", true);
+    type(within(dialog).getByLabelText("Passphrase again"), "correct horse");
+    host.saveChosen = true;
+    fireEvent.click(save);
+    expect(await within(dialog).findByText(/^Copy saved \(/)).toBeDefined();
+    expect(host.savedFiles[0]).toMatch(/\.botloft$/);
+    const call = fake.calls.find((each) => each.method === "backup.export");
+    expect(call?.params).toEqual({ passphrase: "correct horse" });
+  });
+
+  test("a copy opens with its passphrase, shows what it holds and restores on restart", async () => {
+    const { fake, host, dialog } = await openBackup();
+    host.nextFile = "D:\\Copies\\botloft-2026-10-05-1430.botloft";
+    fireEvent.click(within(dialog).getByRole("button", { name: "Choose a copy…" }));
+    const field = await within(dialog).findByLabelText("The copy's passphrase");
+    expect(host.fileFilters[0]).toEqual(["botloft"]);
+
+    type(field, "wrong horse");
+    fireEvent.click(within(dialog).getByRole("button", { name: "Open" }));
+    expect(
+      await within(dialog).findByText("The passphrase is wrong, or the file is damaged."),
+    ).toBeDefined();
+
+    type(field, FAKE_PASSPHRASE);
+    fireEvent.click(within(dialog).getByRole("button", { name: "Open" }));
+    expect(await within(dialog).findByText("Ops: 2 bots")).toBeDefined();
+    fireEvent.click(within(dialog).getByRole("button", { name: "Restore and restart" }));
+    await waitFor(() => expect(host.installs).toContain("restart"));
+    expect(fake.calls.some((each) => each.method === "backup.confirm")).toBe(true);
+  });
+});
diff --git a/app/src/i18n/en/account.ts b/app/src/i18n/en/account.ts
index 2f9ab6a9..696726c9 100644
--- a/app/src/i18n/en/account.ts
+++ b/app/src/i18n/en/account.ts
@@ -54,6 +54,47 @@ export const account = {
         "Each bot's share of your weekly plan shows up once the plan has gone up a few points while the bots work. Until then, the tokens.",
     },
   },
+  backup: {
+    exportTitle: "Save a copy",
+    exportIntro:
+      "Keeps your crews, bots, chats and each bot's memory in one file locked with a passphrase, to bring back after a new install or on another computer. Work folders you chose outside Botloft are not in it.",
+    passphrase: "Passphrase",
+    passphraseHint:
+      "At least 8 characters. Without it the copy cannot be opened, and Botloft does not keep it anywhere.",
+    repeat: "Passphrase again",
+    mismatch: "The two passphrases are not the same.",
+    export: "Save a copy…",
+    exporting: "Making the copy…",
+    saved: (size: string) => `Copy saved (${size}).`,
+    notSaved: "The copy was not saved.",
+    exportFailed: "Could not make the copy",
+    importTitle: "Restore a copy",
+    importIntro:
+      "Replaces everything in this Botloft with a copy. What is here now goes to a folder aside: nothing is deleted.",
+    pick: "Choose a copy…",
+    pickTitle: "Choose a Botloft copy",
+    kind: "Botloft copy",
+    copyPassphrase: "The copy's passphrase",
+    open: "Open",
+    opening: "Opening…",
+    from: (when: string) => `Copy from ${when}`,
+    crew: (name: string, bots: number) =>
+      `${name}: ${bots === 0 ? "no bots" : bots === 1 ? "1 bot" : `${bots} bots`}`,
+    workFolders:
+      "These work folders are not in the copy. Put their files back yourself if this is another computer:",
+    replaces: "Everything in this Botloft is replaced. Botloft restarts to do it.",
+    restore: "Restore and restart",
+    restoring: "Restarting…",
+    cancel: "Cancel",
+    openFailed: "Could not open the copy",
+    restoreFailed: "Could not restore the copy",
+    reasons: {
+      short_passphrase: "The passphrase needs at least 8 characters.",
+      wrong_passphrase: "The passphrase is wrong, or the file is damaged.",
+      not_a_backup: "This file is not a Botloft copy.",
+      newer_backup: "This copy is from a newer Botloft. Update Botloft first.",
+    } as Record<string, string>,
+  },
   settings: {
     title: "Settings",
     background: "In the background",
@@ -131,6 +172,7 @@ export const account = {
     deleteArchived: "Delete",
     deleteArchivedOne: (name: string) => `Delete ${name}`,
     about: "About",
+    backup: "Backup",
     claudeCode: (version: string) => `Claude Code ${version}`,
     botloft: (version: string) => `Botloft ${version}`,
     checkUpdates: "Check for updates",
diff --git a/app/src/i18n/es/account.ts b/app/src/i18n/es/account.ts
index 0f33bafc..fc297414 100644
--- a/app/src/i18n/es/account.ts
+++ b/app/src/i18n/es/account.ts
@@ -54,6 +54,47 @@ export const account: Messages["account"] = {
         "La parte de cada bot en tu plan semanal aparece cuando el plan haya subido unos puntos con los bots trabajando. Hasta entonces, los tokens.",
     },
   },
+  backup: {
+    exportTitle: "Guardar una copia",
+    exportIntro:
+      "Guarda tus equipos, bots, conversaciones y la memoria de cada bot en un archivo cerrado con una contraseña, para recuperarlo tras reinstalar o en otra computadora. Las carpetas de trabajo que elegiste fuera de Botloft no entran.",
+    passphrase: "Contraseña",
+    passphraseHint:
+      "Al menos 8 caracteres. Sin ella la copia no se abre, y Botloft no la guarda en ningún lado.",
+    repeat: "Contraseña otra vez",
+    mismatch: "Las dos contraseñas no son iguales.",
+    export: "Guardar una copia…",
+    exporting: "Haciendo la copia…",
+    saved: (size) => `Copia guardada (${size}).`,
+    notSaved: "La copia no se guardó.",
+    exportFailed: "No se pudo hacer la copia",
+    importTitle: "Restaurar una copia",
+    importIntro:
+      "Cambia todo lo que hay en este Botloft por una copia. Lo que hay ahora va a una carpeta aparte: nada se borra.",
+    pick: "Elegir una copia…",
+    pickTitle: "Elige una copia de Botloft",
+    kind: "Copia de Botloft",
+    copyPassphrase: "Contraseña de la copia",
+    open: "Abrir",
+    opening: "Abriendo…",
+    from: (when) => `Copia del ${when}`,
+    crew: (name, bots) =>
+      `${name}: ${bots === 0 ? "ningún bot" : bots === 1 ? "1 bot" : `${bots} bots`}`,
+    workFolders:
+      "Estas carpetas de trabajo no están en la copia. Si es otra computadora, vuelve a poner sus archivos:",
+    replaces: "Se cambia todo en este Botloft. Botloft se reinicia para hacerlo.",
+    restore: "Restaurar y reiniciar",
+    restoring: "Reiniciando…",
+    cancel: "Cancelar",
+    openFailed: "No se pudo abrir la copia",
+    restoreFailed: "No se pudo restaurar la copia",
+    reasons: {
+      short_passphrase: "La contraseña necesita al menos 8 caracteres.",
+      wrong_passphrase: "La contraseña es incorrecta, o el archivo está dañado.",
+      not_a_backup: "Este archivo no es una copia de Botloft.",
+      newer_backup: "Esta copia es de un Botloft más nuevo. Actualiza Botloft antes.",
+    } as Record<string, string>,
+  },
   settings: {
     title: "Configuración",
     background: "En segundo plano",
@@ -130,6 +171,7 @@ export const account: Messages["account"] = {
     deleteArchived: "Eliminar",
     deleteArchivedOne: (name: string) => `Eliminar ${name}`,
     about: "Acerca de",
+    backup: "Copia de seguridad",
     claudeCode: (version: string) => `Claude Code ${version}`,
     botloft: (version: string) => `Botloft ${version}`,
     checkUpdates: "Buscar actualizaciones",
diff --git a/app/src/i18n/pt-BR/account.ts b/app/src/i18n/pt-BR/account.ts
index 0740017b..d97a856b 100644
--- a/app/src/i18n/pt-BR/account.ts
+++ b/app/src/i18n/pt-BR/account.ts
@@ -54,6 +54,47 @@ export const account: Messages["account"] = {
         "A parte de cada bot no seu plano semanal aparece depois que o plano subir alguns pontos com os bots trabalhando. Até lá, os tokens.",
     },
   },
+  backup: {
+    exportTitle: "Salvar uma cópia",
+    exportIntro:
+      "Guarda suas equipes, bots, conversas e a memória de cada bot num arquivo trancado com uma senha, para trazer de volta depois de reinstalar ou em outro computador. Pastas de trabalho que você escolheu fora do Botloft não entram.",
+    passphrase: "Senha",
+    passphraseHint:
+      "Ao menos 8 caracteres. Sem ela a cópia não abre, e o Botloft não a guarda em lugar nenhum.",
+    repeat: "Senha de novo",
+    mismatch: "As duas senhas não são iguais.",
+    export: "Salvar uma cópia…",
+    exporting: "Fazendo a cópia…",
+    saved: (size) => `Cópia salva (${size}).`,
+    notSaved: "A cópia não foi salva.",
+    exportFailed: "Não foi possível fazer a cópia",
+    importTitle: "Restaurar uma cópia",
+    importIntro:
+      "Troca tudo o que está neste Botloft por uma cópia. O que existe agora vai para uma pasta à parte: nada é apagado.",
+    pick: "Escolher uma cópia…",
+    pickTitle: "Escolha uma cópia do Botloft",
+    kind: "Cópia do Botloft",
+    copyPassphrase: "Senha da cópia",
+    open: "Abrir",
+    opening: "Abrindo…",
+    from: (when) => `Cópia de ${when}`,
+    crew: (name, bots) =>
+      `${name}: ${bots === 0 ? "nenhum bot" : bots === 1 ? "1 bot" : `${bots} bots`}`,
+    workFolders:
+      "Estas pastas de trabalho não estão na cópia. Se este é outro computador, ponha os arquivos delas de volta:",
+    replaces: "Tudo neste Botloft é trocado. O Botloft reinicia para isso.",
+    restore: "Restaurar e reiniciar",
+    restoring: "Reiniciando…",
+    cancel: "Cancelar",
+    openFailed: "Não foi possível abrir a cópia",
+    restoreFailed: "Não foi possível restaurar a cópia",
+    reasons: {
+      short_passphrase: "A senha precisa de ao menos 8 caracteres.",
+      wrong_passphrase: "A senha está errada, ou o arquivo está danificado.",
+      not_a_backup: "Este arquivo não é uma cópia do Botloft.",
+      newer_backup: "Esta cópia é de um Botloft mais novo. Atualize o Botloft antes.",
+    } as Record<string, string>,
+  },
   settings: {
     title: "Configurações",
     background: "Em segundo plano",
@@ -130,6 +171,7 @@ export const account: Messages["account"] = {
     deleteArchived: "Excluir",
     deleteArchivedOne: (name: string) => `Excluir ${name}`,
     about: "Sobre",
+    backup: "Cópia de segurança",
     claudeCode: (version: string) => `Claude Code ${version}`,
     botloft: (version: string) => `Botloft ${version}`,
     checkUpdates: "Procurar atualizações",
diff --git a/app/src/lib/fakeHost.ts b/app/src/lib/fakeHost.ts
index 70dc0ab5..d8dbe3a6 100644
--- a/app/src/lib/fakeHost.ts
+++ b/app/src/lib/fakeHost.ts
@@ -33,6 +33,9 @@ export class FakeHost implements Host {
   nextFolder: string | null = null;
   /** Where each folder picker started. */
   readonly pickerStarts: (string | null)[] = [];
+  /** What `pickFile` gives next; `null`, the owner cancels. */
+  nextFile: string | null = null;
+  readonly fileFilters: string[][] = [];
   readonly installs: ("install" | "restart")[] = [];
   /** How many times the app stopped the daemon. */
   stops = 0;
@@ -182,6 +185,11 @@ export class FakeHost implements Host {
     return Promise.resolve(this.nextFolder);
   }
 
+  pickFile(_title: string, _kind: string, extensions: string[]): Promise<string | null> {
+    this.fileFilters.push(extensions);
+    return Promise.resolve(this.nextFile);
+  }
+
   openUrl(url: string): Promise<void> {
     this.opened.push(url);
     return Promise.resolve();
diff --git a/app/src/lib/host.ts b/app/src/lib/host.ts
index ec0c6e41..1e4f6458 100644
--- a/app/src/lib/host.ts
+++ b/app/src/lib/host.ts
@@ -129,6 +129,11 @@ export interface Host {
    * `start` if given. Resolves null if they cancel.
    */
   pickFolder(title: string, start?: string): Promise<string | null>;
+  /**
+   * Asks the owner for one file with the system's Open dialog, showing
+   * files with `extensions` under `kind`. Resolves null if they cancel.
+   */
+  pickFile(title: string, kind: string, extensions: string[]): Promise<string | null>;
   /** Opens an http(s) link in the default browser. */
   openUrl(url: string): Promise<void>;
   window: AppWindow;
diff --git a/app/src/lib/tauriHost.ts b/app/src/lib/tauriHost.ts
index 1149ac44..eea960d7 100644
--- a/app/src/lib/tauriHost.ts
+++ b/app/src/lib/tauriHost.ts
@@ -142,6 +142,15 @@ export function tauriHost(): Host {
       });
       return typeof picked === "string" ? picked : null;
     },
+    pickFile: async (title, kind, extensions) => {
+      const picked = await open({
+        directory: false,
+        multiple: false,
+        title,
+        filters: [{ name: kind, extensions }],
+      });
+      return typeof picked === "string" ? picked : null;
+    },
     openUrl: (url) => invoke<void>("open_url", { url }),
     window: {
       minimize: () => window.minimize(),
diff --git a/docs/spec.md b/docs/spec.md
index fb77efd4..0f947566 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -820,7 +820,7 @@ Formatar o computador ou perder a pasta do Botloft não pode levar as equipes ju
 - **Importar:** em duas etapas, para nada mudar com o Botloft rodando. `backup.stage {path, passphrase}` abre o arquivo com a senha em `<home>\restore\staged.zip`, confere o manifesto (formato 1, de um Botloft que não é mais novo) e o banco, e devolve o manifesto para o app mostrar o que vem. Senha errada ou arquivo que não é cópia não deixam nada. `backup.cancel` desiste. `backup.confirm` marca a cópia para o próximo início, e o app reinicia o Botloft (`restartDaemon`).
 - **Troca no início:** antes de abrir o banco, o daemon vê a marca e a apaga, para não tentar de novo uma cópia que falhou. Depois desempacota tudo em `<home>\restore\unpacked`, recusando arquivo que cairia fora dela. Só então move o banco atual (`botloft.db`, `-wal`, `-shm`) para `<home>\before-restore\<data>` e a pasta `workspaces_root` inteira para `<workspaces_root>-before-restore-<data>`, ao lado dela. Por fim põe os do backup no lugar; entre discos diferentes, copia e apaga. Nada é apagado: o dono volta atrás pondo as pastas de volta. Se algo falha, o log diz, e o Botloft abre com o que houver.
 - **Depois:** as migrações levam o banco à versão atual, como em toda abertura. Os bots começam conversa nova no Claude Code, com a memória e o histórico do chat de volta. Pastas de trabalho escolhidas que não existem no computador novo são criadas vazias, e o dono põe os arquivos de volta. Permissões de desktop apontam para caminhos de programas que podem não existir lá: o bot pede de novo.
-- A tela no app vem na próxima parte.
+- **No app:** Configurações, "Cópia de segurança". "Salvar uma cópia": a senha duas vezes (o botão só acende com as duas iguais e 8 caracteres ou mais), `backup.export`, e o "Salvar como…" do sistema; "Cópia salva (1,2 MB)" ou "A cópia não foi salva". "Restaurar uma cópia": "Escolher uma cópia…" abre o seletor de arquivos do sistema só com `.botloft` (`pickFile` do host), pede a "Senha da cópia" e chama `backup.stage`. Mostra de quando é a cópia, cada equipe com quantos bots, as pastas de trabalho que não vêm nela e o aviso de que tudo é trocado, com "Restaurar e reiniciar" (`backup.confirm`, depois `restartDaemon`) e "Cancelar" (`backup.cancel`). Os erros com `reason` saem em palavras do dono.
 
 ## 15. App desktop