cortico-world-archivist 0.3.3 → 0.3.4

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.3.4 — 2026-11-15
+
+修两个会真出事的问题，其中一个来自市场维护者 Pal AI Lab 的反馈。
+
+**备份不再把自己打进去（市场反馈）**
+
+- 存放位置默认改到**部署目录**下的 `archivist/`，不再放在 `data/archivist`。`data/` 会被「扩展数据」整目录扫描，放在里面等于每份新备份都把之前的 zip 一起打包——zip 本身已经压过，再压一次几乎不变小，单份体积就逐次接近翻倍，最后吃掉整个磁盘或让 `Compress-Archive` 失败。
+- 就算用户自己把存放位置指回 `data/` 里，也不会再自我打包：判定按**绝对路径**做，存放位置和它下面的 `before-restore-*` 一律跳过，也不再进恢复前快照、不被恢复覆盖。
+- 老部署的兼容：如果 `<data>/archivist` 里已经有旧包，继续用老位置。突然换地方会让「保留份数」的轮转在新目录里从零开始，旧包再也清不掉。
+
+**恢复：说清范围，且真的能回滚（市场反馈）**
+
+- 面板与 README 明写恢复的覆盖面：**所有扩展的数据**、**所有 World 的配置**（`config.json` 里每一个 Worlds 段，不只是本扩展）、**全部密钥**（`.env` 与 `providers/` 下所有渠道）。之前只写了「恢复会覆盖现在的数据」，太含糊。
+- **修掉一个回滚缺口**：`before-restore-<时间>/` 原先只快照 `data/` 的顶层文件，但恢复时 `data/` 的子目录是整个覆盖的。也就是说 `data/stroll`、`data/terrarium`、`data/parlor-history` 这些目录被覆盖后**没有副本**。现在子目录、`providers/`、额外路径都进快照。
+- 额外路径恢复回**原位**：备份时在包里记一张 `extra-map.json`（包内名字 → 原始绝对路径），恢复照它放回。之前只知道 basename，所有额外路径都会被倒在部署目录下。老备份没有这张表，退回旧行为并在结果里说明。
+- 重名的额外路径（如两个 `data`）不再互相覆盖，自动加 `-2`、`-3` 后缀。
+
+**备份内容更干净**
+
+- 任意层级的浏览器 profile 一律跳过：`stroll/douyin-profile` 这类嵌在扩展自己目录里的 profile 原本整包带走（几十 MB 全是可重建的缓存，打包时还容易撞上 `EBUSY`）。`*‑profile` 后缀名一律算。
+- `data/archivist` 加进跳过名单，作为升级路径上的兜底。
+
+**其他**
+
+- `package.json` 补上 `repository`（市场建议，便于以后联系）。
+- 测试扩到 193 项，新增覆盖：自我打包、`data/` 子目录快照、额外路径往返、重名、跳过判定、Windows 大小写与路径分隔符。
+
 ## 0.3.3 — 2026-11-05
 
 首个公开发布的版本。备份与恢复都在里面。

package/README.md

@@ -4,6 +4,9 @@
 
 她的长期记忆散在三个地方——`workspace/`（画像、自述、日记、笔记、交接档案）、`data/*.json`（事实库、向量索引、档案、反思、画像卡）、`config.json` + `.env` + `providers/`（配置与密钥）。这个扩展把三处打成一个 zip，滚动保留若干份；要回退时从任意一份放回去。
 
+> ⚠️ **这三处说的是「备份打些什么」，不是「恢复碰些什么」。**
+> 恢复的覆盖面大得多，见下面[恢复](#恢复)一节——它会覆盖**所有扩展的数据**、**所有 World 的配置**和**全部密钥**。
+
 **零上下文成本**：不进系统前缀（`envPromptVars()` 返回 `null`）、不注册任何工具（`tools()` 返回 `[]`）。它只在后台跑，不吃 token。
 
 ## 装
@@ -20,18 +23,34 @@ pnpm add cortico-world-archivist        # 或在扩展市场里装
 | --- | --- |
 | 备份间隔 | 多久一次（小时）。进程重启后会检查是否超期，超了就立刻补一次 |
 | 保留份数 | 滚动保留。超过就删最老的 |
-| 存放位置 | zip 放哪。留空 = `data/archivist/`。**建议放到另一块硬盘或网盘同步目录** |
+| 存放位置 | zip 放哪。留空 = **部署目录**下的 `archivist/`（在 `data/` 之外，不会被下一次备份打包进去）。**建议放到另一块硬盘或网盘同步目录** |
 | 备份内容 | 五项可勾：工作区全部 / git 历史 / blobs 附件 / 扩展数据 / 配置与密钥 |
 | 连带扩展包 | 把 `extensions/` 也打包。几十 MB，一般不用 |
 | 额外要备份的路径 | 一行一个。给那些把数据放在子目录、或装在别处的扩展补漏 |
 | 立即备份一次 | 拨到开 → 一分钟内开始，做完自动关回去 |
 
-「扩展数据」是**自动扫描** `data/` 目录的：装了什么扩展就备份什么，不用手动配。只跳过明确可重建的东西（运行态 JSON、缓存、`session-main.jsonl` 这类流水，以及 `media/`、`figures/`、`emoji/` 这些几十上百 MB 的素材目录）。判定标准写在 `src/config.js` 的 `DATA_SKIP` / `DATA_SKIP_DIRS` 里，附了每一条的理由。
+**存放位置绝不能落在 `data/` 里。** 「扩展数据」会整目录扫描 `data/`，把备份目录放在那里等于每一份新 zip 都把之前的 zip 一起打包——zip 已经压过，再压一次几乎不变小，单份体积逐次接近翻倍，几天就能吃掉整块盘，或者让 `Compress-Archive` 因为单文件过大而失败。
+
+即使你手动把它指回 `data/` 里，扩展也不会自我打包：判定按绝对路径做，存放位置与它下面的 `before-restore-*` 在备份、快照、恢复三处都被排除。老版本升级上来的部署如果 `<data>/archivist` 里已经有旧包，会继续用老位置（否则轮转在新目录里从零开始，旧包再也清不掉）。
+
+「扩展数据」是**自动扫描** `data/` 目录的：装了什么扩展就备份什么，不用手动配。只跳过明确可重建的东西（运行态 JSON、缓存、`session-main.jsonl` 这类流水、任意层级的浏览器 profile，以及 `media/`、`figures/`、`emoji/` 这些几十上百 MB 的素材目录）。判定标准写在 `src/config.js` 的 `DATA_SKIP` / `DATA_SKIP_DIRS` / `DATA_SKIP_ANY_DIR` 里，附了每一条的理由。
 
 一份真实部署（9 MB 工作区 + 13 MB 记忆数据）打包后约 **15 MB，4～5 秒**。
 
 ## 恢复
 
+> ### ⚠️ 恢复的覆盖面
+>
+> 恢复**不只是把「她的记忆」放回去**。它按备份里的内容原样写回原位，所以实际覆盖的是：
+>
+> | 覆盖什么 | 具体是 |
+> | --- | --- |
+> | **所有扩展的数据** | `data/` 下**每一个**扩展存的东西：记忆库、事实库、向量索引、档案、卡片、表情包索引、词汇本……不只是本扩展或记忆类扩展 |
+> | **所有 World 的配置** | `config.json` 里的**每一个 Worlds 段**（桌面宠物、QQ、语音、社交、做梦、画画……），不只是 `worlds.archivist` |
+> | **全部密钥** | `.env` 与 `providers/` 下所有模型渠道的 Key 和地址 |
+>
+> 备份之后的**新文件不会被删除**（只覆盖、不删除），但**已有文件会被换成备份时的版本**。文件被覆盖前会先存到 `before-restore-<时间>/`，见下面第 3 步。
+
 恢复默认**只用于灾难恢复**，所以设了两道闸：
 
 1. **确认口令**：必须先输入 `RESTORE`（或「恢复」），否则「立即恢复」开关不动。
@@ -46,6 +65,8 @@ pnpm add cortico-world-archivist        # 或在扩展市场里装
 ④ 才复制覆盖
 ```
 
+第 ③ 步快照的范围与第 ④ 步覆盖的范围**一一对应**：`workspace/` 的各个子项、`data/` 的顶层数据文件**和每个会被整包覆盖的子目录**、`config.json` / `.env` / `providers/`、以及额外路径（存在快照的 `extra/` 下，按包内名字对应）。所以任何一个被恢复覆盖的位置都拿得回来。
+
 **恢复完必须重启 Coopanion。** 记忆类扩展（如 memory-extra）把数据缓存在内存里、每 2 秒全量 flush 一次，不重启会被旧内存写回去。`workspace/*.md` 是每次现读的，会立刻生效。
 
 所以恢复完会再等 3 秒复查一遍：如果 `data/` 里的文件在恢复后立刻被改写（内容变了，不只是时间戳），说明进程正把旧数据写回磁盘，这时结果里会直接说「这次恢复对它们无效，请完全退出 Coopanion 后重新恢复」，而不是留下一个看起来成功的假象。
@@ -77,6 +98,8 @@ pnpm add cortico-world-archivist        # 或在扩展市场里装
 
 - zip 打包和解压调系统能力（Windows 用 `Compress-Archive` / `Expand-Archive`，macOS/Linux 用 `zip` / `unzip`），不引第三方依赖，所以打包时源文件被并发改写可能进包失败——这也是先复制到临时目录再压缩的原因。
 - 恢复 `config.json` 会连 `worlds.archivist` 这一段一起还原，包括当时的「存放位置」。如果你改过存放位置，恢复后它也会变回去。
+- 快照与备份都会跳过浏览器 profile（`*‑profile`），所以这些缓存不在回滚范围内——它们本来也能重建。
+- 恢复**只覆盖、不删除**：备份之后新写出来的文件会留在原地，不会因为你回退到旧备份而消失。
 - 不做增量备份，每次都是全量。这样单份 zip 自包含，恢复时不用找链条。
 
 ## 开发

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "cortico-world-archivist",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "type": "module",
   "author": {
     "name": "g_zone"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/z-o-n-e/cortico-world-archivist.git"
+  },
   "description": "备份与恢复 —— 定期把她的工作区、记忆数据和配置打包成 zip，滚动保留若干份；需要时一键恢复（恢复前自动留存当前状态）。零上下文成本：不进系统前缀、不占工具表。",
   "license": "MIT",
   "os": [

package/src/backup.js

@@ -8,15 +8,50 @@
  *  - 任何一步失败都清理临时目录，不留下垃圾
  */
 import { existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
-import { copyFile, rm, mkdir, readdir, stat } from 'node:fs/promises';
-import { join, basename, dirname, resolve } from 'node:path';
+import { copyFile, rm, mkdir, readdir, stat, writeFile } from 'node:fs/promises';
+import { join, basename, dirname, resolve, sep } from 'node:path';
 import { tmpdir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
-import { CONFIG_FILES, CONFIG_DIRS, DATA_SKIP, DATA_SKIP_DIRS } from './config.js';
+import { CONFIG_FILES, CONFIG_DIRS, DATA_SKIP, DATA_SKIP_DIRS, skipAnyDir } from './config.js';
+
+/** 绝对路径统一形态（Windows 不分大小写），用来比对「在不在某个目录里」。 */
+function norm(p) {
+  const abs = resolve(p);
+  return process.platform === 'win32' ? abs.toLowerCase() : abs;
+}
+
+/** abs 是否就是 root 或落在 root 里面。 */
+export function isInside(abs, root) {
+  const a = norm(abs);
+  const r = norm(root);
+  return a === r || a.startsWith(r.endsWith(sep) ? r : r + sep);
+}
+
+/**
+ * 配置没填存放位置时的默认目录。
+ *
+ * 默认放部署目录下（botDir），**不放** data/ 里：data/ 会被「扩展数据」整目录扫描，
+ * 放在里面等于每份备份都把之前的 zip 一起打包——zip 已经压过，再打一次几乎不变小，
+ * 单份体积就逐次接近翻倍，直到占满磁盘或压缩失败。
+ *
+ * 但老部署升级上来时 `<dataDir>/archivist` 里可能已经有旧包。继续用它，
+ * 否则「保留份数」的轮转会在新目录里从零开始，旧包再也清不掉。
+ *
+ * @param {{botDir: string, dataDir: string}} dirs
+ */
+export function defaultDestDir({ botDir, dataDir }) {
+  const legacy = join(dataDir, 'archivist');
+  try {
+    if (existsSync(legacy) && readdirSync(legacy).some((f) => f.endsWith('.zip'))) return legacy;
+  } catch {
+    // 读不了就按新默认走
+  }
+  return join(botDir, 'archivist');
+}
 
 /** 递归复制目录；onError 收集单个文件的失败，不中断整体。 */
-async function copyDir(src, dest, onError) {
+async function copyDir(src, dest, onError, skip) {
   await mkdir(dest, { recursive: true });
   let entries;
   try {
@@ -28,8 +63,9 @@ async function copyDir(src, dest, onError) {
   for (const entry of entries) {
     const s = join(src, entry.name);
     const d = join(dest, entry.name);
+    if (skip?.(s, entry.name, entry.isDirectory())) continue;
     if (entry.isDirectory()) {
-      await copyDir(s, d, onError);
+      await copyDir(s, d, onError, skip);
     } else if (entry.isFile()) {
       try {
         await copyFile(s, d);
@@ -100,6 +136,35 @@ function stampOf(name) {
   return new Date(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]).getTime();
 }
 
+/**
+ * 把 `extraPaths` 配置解析成「包里的名字 → 原始绝对路径」。
+ *
+ * 单独抽出来是为了备份与恢复用同一份映射：恢复时才知道该放回哪里，
+ * 快照时也知道该给哪些路径留副本。重名就加 `-2`、`-3` 后缀。
+ *
+ * @param {string} botDir
+ * @param {object} cfg
+ * @returns {{name: string, abs: string}[]}
+ */
+export function extraTargets(botDir, cfg) {
+  const raw = String(cfg?.extraPaths ?? '')
+    .split(/\r?\n/)
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .filter((s) => !s.startsWith('#'));
+  const out = [];
+  const used = new Set();
+  for (const item of raw) {
+    const abs = resolve(botDir, item);
+    if (!existsSync(abs)) continue;
+    let name = basename(abs);
+    for (let i = 2; used.has(name); i++) name = `${basename(abs)}-${i}`;
+    used.add(name);
+    out.push({ name, abs });
+  }
+  return out;
+}
+
 /**
  * 执行一次备份。
  * @param {object} opts
@@ -115,7 +180,9 @@ export async function runBackup({ botDir, dataDir, cfg, log }) {
   const onError = (msg) => { errors.push(msg); if (errors.length <= 20) log(`跳过 ${msg}`); };
 
   // ---- 决定目标目录 ----
-  const destDir = cfg.destDir?.trim() ? resolve(cfg.destDir.trim()) : join(dataDir, 'archivist');
+  // 与 world.js 的 destDir() 保持一致：默认放在部署目录（botDir）下，不在 data/ 里面。
+  // 老部署如果已经在 <dataDir>/archivist 里攒了旧包，就继续用那里。
+  const destDir = cfg.destDir?.trim() ? resolve(cfg.destDir.trim()) : defaultDestDir({ botDir, dataDir });
   try {
     mkdirSync(destDir, { recursive: true });
   } catch (e) {
@@ -193,12 +260,24 @@ export async function runBackup({ botDir, dataDir, cfg, log }) {
         onError(`读不了数据目录 ${dataDir}: ${e.code ?? e.message}`);
       }
 
+      // 存放位置可能就在 data/ 里面（老版本的默认位置）。绝不能把它打进包：
+      // zip 本身已经压过，再打一次几乎不变小，体积会逐份接近翻倍，直到占满磁盘。
+      // 这里按绝对路径判定，比只比名字更稳——用户也可能把存放位置指到 data/ 的某个子目录。
+      const isSelfDir = (abs) => isInside(abs, destDir);
+
       for (const entry of entries) {
         // 跳过不需要备份的目录（venv、浏览器 profile、运行日志等）
         if (entry.isDirectory()) {
           if (DATA_SKIP_DIRS.has(entry.name)) continue;
-          // 其它子目录整包带走（有些扩展把数据放在自己的子目录里）
-          await copyDir(join(dataDir, entry.name), join(target, entry.name), onError);
+          const abs = join(dataDir, entry.name);
+          if (isSelfDir(abs)) {
+            log(`跳过自己的存放位置 ${abs}（否则备份会把自己打进去）`);
+            continue;
+          }
+          // 其它子目录整包带走（有些扩展把数据放在自己的子目录里），
+          // 但任意层级上的浏览器 profile 一律跳过。
+          await copyDir(abs, join(target, entry.name), onError,
+            (p, name, isDir) => isDir && (skipAnyDir(name) || isSelfDir(p)));
           nDirs++;
           continue;
         }
@@ -217,22 +296,19 @@ export async function runBackup({ botDir, dataDir, cfg, log }) {
     }
 
     // ---- 2b. 用户指定的额外路径 ----
-    const extra = String(cfg.extraPaths ?? '')
-      .split(/\r?\n/)
-      .map((s) => s.trim())
-      .filter(Boolean)
-      .filter((s) => !s.startsWith('#'));
-    if (extra.length) {
+    const extraList = extraTargets(botDir, cfg);
+    // 逐条报出「配了但不存在」的路径，别让它静默消失
+    for (const raw of String(cfg.extraPaths ?? '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)) {
+      if (raw.startsWith('#')) continue;
+      if (!extraList.some((e) => e.abs === resolve(botDir, raw))) onError(`额外路径不存在: ${raw}`);
+    }
+    if (extraList.length) {
       const target = join(stage, 'extra');
+      const mapping = {};
       let n = 0;
-      for (const raw of extra) {
-        const abs = resolve(botDir, raw);
-        if (!existsSync(abs)) {
-          onError(`额外路径不存在: ${raw}`);
-          continue;
-        }
+      for (const { name, abs } of extraList) {
+        mapping[name] = abs;
         const st = statSync(abs);
-        const name = basename(abs);
         if (st.isDirectory()) {
           await copyDir(abs, join(target, name), onError);
           n++;
@@ -240,7 +316,14 @@ export async function runBackup({ botDir, dataDir, cfg, log }) {
           if (await copyOne(abs, join(target, name), onError)) n++;
         }
       }
-      if (n) done.push(`额外路径(${n})`);
+      // 记下「包里的名字 → 原始绝对路径」，恢复时才能放回原处
+      // （光看名字只知道 basename，会一股脑倒在 botDir 下）
+      if (n) {
+        await writeFile(
+          join(target, 'extra-map.json'), JSON.stringify(mapping, null, 2), 'utf8',
+        );
+        done.push(`额外路径(${n})`);
+      }
     }
 
     // ---- 3. 配置与密钥 ----
@@ -305,7 +388,6 @@ export async function runBackup({ botDir, dataDir, cfg, log }) {
       `恢复后扩展会在下次启动时自行重建它们。`,
       ``,
     ].join('\n');
-    const { writeFile } = await import('node:fs/promises');
     await writeFile(join(stage, 'MANIFEST.md'), manifest, 'utf8');
 
     // ---- 6. 压缩 ----

package/src/config.js

@@ -17,7 +17,7 @@ export const TITLES_ZH = {
   keepCountNote: '备份是滚动的：超过这个数量就自动删掉最老的一份。',
   copies: '份',
   destDir: '存放位置',
-  destDirNote: '备份 zip 存到哪个文件夹。留空 = 数据目录下的 archivist 文件夹。建议放到另一块硬盘或网盘同步目录。',
+  destDirNote: '备份 zip 存到哪个文件夹。留空 = 部署目录下的 archivist 文件夹（在 data/ 之外，不会被下一次备份打包进去）。建议放到另一块硬盘或网盘同步目录。',
   extraPaths: '额外要备份的路径',
   extraPathsNote: '一行一个，绝对路径或相对部署目录均可。给那些把数据放在子目录、或装在别处的扩展补漏。一般不用填。',
   includeExtensions: '连带扩展包',
@@ -30,11 +30,11 @@ export const TITLES_ZH = {
   lastResult: '上次备份结果',
   // ---- 恢复 ----
   restoreTitle: '恢复（危险）',
-  restoreNote: '把备份里的文件放回原位。恢复前会先把当前状态存一份到存放位置下的 before-restore-<时间>/，万一后悔还能拿回来。恢复完成后必须重启 Coopanion。',
+  restoreNote: '把备份里的文件原样放回原位。⚠️ 覆盖面比「她的记忆」大得多：恢复会覆盖【所有扩展的数据目录与数据文件】（data/ 下各扩展存的记忆库、档案、卡片、表情包索引、词汇本等）、【所有 World 的配置】（config.json 里的每一个 Worlds 段，不只是本扩展）、以及【全部密钥】（.env、providers/ 选择器里的所有模型渠道 Key）。恢复前会先把当前状态存一份到存放位置下的 before-restore-<时间>/，万一后悔还能拿回来。恢复完成后必须重启 Coopanion。',
   restoreFile: '要恢复的备份',
   restoreFileNote: '选一个 .zip 备份文件。留空 = 用存放位置里最新的那一份。',
   restoreConfirm: '确认口令',
-  restoreConfirmNote: '恢复会覆盖现在的数据。确实要恢复，请在这里原样输入 RESTORE（或「恢复」两个字）。口令不对，下面的开关不会动作。',
+  restoreConfirmNote: '恢复会覆盖上面说的全部范围。确实要恢复，请在这里原样输入 RESTORE（或「恢复」两个字）。口令不对，下面的开关不会动作。',
   restoreNow: '立即恢复',
   restoreNowNote: '口令填对之后拨到开 → 一分钟内开始恢复，做完自动关回去。恢复期间请勿关闭 Coopanion。',
   lastRestoreAt: '上次恢复时间',
@@ -52,7 +52,7 @@ export const TITLES_EN = {
   keepCountNote: 'Rolling: the oldest archive is deleted once this many exist.',
   copies: 'files',
   destDir: 'Destination',
-  destDirNote: 'Folder for the zip files. Empty = the archivist folder inside the data directory. Prefer another disk or a synced folder.',
+  destDirNote: 'Folder for the zip files. Empty = the archivist folder in the deployment directory, outside data/, so backups never pack themselves. Prefer another disk or a synced folder.',
   extraPaths: 'Extra paths to back up',
   extraPathsNote: 'One per line; absolute, or relative to the deployment directory. For extensions that keep data in a subfolder or elsewhere. Usually unnecessary.',
   includeExtensions: 'Include extensions',
@@ -65,11 +65,11 @@ export const TITLES_EN = {
   lastResult: 'Backup result',
   // ---- restore ----
   restoreTitle: 'Restore (dangerous)',
-  restoreNote: 'Puts archived files back where they belong. The current state is first copied to before-restore-<time>/ inside the destination folder, so a mistake is recoverable. Coopanion must be restarted afterwards.',
+  restoreNote: 'Puts archived files back where they belong. ⚠️ This covers far more than her memories: it overwrites ALL extension data (the memory stores, archives, cards, sticker index and vocabulary that every extension keeps under data/), ALL World configuration (every Worlds section in config.json, not just this extension), and ALL API keys (.env plus every model channel under providers/). The current state is first copied to before-restore-<time>/ inside the destination folder, so a mistake is recoverable. Coopanion must be restarted afterwards.',
   restoreFile: 'Archive to restore',
   restoreFileNote: 'Pick a .zip archive. Empty = the newest one in the destination folder.',
   restoreConfirm: 'Confirmation code',
-  restoreConfirmNote: 'Restoring overwrites current data. To proceed, type RESTORE here exactly. The switch below does nothing without it.',
+  restoreConfirmNote: 'Restoring overwrites everything listed above. To proceed, type RESTORE here exactly. The switch below does nothing without it.',
   restoreNow: 'Restore now',
   restoreNowNote: 'With the code in place, switch on → the restore starts within a minute and the switch flips back. Do not quit Coopanion while it runs.',
   lastRestoreAt: 'Last restore',
@@ -127,9 +127,9 @@ export const SOURCES = [
     root: 'data',
     defaultOn: true,
     title: '扩展数据（data/ 下的文件）',
-    note: '自动扫描 data 目录里所有扩展存的数据：记忆库、档案、卡片、表情包索引、词汇本……装了什么扩展就备份什么，不用手动配。仅跳过可重建的临时状态与缓存。',
+    note: '自动扫描 data 目录里所有扩展存的数据：记忆库、档案、卡片、表情包索引、词汇本……装了什么扩展就备份什么，不用手动配。仅跳过可重建的临时状态、缓存与浏览器 profile，以及备份自己的存放位置。',
     enTitle: 'Extension data (files under data/)',
-    enNote: 'Scans the data folder for whatever the installed extensions store: memory databases, archives, cards, sticker index, vocabulary… Nothing to configure — only rebuildable runtime state and caches are skipped.',
+    enNote: 'Scans the data folder for whatever the installed extensions store: memory databases, archives, cards, sticker index, vocabulary… Nothing to configure — only rebuildable runtime state, caches, browser profiles and the backup folder itself are skipped.',
   },
   // ---- 配置 ----
   {
@@ -138,9 +138,9 @@ export const SOURCES = [
     root: 'bot',
     defaultOn: true,
     title: '配置与密钥',
-    note: 'config.json、.env、providers/ 下的模型渠道配置',
+    note: 'config.json、.env、providers/ 下的模型渠道配置。注意这是整套配置：恢复时 config.json 里【所有 World 的配置】和【全部渠道密钥】都会一起回到备份时的样子',
     enTitle: 'Config and secrets',
-    enNote: 'config.json, .env, and the model channel configs under providers/.',
+    enNote: 'config.json, .env, and the model channel configs under providers/. Note that this is the whole thing: restoring puts back EVERY World section in config.json and EVERY channel key as of the backup.',
   },
 ];
 
@@ -188,8 +188,33 @@ export const DATA_SKIP_DIRS = new Set([
   'qq-video',       // 视频缓存
   'emote-pics-popup', // 弹窗临时资源
   'bilibili-video', // 视频素材缓存
+  'archivist',      // 老版本的默认存放位置。留着这一条，免得升级后把旧包又打进去
 ]);
 
+/**
+ * 目录名命中就算跳过 —— 在任意层级的子目录上都生效。
+ *
+ * `DATA_SKIP_DIRS` 只比对 data/ 的顶层，所以像 `stroll/douyin-profile`
+ * 这种嵌在扩展自己的目录里的浏览器 profile 会整包被带走（几十 MB，
+ * 全是可以重建的缓存，打包时还容易撞上 EBUSY）。
+ */
+export const DATA_SKIP_ANY_DIR = new Set([
+  'douyin-profile',
+  'browser-profile',
+  'chrome-profile',
+  '*-profile',
+]);
+
+/**
+ * 判断某个目录名（任意层级）是否该跳过。
+ * 支持 `*-profile` 这种后缀式通配。
+ * @param {string} name
+ */
+export function skipAnyDir(name) {
+  if (DATA_SKIP_ANY_DIR.has(name)) return true;
+  return name.endsWith('-profile');
+}
+
 /** config 源要打包的具体文件（相对 botDir）。 */
 export const CONFIG_FILES = [
   'config.json',

package/src/restore.js

@@ -12,12 +12,13 @@
  * 恢复完成会等几秒复查一遍：真被写回去了就当场喊出来，别让人以为恢复成功了。
  */
 import { existsSync } from 'node:fs';
-import { copyFile, rm, mkdir, readdir, readFile, rename } from 'node:fs/promises';
+import { copyFile, rm, mkdir, readdir, readFile, rename, stat } from 'node:fs/promises';
 import { join, basename, dirname, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
-import { CONFIG_FILES, CONFIG_DIRS } from './config.js';
+import { CONFIG_FILES, CONFIG_DIRS, DATA_SKIP, DATA_SKIP_DIRS, skipAnyDir } from './config.js';
+import { defaultDestDir, isInside, extraTargets } from './backup.js';
 
 /** 一个文件的 sha1；读不到给 null。 */
 async function hashFile(path) {
@@ -111,8 +112,8 @@ function decompress(zipPath, outDir) {
   });
 }
 
-/** 递归复制目录并覆盖。 */
-async function overwriteDir(src, dest, onError, stats) {
+/** 递归复制目录并覆盖。`skip(path, name, isDir)` 返回 true 的条目直接不碰。 */
+async function overwriteDir(src, dest, onError, stats, skip) {
   await mkdir(dest, { recursive: true });
   let entries;
   try {
@@ -124,7 +125,8 @@ async function overwriteDir(src, dest, onError, stats) {
   for (const entry of entries) {
     const s = join(src, entry.name);
     const d = join(dest, entry.name);
-    if (entry.isDirectory()) await overwriteDir(s, d, onError, stats);
+    if (skip?.(s, entry.name, entry.isDirectory())) continue;
+    if (entry.isDirectory()) await overwriteDir(s, d, onError, stats, skip);
     else if (entry.isFile()) {
       try {
         await copyFile(s, d);
@@ -189,10 +191,21 @@ async function snapshotCurrent({ botDir, dataDir, cfg, destDir, onError, stats }
   if (wantData && existsSync(dataDir)) {
     const dst = join(target, 'data');
     await mkdir(dst, { recursive: true });
-    // 只快照备份包里会恢复的那些顶层文件（与 backup.js 的扫描规则一致）
+    // 和 backup.js 的扫描规则保持一致：顶层数据文件 + 每个整包带走的子目录。
+    // 子目录也必须快照——恢复时它们是整个覆盖的（data/stroll、data/terrarium 之类），
+    // 只存顶层文件的话，这些目录被覆盖掉就再也拿不回原样了。
     for (const entry of await readdir(dataDir, { withFileTypes: true }).catch(() => [])) {
-      if (entry.isFile() && /\.(json|jsonl|db|sqlite|yaml|yml|txt|md)$/i.test(entry.name)) {
-        await overwriteOne(join(dataDir, entry.name), join(dst, entry.name), onError, stats);
+      const src = join(dataDir, entry.name);
+      const out = join(dst, entry.name);
+      if (entry.isDirectory()) {
+        if (DATA_SKIP_DIRS.has(entry.name)) continue;
+        if (isInside(src, destDir)) continue; // 自己的存放位置，别把 zip 拷进快照
+        await overwriteDir(src, out, onError, stats,
+          (p, name, isDir) => isDir && (skipAnyDir(name) || isInside(p, destDir)));
+      } else if (entry.isFile()) {
+        if (DATA_SKIP.has(entry.name)) continue;
+        if (!/\.(json|jsonl|db|sqlite|yaml|yml|txt|md)$/i.test(entry.name)) continue;
+        await overwriteOne(src, out, onError, stats);
       }
     }
   }
@@ -203,6 +216,31 @@ async function snapshotCurrent({ botDir, dataDir, cfg, destDir, onError, stats }
     for (const f of CONFIG_FILES) {
       await overwriteOne(join(botDir, f), join(dst, f), onError, stats);
     }
+    for (const d of CONFIG_DIRS) {
+      const src = join(botDir, d);
+      if (existsSync(src)) await overwriteDir(src, join(dst, d), onError, stats);
+    }
+  }
+
+  // 额外路径同样会被恢复覆盖，同样得留副本。按「包里的名字」存，
+  // 和 zip 里的 extra/ 结构一致，回滚时照着放回去就行。
+  const extras = extraTargets(botDir, cfg);
+  if (extras.length) {
+    const dst = join(target, 'extra');
+    await mkdir(dst, { recursive: true });
+    for (const { name, abs } of extras) {
+      if (isInside(abs, destDir)) continue;
+      try {
+        if ((await stat(abs)).isDirectory()) {
+          await overwriteDir(abs, join(dst, name), onError, stats,
+            (p, n2, isDir) => isDir && skipAnyDir(n2));
+        } else {
+          await overwriteOne(abs, join(dst, name), onError, stats);
+        }
+      } catch {
+        // 单条路径读不到就算了，不拖累整体
+      }
+    }
   }
 
   return target;
@@ -252,7 +290,9 @@ export async function runRestore({ botDir, dataDir, cfg, zipPath, log }) {
       return { ok: false, detail: '备份里没有可恢复的内容（workspace/data/config 都不存在）。' };
     }
 
-    const destDir = cfg.destDir?.trim() ? resolve(cfg.destDir.trim()) : join(dataDir, 'archivist');
+    const destDir = cfg.destDir?.trim()
+      ? resolve(cfg.destDir.trim())
+      : defaultDestDir({ botDir, dataDir });
 
     // ---- ③ 先备份当前状态 ----
     const pre = { files: 0 };
@@ -303,9 +343,17 @@ export async function runRestore({ botDir, dataDir, cfg, zipPath, log }) {
       for (const entry of await readdir(src, { withFileTypes: true }).catch(() => [])) {
         const s = join(src, entry.name);
         const t = join(dst, entry.name);
+        // 存放位置若在 data/ 内，恢复它就是把备份目录本身覆盖成旧版本。
+        // 跳过：这一步没有意义，还会把刚拿到的包弄坏。
+        if (isInside(t, destDir)) {
+          log(`跳过 ${t}（这是自己的存放位置，不能覆盖）`);
+          continue;
+        }
+        const skip = (p, name, isDir) => isDir && (skipAnyDir(name) || isInside(p, destDir));
         if (entry.isDirectory()) {
-          await overwriteDir(s, t, onError, stats);
+          await overwriteDir(s, t, onError, stats, skip);
         } else if (entry.isFile()) {
+          if (DATA_SKIP.has(entry.name)) continue;
           if (await overwriteOne(s, t, onError, stats)) dataFiles.push(t);
         }
         n++;
@@ -331,13 +379,24 @@ export async function runRestore({ botDir, dataDir, cfg, zipPath, log }) {
 
     if (hasExtra) {
       const src = join(stage, 'extra');
+      // 包里记了「名字 → 原始绝对路径」就照它放回原处；
+      // 老备份没有这张表，只能退回旧行为（放进 botDir），并在结果里说清楚。
+      let mapping = null;
+      try {
+        mapping = JSON.parse(await readFile(join(src, 'extra-map.json'), 'utf8'));
+      } catch {
+        mapping = null;
+      }
+      let n = 0;
       for (const entry of await readdir(src, { withFileTypes: true }).catch(() => [])) {
+        if (entry.isFile() && entry.name === 'extra-map.json') continue;
         const s = join(src, entry.name);
-        const t = join(botDir, entry.name);
-        if (entry.isDirectory()) await overwriteDir(s, t, onError, stats);
+        const t = mapping?.[entry.name] ? resolve(mapping[entry.name]) : join(botDir, entry.name);
+        if (entry.isDirectory()) await overwriteDir(s, t, onError, stats, (p, name, isDir) => isDir && skipAnyDir(name));
         else if (entry.isFile()) await overwriteOne(s, t, onError, stats);
+        n++;
       }
-      done.push('额外路径');
+      if (n) done.push(mapping ? '额外路径' : '额外路径（老备份没有路径表，放到部署目录下）');
     }
 
     if (!done.length) {

package/src/world.js

@@ -7,7 +7,7 @@
  *  - 只做后台定时备份，外加面板上的手动备份 / 恢复
  */
 import { join, resolve } from 'node:path';
-import { runBackup, listBackups } from './backup.js';
+import { runBackup, listBackups, defaultDestDir } from './backup.js';
 import { runRestore } from './restore.js';
 import { configGroups, normalizeSources, TITLES_ZH, TITLES_EN } from './config.js';
 import { fileLogger } from './log.js';
@@ -70,10 +70,21 @@ export class ArchivistWorld {
     return { config: configGroups(lang === 'en' ? TITLES_EN : TITLES_ZH, lang) };
   }
 
-  /** 目标目录（配置留空时落到 dataDir/archivist）。 */
+  /**
+   * 目标目录（配置留空时的默认存放位置）。
+   *
+   * 默认放在**部署目录**（botDir）下，不再放在 data/ 里面。
+   * 原因：`data/` 会被「扩展数据」整目录扫描，放在里面等于让每一份新备份
+   * 把之前的 zip 也打进去——zip 已经压过，再打一次几乎不变小，体积逐份接近翻倍。
+   *
+   * 老部署升级上来时，`<dataDir>/archivist` 里可能已经有一堆旧包。
+   * 这时如果它非空，就继续用它：突然换地方会让「保留份数」的轮转在新目录里
+   * 从零开始，旧包再也清不掉。backup.js 的跳过判定按绝对路径做，两个位置都安全。
+   */
   destDir() {
     const raw = this.ctx.cfg.destDir;
-    return raw && String(raw).trim() ? String(raw).trim() : join(this.ctx.dataDir, DEFAULT_DEST_SUBDIR);
+    if (raw && String(raw).trim()) return String(raw).trim();
+    return defaultDestDir({ botDir: this.ctx.botDir, dataDir: this.ctx.dataDir });
   }
 
   /** 下一次该备份的时间（毫秒时间戳）；没有历史则立即。 */
@@ -96,7 +107,7 @@ export class ArchivistWorld {
     try {
       dest = this.destDir();
     } catch {
-      dest = DEFAULT_DEST_SUBDIR;
+      dest = join(this.ctx.dataDir, DEFAULT_DEST_SUBDIR);
     }
     if (!this._logger || this._loggerDir !== dest) {
       this._loggerDir = dest;