@xiaoyuyu6420/dsh-backup 0.13.4 → 0.14.0

package/lib/index.js

@@ -5,7 +5,7 @@
  * node_modules，生成 sha256 校验和，自动轮换旧备份；定时自动备份
  * 状态落盘、重启续跑；跨平台（macOS / Linux / Windows）。
  *
- * - `/backup`                              立即备份（默认到 ~/Desktop/dsh-backups/）
+ * - `/backup`                              立即备份（默认到 ~/Desktop/DSH Backups/）
  * - `/backup list`                         列出已有备份（含大小）+ 自动备份状态
  * - `/backup verify [前缀|all]`            校验备份完整性（缺省校验最新一份）
  * - `/backup restore <前缀|latest> [--dry-run]`  恢复（先校验 + 自动快照当前数据）
@@ -27,6 +27,8 @@
  * - 救援通道（进程外）：每次备份把 rescue.mjs + 双击启动器（点我恢复.command/.bat/.sh）
  *   + RESCUE.txt 写进备份目录——DSH 起不来时双击/`node rescue.mjs` 打开零依赖
  *   救援网页（列表/校验/恢复/doctor），Node 活着就能自救
+ * - 使用说明：每次备份在备份目录根写一份「使用说明.txt」，讲清每个文件是什么、
+ *   恢复走哪三条路——第一次打开这个文件夹的用户不用去翻 README
  *
  * 安全说明（v0.7.0 起）：凭据文件（.credentials.yaml / .env / qq-bridge/config.json，
  * config.redact 可增删）默认脱敏——不进归档、不进 GitHub 同步，明文只存备份目录下
@@ -35,6 +37,16 @@
  * 家目录不一致时提示绝对路径风险。config.redact=false/'off' 可回到 v0.6.x 明文行为
  * （不推荐）。归档与校验边车在 POSIX 上 chmod 600 仅本人可读写。
  * restore 会拒绝恢复含归档根目录之外条目的文件（tar 路径穿越防护）。
+ * 可选加密备份（P2）：backupPanel 的 backup({password}) 用 scrypt + AES-256-GCM 加密
+ * 归档（密文覆盖 .tar.gz 本体、参数进 .encrypted.json 边车、meta.encrypted=true）；
+ * 口令只经 RPC 内存态传入、绝不写 settings.yaml/日志/磁盘；list 显示 🔒，verify 只做
+ * 完整性（无需口令），restore 需口令、口令错误给明确人话报错。
+ * 导出/导入（P2）：把 ~/.dsh 打成单文件 ZIP（节段化、凭据默认脱敏、可选加密），导入
+ * 走 importPreview（dry-run 计划：节段/冲突/跨机 remap/兼容性评分）→ importApply
+ * （自动快照 → 应用 → 校验 → 失败回滚）；ZIP 视为不可信输入，防 Zip Slip/恶意路径/异常条目。
+ * P3：同步多通道（WebDAV / S3 兼容 / GitHub Gist，零依赖签名，凭据只存本机 0600）、
+ * GFS 保留（最近 N + 每月/每年各一份）、操作锁 + 残留锁回收（心跳 + 死锁判定，不误踢活锁）、
+ * 磁盘占用报告 + 分级清理（快照/同步永不删）、定时备份自定义每周时刻。
  *
  * 存储说明：插件自有数据（归档、校验和、auto.json）直接经 node:fs 写入
  * （与 dsh-session 持久化、skill-filesystem 同一模式）——ctx.fs 能力是
@@ -42,14 +54,20 @@
  * 插件的自有存储。
  */
 import { createHash, randomUUID } from 'node:crypto';
-import { createReadStream, readFileSync, realpathSync } from 'node:fs';
-import { mkdir, open, copyFile, chmod, readdir, readFile, rename, rm, stat as fsStat, unlink, writeFile, link } from 'node:fs/promises';
+import { createReadStream, existsSync, readFileSync, realpathSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { mkdir, open, copyFile, chmod, readdir, readFile, rename, rm, stat as fsStat, lstat, unlink, writeFile, link } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { hostname } from 'node:os';
-import { basename, dirname, join } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 import { fileURLToPath } from 'node:url';
 import * as zlib from 'node:zlib';
+import { encryptBuffer, decryptBuffer } from './encrypt.js';
+import { buildZip, listZip, extractZip, readZipEntry } from './zip.js';
+import { gfsProtectedSet } from './gfs.js';
+import { acquireLock, releaseLock, heartbeatLock, reclaimLock as reclaimOplock, isLockStale, LOCK_HEARTBEAT_MS } from './oplock.js';
+import { s3Put, webdavPut, gistSync, gistContent } from './sync-channels.js';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { SettingsConflictError } from '@deepseek-ai/dsh-settings';
@@ -78,6 +96,14 @@ const MAX_GITHUB_BYTES = 90 * 1024 * 1024;
 const SYNC_DIR = '.github-sync';
 /** Web 下载路由前缀（无尾斜杠：prefix 匹配语义为 pathname.startsWith(prefix + '/')）。 */
 const DOWNLOAD_PREFIX = '/backup-download';
+/** WebDAV/S3 同步的单文件整读 PUT 上限（内存缓冲护栏；超大归档跳过并上报）。 */
+const SYNC_MAX_BYTES = MAX_GITHUB_BYTES;
+/** GitHub Gist 单文件上限（GitHub 硬性约 10MB；超限跳过，gist 本就只适合轻量配置）。 */
+const GIST_MAX_BYTES = 10 * 1024 * 1024;
+/** 多通道同步配置文件名（备份目录根，0600；凭据不进归档不进日志）。 */
+const SYNC_CONFIG_FILE = 'sync.json';
+/** 操作锁文件名（备份目录根；pid+token+心跳）。 */
+const LOCK_FILE = '.oplock.json';
 /**
  * 默认脱敏的敏感文件（相对 ~/.dsh 根的 POSIX 路径）：凭据与环境变量文件
  * 明文绝不进归档、绝不进 GitHub 同步——真实值只落本机 vault（备份目录下
@@ -110,6 +136,39 @@ const BACKUP_TYPES = Object.freeze({
 /** 分类型归档前缀（与全量 dsh- 区分：独立轮换、不进全量列表、旧版插件不可见不误删）。 */
 const TYPED_PREFIX = 'dsh-t-';
 
+/**
+ * 导出/导入（P2）的节段表：把 ~/.dsh 顶层内容归入 10 个语义节段 + 一个 `other`
+ * 兜底节段。`paths` 是相对 ~/.dsh 根的 POSIX 路径（文件精确名 / 目录名）；
+ * credentials 节段默认脱敏（不进 ZIP），仅在 includeCredentials 且加密时入包。
+ *
+ * 节段划分与 BACKUP_TYPES（分类型备份）一致的最小集，但**按顶层非重叠**组织：
+ * profiles（插件）整目录归 plugins，家级 cordis*.yml 归 mcp（profile 内的 cordis
+ * 由 plugins 覆盖，避免重复入包）。`other` 收所有未匹配的顶层条目（attachments /
+ * cache / storages / dsh-market / .dshw-* 等 DSH 运行数据），保证「换机丢配置」
+ * 场景绝不静默丢文件——宁可多一个兜底节段，也不漏。
+ */
+const EXPORT_SECTIONS = Object.freeze([
+  { key: 'settings', label: '设置', paths: ['settings.yaml', 'settings.json'] },
+  { key: 'ui', label: '界面设置', paths: ['ui.json', 'ui-state.json', '.ui'] },
+  { key: 'providers', label: '模型供应商', paths: ['providers'] },
+  { key: 'plugins', label: '插件 profiles', paths: ['profiles'] },
+  { key: 'mcp', label: 'MCP 配置', paths: ['cordis.patch.yml', 'cordis.yml'] },
+  { key: 'skills', label: '技能', paths: ['skills'] },
+  { key: 'prompts', label: '提示词', paths: ['prompts'] },
+  { key: 'workspaces', label: '工作区', paths: ['workspaces'] },
+  { key: 'sessions', label: '会话', paths: ['sessions'] },
+  { key: 'credentials', label: '凭据/api key', paths: ['.credentials.yaml', '.env', 'qq-bridge'], credentials: true },
+]);
+/** 兜底节段 key：所有未匹配到上面 10 类的顶层文件/目录都归这里，绝不丢弃。 */
+const EXPORT_OTHER_KEY = 'other';
+/** 导出 manifest 的格式标识与版本（读端据此识别 dsh-config 包、拒绝未知格式）。 */
+const EXPORT_FORMAT = 'dsh-config-export';
+const EXPORT_FORMAT_VERSION = 1;
+/** 导出递归走查的目录/文件上限（防病态目录树把导出拖死）。 */
+const EXPORT_MAX_FILES = 100_000;
+/** 导出内部快照前缀（importApply 前拍的当前数据安全网，不进用户列表）。 */
+const IMPORT_SNAPSHOT_PREFIX = 'dsh-pre-import-';
+
 /**
  * 按类型 globs 匹配归档内条目（restore 侧）：把 BACKUP_TYPES 的相对路径转成
  * 对归档条目（${base}/ 前缀）的匹配——文件精确匹配、目录前缀匹配、含 * 的
@@ -158,6 +217,57 @@ const RESCUE_TXT = `DSH 出问题时的自救通道（不依赖 DSH 能否启动
 凭据从本目录 vault/ 自动补回。rescue.mjs / 启动器 / 本说明由 dsh-backup 每次备份时更新。
 `;
 
+/** 备份目录根的使用说明文件名：用户第一次打开文件夹时最该看到的东西。 */
+const GUIDE_FILE = '使用说明.txt';
+
+/**
+ * 随备份落盘的人话版说明书。
+ *
+ * 背景（0.14.0 UX 审查）：备份目录里混着归档、校验边车、救援工具、vault 和
+ * 调度状态，第一次打开的用户只看到一堆 tar.gz，既不知道能不能删，也不知道
+ * 恢复从哪下手。这份文件把「是什么 / 怎么恢复 / 哪些别动 / 怎么换位置」一次
+ * 讲清，和 RESCUE.txt（灾时专用）互补。每次备份都会重写，保持最新。
+ */
+const GUIDE_TXT = `DSH 备份文件夹 —— 使用说明
+================================
+
+这个文件夹由 dsh-backup 插件自动生成，保存你本机 DSH 的全部数据
+（~/.dsh：会话、设置、技能、插件配置……）。日常不需要手动改动这里。
+
+【怎么恢复】
+1. DSH 还能打开：在 DSH 里输入 /backup list 查看，再用 /backup restore latest；
+   或者打开 设置 → 插件 → 备份，在面板里点「恢复」。
+2. DSH 打不开：双击本文件夹里的「点我恢复」（macOS .command / Windows .bat /
+   Linux .sh），浏览器会打开救援页面，按提示校验/恢复。
+3. 终端：node rescue.mjs                 打开救援页面
+         node rescue.mjs list            列出备份
+         node rescue.mjs restore latest  预览恢复；加 --yes 执行
+
+【里面的文件都是什么】
+- dsh-<时间戳>.tar.gz    一份完整备份。别手动解压，也别改名。
+- 同名 .sha256           校验和，用来验证备份没损坏。
+- 同名 .meta.json        元数据（主机、时间等），恢复前预检用。
+- 同名 .redacted.json    脱敏清单（哪些凭据没进归档），有它时恢复会提示。
+- 点我恢复 / rescue.mjs  进程外救援工具：DSH 坏了也能跑。「RESCUE.txt」是它的说明。
+- vault/                 本机凭据明文备份（只有你能读；不要上传、不要分享）。
+- auto.json              自动备份的调度状态，删了会重置节奏。
+- .github-sync/          GitHub 同步缓存（开了 GitHub 同步才有，别手动改）。
+
+【想换个位置或名字】
+DSH 能打开时：设置 → 插件 → 备份 → 备份目录，改完保存立即生效。
+注意：改动只影响以后的新备份，已有的旧备份不会自动搬过去。
+
+【保留策略】
+默认保留最近 7 份（自动备份间隔不足 24 小时时保留 3 份），更旧的自动删除。
+本说明由 dsh-backup 在每次备份时自动更新，不用管它。
+
+【English】
+This folder is auto-generated by the dsh-backup plugin
+(https://github.com/xiaoyuyu6420/dsh-backup). It holds copies of your DSH data.
+To restore: run /backup restore latest inside DSH, or double-click the rescue
+launcher, or run "node rescue.mjs". Do not unpack or rename the archives by hand.
+`;
+
 /** 双击启动器：起救援服务并自动开浏览器。按当前平台生成，避免目录里躺三个系统的文件。 */
 const RESCUE_LAUNCHERS = Object.freeze({
   // 双击 .command 时 GUI 的 PATH 只有 /usr/bin:/bin:...，nvm/Homebrew 装的
@@ -299,13 +409,32 @@ const SELF_META = (() => {
  * 避免同一字面量散落多处导致迁移逻辑漏改。
  */
 const DEFAULTS = Object.freeze({
-  destination: '~/Desktop/dsh-backups',
+  // 0.14.0 起默认目录改名为 `DSH Backups`：旧名 `dsh-backups`（全小写 + 连字符）
+  // 在桌面/Finder 里像临时垃圾目录，用户打开也不知道里面是干嘛的。位置仍留在
+  // 桌面——救援通道（点我恢复）要求 DSH 彻底起不来时也能被非技术用户一眼找到。
+  destination: '~/Desktop/DSH Backups',
   exclude: [],
   redact: [...SENSITIVE_DEFAULTS],
   githubRepo: '',
   updateCheck: false,
+  // GFS 保留：keep 窗口外，每月一份 / 每年一份各保留多少个桶。0=关（等价旧行为）。
+  gfsMonthly: 0,
+  gfsYearly: 0,
+  // 配置市场索引地址（空 = 市场禁用；用户填了才拉取）。
+  marketUrl: '',
 });
 
+/**
+ * ≤0.13.4 的默认目录。升级后由 migrateLegacyDefaultDir() 同盘改名为新默认名；
+ * 迁移失败时 paths() 会继续使用老目录，保证已有备份不"消失"。
+ */
+const LEGACY_DEFAULT_DESTINATIONS = Object.freeze(['~/Desktop/dsh-backups']);
+
+/** existsSync 的安全包装：非法路径/权限异常一律按"不存在"处理。 */
+const pathExists = (p) => {
+  try { return existsSync(p); } catch { return false; }
+};
+
 /**
  * 解析 settings 命名空间的 schema，同时定义默认值。
  * Base 层：pluginConfig（cordis.patch.yml，插件级或 profile 级）。
@@ -334,12 +463,15 @@ const SCHEMA = z.object({
   redact: volatileField(z.union([z.array(z.string()), 'off', 'none']).default(DEFAULTS.redact)),
   githubRepo: volatileField(z.string().default(DEFAULTS.githubRepo)),
   updateCheck: volatileField(z.boolean().default(DEFAULTS.updateCheck)),
+  gfsMonthly: volatileField(z.number().min(0).default(DEFAULTS.gfsMonthly)),
+  gfsYearly: volatileField(z.number().min(0).default(DEFAULTS.gfsYearly)),
+  marketUrl: volatileField(z.string().default(DEFAULTS.marketUrl)),
 });
 
 /** 宿主装载条目时读取的 Config schema（0.1.7+ 的设置表单来源）。 */
 export const Config = SCHEMA;
 
-const SETTINGS_FIELDS = ['destination', 'keep', 'exclude', 'redact', 'githubRepo', 'updateCheck'];
+const SETTINGS_FIELDS = ['destination', 'keep', 'exclude', 'redact', 'githubRepo', 'updateCheck', 'gfsMonthly', 'gfsYearly', 'marketUrl'];
 
 /** 校验并归一化单个字段到 `out`；非法值忽略。 */
 function normalizeField(out, field, value) {
@@ -358,6 +490,11 @@ function normalizeField(out, field, value) {
     if (typeof value === 'string') out.githubRepo = value;
   } else if (field === 'updateCheck') {
     if (typeof value === 'boolean') out.updateCheck = value;
+  } else if (field === 'gfsMonthly' || field === 'gfsYearly') {
+    const n = Number(value);
+    if (Number.isFinite(n) && n >= 0) out[field] = Math.floor(n);
+  } else if (field === 'marketUrl') {
+    if (typeof value === 'string') out.marketUrl = value.trim();
   }
 }
 
@@ -428,11 +565,68 @@ function panelDescriptor(method, parameters, cancellation) {
   });
 }
 
+/**
+ * ============================================================================
+ * backupPanel RPC 契约（P2 新增/变更）——客户端 strict descriptor 据此实现
+ * ============================================================================
+ * 宿主多注册方法不影响客户端挂载（客户端只挂载它声明的子集）。口令一律「只经 RPC
+ * 传入、内存态」，绝不写 settings.yaml / 日志 / 磁盘。
+ *
+ * @method backup(keep?, types?, password?, signal) → { ok, summary, path, sha,
+ *         stale, keep, encrypted?, types?, hasCredentials? }
+ *   - password: string 可选。非空即加密备份（scrypt+AES-256-GCM，密文覆盖归档、
+ *     .encrypted.json 边书记参数，meta.encrypted=true）。
+ *
+ * @method restore(selector?, dryRun?, types?, syncDeps?, password?, signal)
+ *   → 与旧 shape 相同，另加加密归档的恢复：password 提供时用于解密；缺口令或口令
+ *     错误 → ok:false + 人话 summary（「口令错误或归档已损坏」）。
+ *
+ * @method exportConfig(options, signal)
+ *   options: { password?: string, includeCredentials?: boolean, sections?: string[] }
+ *   → { ok, summary, path, name, size, encrypted, manifest, redactedFiles }
+ *   manifest: { format:'dsh-config-export', version:1, createdAt, source:{host,home,
+ *              platform,pluginVersion}, redacted[], encrypted, sections:[{key,label,
+ *              files,bytes}], totalFiles, totalBytes }
+ *
+ * @method importPreview(options, signal)  // dry-run，只读
+ *   options: { sourcePath: string, password?: string }
+ *   → { ok, summary, encrypted, manifest, sections:[{key,label,files,bytes,
+ *       conflicts:[{name,rel,exists}]}], totalFiles, totalBytes, conflicts:[{name,rel,
+ *       section,exists}], remap:[{section,file,count,sample[]}],
+ *       compatibility:{score,reasons[]} }
+ *
+ * @method importApply(options, signal)  // 自动快照 → 应用 → 校验 → 失败回滚
+ *   options: { sourcePath, password?, sections?: string[], decisions?: {[name]:
+ *             'keep'|'overwrite'}, remap?: [{from,to}] }
+ *   → { ok, summary, encrypted, applied, skipped, overwrote, snapshot, remapped }
+ *
+ * P3 新增：
+ * @method syncStatus() → { ok, channels: {github,webdav,s3,gist}, summary }
+ *   每通道：{ channel, type, configured, url?/endpoint?/bucket?/gistId?, tokenSet?/
+ *   passwordSet?/secretKeySet?, lastPush, lastError }（凭据一律脱敏，不回显明文）
+ * @method syncNow(channel, signal) → { ok, summary, pushed, count?, at, tooBig?, gistUrl? }
+ * @method setSyncChannel(channel, config) → { ok, summary, channel? }
+ *   config 按通道：webdav{url,username,password} / s3{endpoint,region,bucket,
+ *   accessKey,secretKey,pathPrefix?,pathStyle?} / gist{token,gistId?}；凭据只存本机 0600
+ * @method removeSyncChannel(channel) → { ok, summary }
+ * @method lockStatus() → { ok, held, stale, pid, operation, startedAt, heartbeatAt }
+ * @method reclaimLock(force) → { ok, summary, heldBy? }
+ * @method diskUsage(signal) → { ok, total, totalText, categories:[{key,label,bytes,files}], summary }
+ * @method cleanup(scope, signal) → { ok, removed, names, summary }（scope='cache'|'expired'）
+ * @method setWeekly(schedules) → { ok, weekly:[{day,time}], summary }（day 1=周一..7=周日）
+ *
+ * P4 新增：
+ * @method about() → { ok, version, dshVersion, platform, node, profile, pluginDir }
+ *   环境信息脱敏：只含版本/平台/路径，绝不含凭据/密钥；home 不单独返回，pluginDir
+ *   若位于 home 下则 home 前缀脱敏成 ~（取不到一律 'unknown'）。
+ * ============================================================================
+ */
+
 const PANEL_INVOCATIONS = Object.freeze([
   panelDescriptor('status', []),
-  panelDescriptor('backup', ['keep', 'types'], true),
+  panelDescriptor('backup', ['keep', 'types', 'password'], true),
   panelDescriptor('verify', ['selector'], true),
-  panelDescriptor('restore', ['selector', 'dryRun', 'types', 'syncDeps'], true),
+  panelDescriptor('restore', ['selector', 'dryRun', 'types', 'syncDeps', 'password'], true),
   panelDescriptor('setAuto', ['hours']),
   panelDescriptor('githubStatus', []),
   panelDescriptor('githubSyncNow', [], true),
@@ -445,6 +639,37 @@ const PANEL_INVOCATIONS = Object.freeze([
   panelDescriptor('setGithubToken', ['token']),
   panelDescriptor('checkUpdate', [], true),
   panelDescriptor('update', [], true),
+  panelDescriptor('exportConfig', ['options'], true),
+  panelDescriptor('importPreview', ['options'], true),
+  panelDescriptor('importApply', ['options'], true),
+  panelDescriptor('syncStatus', []),
+  panelDescriptor('syncNow', ['channel'], true),
+  panelDescriptor('setSyncChannel', ['channel', 'config']),
+  panelDescriptor('removeSyncChannel', ['channel']),
+  panelDescriptor('lockStatus', []),
+  panelDescriptor('reclaimLock', ['force']),
+  panelDescriptor('diskUsage', [], true),
+  panelDescriptor('cleanup', ['scope'], true),
+  panelDescriptor('setWeekly', ['schedules']),
+  panelDescriptor('about', []),
+  panelDescriptor('profilesList', []),
+  panelDescriptor('profileCreate', ['name']),
+  panelDescriptor('profileRename', ['old', 'new']),
+  panelDescriptor('profileDelete', ['name']),
+  panelDescriptor('profileLaunch', ['name']),
+  panelDescriptor('profileStop', ['name']),
+  panelDescriptor('marketList', [], true),
+  panelDescriptor('marketSearch', ['query'], true),
+  panelDescriptor('marketInstall', ['options'], true),
+  panelDescriptor('foreignSources', []),
+  panelDescriptor('foreignPreview', ['options'], true),
+  panelDescriptor('foreignImport', ['options'], true),
+  panelDescriptor('sessionRewindList', []),
+  panelDescriptor('sessionRewindPreview', ['session', 'seq'], true),
+  panelDescriptor('sessionRewindApply', ['options'], true),
+  panelDescriptor('chatSources', []),
+  panelDescriptor('chatPreview', ['options'], true),
+  panelDescriptor('chatApply', ['options'], true),
 ]);
 
 /**
@@ -464,9 +689,9 @@ class BackupPanelService extends TypertRemoteService {
     return this.ops.status();
   }
 
-  /** 立即备份（types 非空时分类型子集备份）。 */
-  backup(keep, types, signal) {
-    return this.ops.backup(keep, types, signal);
+  /** 立即备份（types 非空时分类型子集备份；password 非空时加密备份——口令内存态，绝不落盘）。 */
+  backup(keep, types, password, signal) {
+    return this.ops.backup(keep, types, password, signal);
   }
 
   /** 校验（selector=前缀|all|latest）。 */
@@ -474,9 +699,9 @@ class BackupPanelService extends TypertRemoteService {
     return this.ops.verify(selector, signal);
   }
 
-  /** 恢复（dryRun 仅预览；types 非空时分类型 merge 恢复；syncDeps 恢复后重装 profile 依赖）。 */
-  restore(selector, dryRun, types, syncDeps, signal) {
-    return this.ops.restore(selector, dryRun, types, syncDeps, signal);
+  /** 恢复（dryRun 仅预览；types 非空时分类型 merge 恢复；syncDeps 恢复后重装 profile 依赖；password 用于加密归档——内存态）。 */
+  restore(selector, dryRun, types, syncDeps, password, signal) {
+    return this.ops.restore(selector, dryRun, types, syncDeps, password, signal);
   }
 
   /** 设置自动备份（0=关闭）。 */
@@ -538,6 +763,161 @@ class BackupPanelService extends TypertRemoteService {
   update(signal) {
     return this.ops.update(signal);
   }
+
+  /** 导出配置为单文件 ZIP（options: { password?, includeCredentials?, sections? }）。 */
+  exportConfig(options, signal) {
+    return this.ops.exportConfig(options, signal);
+  }
+
+  /** 导入预览（dry-run）：options: { sourcePath, password? }。 */
+  importPreview(options, signal) {
+    return this.ops.importPreview(options, signal);
+  }
+
+  /** 导入应用：options: { sourcePath, password?, sections?, decisions?, remap? }。 */
+  importApply(options, signal) {
+    return this.ops.importApply(options, signal);
+  }
+
+  /** 多通道同步状态（含 github/webdav/s3/gist，凭据脱敏）。 */
+  syncStatus() {
+    return this.ops.syncStatus();
+  }
+
+  /** 立即推送到指定通道（github/webdav/s3/gist）。 */
+  syncNow(channel, signal) {
+    return this.ops.syncNow(channel, signal);
+  }
+
+  /** 设置同步通道配置（config 含凭据，只存本机 0600，不回显明文）。 */
+  setSyncChannel(channel, config) {
+    return this.ops.setSyncChannel(channel, config);
+  }
+
+  /** 清除同步通道。 */
+  removeSyncChannel(channel) {
+    return this.ops.removeSyncChannel(channel);
+  }
+
+  /** 操作锁状态。 */
+  lockStatus() {
+    return this.ops.lockStatus();
+  }
+
+  /** 回收操作锁（force=true 强删活锁，慎用）。 */
+  reclaimLock(force) {
+    return this.ops.reclaimLock(force);
+  }
+
+  /** 磁盘占用报告。 */
+  diskUsage(signal) {
+    return this.ops.diskUsage(signal);
+  }
+
+  /** 分级清理（scope='cache' 只清可再生缓存；'expired' 再加过期备份，快照/同步永不删）。 */
+  cleanup(scope, signal) {
+    return this.ops.cleanup(scope, signal);
+  }
+
+  /** 设置每周调度：[{ day: 1-7, time: 'HH:MM' }]；空数组关闭。 */
+  setWeekly(schedules) {
+    return this.ops.setWeekly(schedules);
+  }
+
+  /** About 环境信息（版本/平台/路径，脱敏，供 About 面板 + 一键复制）。 */
+  about() {
+    return this.ops.about();
+  }
+
+  /** 列出 profiles（app-owned 标注只读）。 */
+  profilesList() {
+    return this.ops.profilesList();
+  }
+
+  /** 从内置模板创建 profile。 */
+  profileCreate(name) {
+    return this.ops.profileCreate(name);
+  }
+
+  /** 重命名 profile（内置只读，目标已存在拒绝）。 */
+  profileRename(oldName, newName) {
+    return this.ops.profileRename(oldName, newName);
+  }
+
+  /** 硬删 profile（内置只读，二次确认语义由客户端承担）。 */
+  profileDelete(name) {
+    return this.ops.profileDelete(name);
+  }
+
+  /** 启动独立 profile 实例（detached+unref）。 */
+  profileLaunch(name) {
+    return this.ops.profileLaunch(name);
+  }
+
+  /** 停止独立 profile 实例。 */
+  profileStop(name) {
+    return this.ops.profileStop(name);
+  }
+
+  /** 配置市场：列出市场条目（只读；marketUrl 索引，不执行任何 bundle 代码）。 */
+  marketList(signal) {
+    return this.ops.marketList(signal);
+  }
+
+  /** 配置市场：搜索条目（只读，本地过滤 name/desc）。 */
+  marketSearch(query, signal) {
+    return this.ops.marketSearch(query, signal);
+  }
+
+  /** 配置市场：安装条目（默认 dry-run；confirm:true 才写，走 importPreview/importApply + 快照回滚）。 */
+  marketInstall(options, signal) {
+    return this.ops.marketInstall(options, signal);
+  }
+
+  /** 外部 agent：列出本机可导入来源（只读检测）。 */
+  foreignSources() {
+    return this.ops.foreignSources();
+  }
+
+  /** 外部 agent：预览导入计划（只读，不写 ~/.dsh）。 */
+  foreignPreview(options, signal) {
+    return this.ops.foreignPreview(options, signal);
+  }
+
+  /** 外部 agent：导入（默认 dry-run；confirm:true 才写，走 importPreview/importApply）。 */
+  foreignImport(options, signal) {
+    return this.ops.foreignImport(options, signal);
+  }
+
+  /** 会话 Rewind：列出可回退会话（只读）。 */
+  sessionRewindList(signal) {
+    return this.ops.sessionRewindList(signal);
+  }
+
+  /** 会话 Rewind：预览分叉计划（只读，不写盘）。 */
+  sessionRewindPreview(session, seq, signal) {
+    return this.ops.sessionRewindPreview(session, seq, signal);
+  }
+
+  /** 会话 Rewind：执行分叉（默认 dry-run；confirm:true 才写；原会话永不修改）。 */
+  sessionRewindApply(options, signal) {
+    return this.ops.sessionRewindApply(options, signal);
+  }
+
+  /** 外部聊天记录：列出可导入来源（v1 仅 Claude Code）。 */
+  chatSources() {
+    return this.ops.chatSources();
+  }
+
+  /** 外部聊天记录：预览导入计划（只读）。 */
+  chatPreview(options, signal) {
+    return this.ops.chatPreview(options, signal);
+  }
+
+  /** 外部聊天记录：导入为新会话（默认 dry-run；confirm:true 才写）。 */
+  chatApply(options, signal) {
+    return this.ops.chatApply(options, signal);
+  }
 }
 
 export function apply(ctx, pluginConfig) {
@@ -770,7 +1150,16 @@ export function apply(ctx, pluginConfig) {
     const raw = typeof cfg.destination === 'string' && cfg.destination.trim()
       ? cfg.destination.trim()
       : DEFAULTS.destination;
-    const root = raw.startsWith('~') ? `${home}${raw.slice(1)}` : toFwd(raw);
+    const expandHome = (p) => (p.startsWith('~') ? `${home}${p.slice(1)}` : toFwd(p));
+    let root = expandHome(raw);
+    // 0.14.0 改了默认目录名；还没完成迁移（或迁移失败）时继续用老默认目录，
+    // 避免用户升级后看到"备份全没了"。用户显式配置过的目录不走这段兜底。
+    if (raw === DEFAULTS.destination && !pathExists(root)) {
+      for (const legacyRaw of LEGACY_DEFAULT_DESTINATIONS) {
+        const legacyRoot = expandHome(legacyRaw);
+        if (pathExists(legacyRoot)) { root = legacyRoot; break; }
+      }
+    }
     return { home, dshHome: toFwd(dshHome), root };
   }
 
@@ -839,6 +1228,33 @@ export function apply(ctx, pluginConfig) {
     }
   }
 
+  /**
+   * About 环境信息（P4）：只含版本/平台/路径，**绝不含凭据/密钥/home 明文**。
+   * home 不单独返回；pluginDir 若位于 home 下则把 home 前缀脱敏成 `~`。
+   * dshVersion 用 detectHostTrain()（测正在跑的宿主，而非 profile 里 hoisted
+   * 的 peer 包）；取不到一律 'unknown'，绝不让 About 面板因环境探测失败而崩。
+   */
+  async function aboutInfo() {
+    let dshVersion = 'unknown';
+    try { dshVersion = detectHostTrain() || 'unknown'; } catch { dshVersion = 'unknown'; }
+    let pluginDir = 'unknown';
+    try {
+      pluginDir = (fileURLToPath(new URL('..', import.meta.url)) || '').replace(/\/+$/, '') || '/';
+    } catch { pluginDir = 'unknown'; }
+    let home = null;
+    try { home = paths().home; } catch { home = null; }
+    // 脱敏：pluginDir 绝对路径若含 home 明文，替换成 ~ 前缀
+    const maskHome = (p) => (home && typeof p === 'string' && p.startsWith(home)) ? `~${p.slice(home.length)}` : p;
+    return {
+      version: SELF_META.version,
+      dshVersion,
+      platform: process.platform,
+      node: process.version,
+      profile: 'web', // Web 面板 profile（launchEnvironment 无独立 profile 键时按默认）
+      pluginDir: maskHome(pluginDir),
+    };
+  }
+
   /**
    * 一键更新（B）：先拍升级前快照（未过期的退路），再走官方 `dsh plugin
    * --profile <p> update --latest <pkg>`（pnpm 语义——profile 是 pnpm 项目，
@@ -903,7 +1319,7 @@ export function apply(ctx, pluginConfig) {
       updated: true,
       current: after || chk.latest,
       latest: chk.latest,
-      summary: `已更新到 ${after || chk.latest}。${snap ? `\n更新前已留升级前快照 ${snap}（想回退：/backup restore ${snap}）。` : '\n更新前快照未生成（不影响本次更新）。'}\n请重启 dsh web 使新版本生效。`,
+      summary: `已更新到 ${after || chk.latest}。${snap ? `\n更新前已留升级前快照 ${snap}（想回退：/backup restore ${snap}）。` : '\n更新前快照未生成（不影响本次更新）。'}\n请重启 dsh web 使新版本生效（宿主 0.2.1-rc.1+ 开启热重载时部分插件可免重启，面板没变化就重启）。`,
     };
   }
 
@@ -1074,7 +1490,7 @@ export function apply(ctx, pluginConfig) {
       return;
     }
     const names = dirents
-      .filter((d) => d.name.startsWith(prefix) && (d.name.endsWith('.tar.gz') || d.name.endsWith('.sha256') || d.name.endsWith('.meta.json') || d.name.endsWith('.redacted.json')))
+      .filter((d) => d.name.startsWith(prefix) && (d.name.endsWith('.tar.gz') || d.name.endsWith('.sha256') || d.name.endsWith('.meta.json') || d.name.endsWith('.redacted.json') || d.name.endsWith('.encrypted.json')))
       .map((d) => d.name)
       .sort()
       .reverse();
@@ -1096,11 +1512,11 @@ export function apply(ctx, pluginConfig) {
 
   /** 归档伴生边车集：轮换、删除与 GitHub 同步对同一归档统一处理的文件列表。 */
   function sidecarsFor(name) {
-    return [name, `${name}.sha256`, `${name}.meta.json`, `${name}.redacted.json`];
+    return [name, `${name}.sha256`, `${name}.meta.json`, `${name}.redacted.json`, `${name}.encrypted.json`];
   }
 
-  /** 内部快照前缀（恢复前 / 升级前）：不进用户列表、不参与轮换与 keep 配额。 */
-  const SNAPSHOT_PREFIXES = Object.freeze(['dsh-pre-restore-', 'dsh-pre-upgrade-']);
+  /** 内部快照前缀（恢复前 / 升级前 / 导入前）：不进用户列表、不参与轮换与 keep 配额。 */
+  const SNAPSHOT_PREFIXES = Object.freeze(['dsh-pre-restore-', 'dsh-pre-upgrade-', IMPORT_SNAPSHOT_PREFIX]);
 
   async function listBackups() {
     const { root } = paths();
@@ -1129,7 +1545,9 @@ export function apply(ctx, pluginConfig) {
         // 归档在列表与 stat 之间被删除（轮换/删除竞态）——大小显示为未知而非报错
         size = undefined;
       }
-      backups.push({ name: d.name, size });
+      // 加密归档带 .encrypted.json 边车：列表标记 🔒，供 CLI/面板/工具展示。
+      const encrypted = await existsStat(`${root}/${d.name}.encrypted.json`);
+      backups.push({ name: d.name, size, encrypted });
     }
     return backups.sort((a, b) => (a.name < b.name ? 1 : a.name > b.name ? -1 : 0));
   }
@@ -1155,6 +1573,12 @@ export function apply(ctx, pluginConfig) {
     await writeFile(p, content, 'utf8');
   }
 
+  /** 二进制写盘（密文归档、解密的临时 tar.gz 等——绝不能用 utf8 写，会毁掉字节）。 */
+  async function writeBinary(p, buf) {
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, buf);
+  }
+
   // 校验和：POSIX 优先 sha256sum（macOS 回退 shasum）流式计算；
   // 都不可用时（Windows 典型）回退 node:crypto 流式哈希。
   // #103：旧实现是 readFile 整包进内存 + 同步 update，且 >256MB 直接抛错——
@@ -1259,7 +1683,38 @@ export function apply(ctx, pluginConfig) {
     return backups.sort((a, b) => (a.name < b.name ? 1 : a.name > b.name ? -1 : 0));
   }
 
+  // ---------- 操作锁（跨进程互斥 + 死锁回收，P3） ----------
+  // 备份/恢复/导入/同步/doctor 这类重活会动 ~/.dsh 与备份目录（vault 刷新、
+  // .dsh 挪旁、归档轮换），多实例/多 profile 并发会互相踩。锁文件在备份目录根
+  // .oplock.json，记 pid+token+心跳；死锁（pid 已死）下次自动回收，活锁绝不误踢。
+  // 同进程重入（restore 内部的快照 doBackup 等）经 heldLock 内存标记直接放行。
+  let heldLock = null;
+  let heartbeatTimer = null;
+
+  async function withOperationLock(operation, fn) {
+    if (heldLock) return fn(); // 同进程重入：本进程已持锁，直接跑
+    const { root } = paths();
+    const lockPath = `${root}/${LOCK_FILE}`;
+    const r = await acquireLock(lockPath, operation);
+    if (!r.acquired) {
+      throw new Error(`另一操作正在进行（${r.heldBy?.operation ?? '未知'}，pid=${r.heldBy?.pid}）——请稍后重试；若确认是残留死锁可用 /backup lock reclaim 回收`);
+    }
+    heldLock = r.lock;
+    heartbeatTimer = setInterval(() => { heartbeatLock(lockPath, r.lock.token).catch(() => {}); }, LOCK_HEARTBEAT_MS);
+    try {
+      return await fn();
+    } finally {
+      if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+      await releaseLock(lockPath, r.lock.token).catch(() => {});
+      heldLock = null;
+    }
+  }
+
   async function doBackup(keep, signal, opts = {}) {
+    return withOperationLock('backup', () => doBackupInner(keep, signal, opts));
+  }
+
+  async function doBackupInner(keep, signal, opts = {}) {
     const { home, dshHome, root } = paths();
     const keepN = keep && keep > 0 ? Math.floor(keep) : defaultKeep();
     // 状态文件先写：writeText 会自动创建备份目录，替代 mkdir -p（Windows 无 mkdir.exe）。
@@ -1315,6 +1770,20 @@ export function apply(ctx, pluginConfig) {
       throw err;
     }
 
+    // 可选口令加密（P2）：口令只经内存传入（面板 RPC 的 backup({password})），
+    // **绝不写 settings.yaml、绝不进日志、绝不写盘**。密文原地覆盖归档本身，
+    // nonce/tag/salt/kdf 参数进 .encrypted.json 边车；下方 sha256 算的是**密文**，
+    // 故 verify 无需口令即可做完整性校验。加密前 tar.gz 已是完整明文，此处原地
+    // 替换——旧版插件遇到它只会 tar 解不开，边车只增不改、不误删不误读。
+    let encrypted = false;
+    if (typeof opts?.password === 'string' && opts.password) {
+      const plain = await readFile(out);
+      const enc = await encryptBuffer(plain, opts.password);
+      await writeBinary(out, enc.ciphertext);
+      await writeOwned(`${out}.encrypted.json`, `${JSON.stringify(enc.sidecar)}\n`);
+      encrypted = true;
+    }
+
     const shaText = await sha256File(out, home, signal);
     await writeOwned(`${out}.sha256`, `${shaText}  ${out}\n`);
     // types 归档不写 .redacted.json：凭据类明文已在归档内（不靠 vault 还原），
@@ -1326,7 +1795,7 @@ export function apply(ctx, pluginConfig) {
     // quarantined 记录体检隔离、未入档的损坏会话文件。
     // meta 记 types（分类型归档标识；缺省=全量，旧版/旧归档照读不误）；types
     // 归档 redacted 记 0（未脱敏），hasCredentials 供 githubSync 跳过上云判断。
-    await writeOwned(`${out}.meta.json`, `${JSON.stringify({ host: hostname(), home, dshHome, createdAt: new Date().toISOString(), redacted: isTyped ? 0 : redacted.length, ...(isTyped ? { types, hasCredentials } : {}), ...(quarantined.length ? { quarantined } : {}) })}\n`);
+    await writeOwned(`${out}.meta.json`, `${JSON.stringify({ host: hostname(), home, dshHome, createdAt: new Date().toISOString(), redacted: isTyped ? 0 : redacted.length, ...(isTyped ? { types, hasCredentials } : {}), ...(encrypted ? { encrypted: true } : {}), ...(quarantined.length ? { quarantined } : {}) })}\n`);
 
     // 救援通道：每次备份把进程外恢复工具落进备份目录——宿主起不来时
     // `node rescue.mjs`（或双击启动器）仍可恢复（DSH 依赖 Node，宿主死了
@@ -1334,6 +1803,8 @@ export function apply(ctx, pluginConfig) {
     try {
       await copyFile(new URL('../rescue/rescue.mjs', import.meta.url), `${root}/rescue.mjs`);
       await writeOwned(`${root}/RESCUE.txt`, RESCUE_TXT);
+      // 人话版使用说明：用户第一次打开备份目录时最该看到的东西（0.14.0）
+      await writeOwned(`${root}/${GUIDE_FILE}`, GUIDE_TXT);
       const launcher = RESCUE_LAUNCHERS[process.platform];
       if (launcher) {
         const [name, content] = launcher;
@@ -1346,10 +1817,10 @@ export function apply(ctx, pluginConfig) {
     } catch { /* 老安装缺文件等场景静默跳过 */ }
 
     // 安全：备份含明文凭据（.credentials.yaml / qq-bridge/config.json），收紧为仅本人可读写。
-    // Windows 无 chmod，用户目录 ACL 默认私有。
+    // Windows 无 chmod，用户目录 ACL 默认私有。加密边车同权（无明文，但统一收紧）。
     if (!IS_WIN) {
       const chmod = await ctx.subprocess.resolveExecutable('chmod');
-      await spawnRun([chmod, '600', out, `${out}.sha256`], home, signal);
+      await spawnRun([chmod, '600', out, `${out}.sha256`, ...(encrypted ? [`${out}.encrypted.json`] : [])], home, signal);
     }
 
     // 分级轮换：keep 窗口之外的尾巴不再一刀切全删——保留最近 7 个不同自然日
@@ -1362,9 +1833,16 @@ export function apply(ctx, pluginConfig) {
     // keep 窗口外，轮换会删掉马上要解压的文件（review P1-3）。
     const rotateBase = isTyped ? await listTypedBackups() : await listBackups();
     const rotateTail = rotateBase.slice(keepN);
+    // GFS 保留（P3）：在既有日/周分层之上，再按 gfsMonthly/gfsYearly 各留月/年
+    // 首份。缺省 0 = 完全等价旧行为（只 keep N + 日/周分层）。
+    const gfsCfg = resolvedConfig();
+    const gfsProtect = gfsProtectedSet(rotateTail, rotateBase[0]?.name, {
+      monthly: Number(gfsCfg.gfsMonthly) > 0 ? Math.floor(Number(gfsCfg.gfsMonthly)) : 0,
+      yearly: Number(gfsCfg.gfsYearly) > 0 ? Math.floor(Number(gfsCfg.gfsYearly)) : 0,
+    });
     const rotateStale = opts.skipRotate
       ? []
-      : rotateTail.filter((b) => !tierProtectedSet(rotateTail, rotateBase[0]?.name).has(b.name)).map((b) => b.name);
+      : rotateTail.filter((b) => !tierProtectedSet(rotateTail, rotateBase[0]?.name).has(b.name) && !gfsProtect.has(b.name)).map((b) => b.name);
     if (rotateStale.length) await removeFiles(rotateStale.flatMap((n) => sidecarsFor(n)), root, signal);
 
     // GitHub 同步（失败不回滚备份；状态记入 auto.json）
@@ -1385,7 +1863,7 @@ export function apply(ctx, pluginConfig) {
       await saveAutoState();
     }
 
-    return { path: out, name, sha: shaText, total: rotateBase.length, stale: rotateStale.length, keep: keepN, quarantined, sync, ...(isTyped ? { types, hasCredentials } : {}) };
+    return { path: out, name, sha: shaText, total: rotateBase.length, stale: rotateStale.length, keep: keepN, quarantined, sync, ...(encrypted ? { encrypted: true } : {}), ...(isTyped ? { types, hasCredentials } : {}) };
   }
 
   /** 备份回执的隔离提示行：体检发现坏会话文件未入档时如实告知 + 指路修复。 */
@@ -1659,8 +2137,9 @@ export function apply(ctx, pluginConfig) {
         continue;
       }
       await rename(staging, `${root}/${name}`);
-      // 边车随归档转正（缺失的可选边车跳过）
-      for (const side of [`${name}.sha256`, `${name}.meta.json`, `${name}.redacted.json`]) {
+      // 边车随归档转正（缺失的可选边车跳过）；.encrypted.json 一并带回来，
+      // 否则加密归档拉回后无法解密（P3 补）。
+      for (const side of [`${name}.sha256`, `${name}.meta.json`, `${name}.redacted.json`, `${name}.encrypted.json`]) {
         await copyFile(`${syncDir}/${side}`, `${root}/${side}`).catch((err) => {
           if (err && err.code === 'ENOENT') return;
           throw err;
@@ -1671,6 +2150,189 @@ export function apply(ctx, pluginConfig) {
     return { pulled, corrupt, total: wanted.length };
   }
 
+  // ---------- 多通道同步（WebDAV / S3 兼容 / GitHub Gist，P3） ----------
+  // 与现有 GitHub 同步并列：每通道独立配置，持久化到备份目录根 sync.json（0600），
+  // 凭据（password/secretKey/token）只存本机、不进归档、不进日志、状态回显一律脱敏。
+  // 同步产物与 GitHub 一致：全量归档 + .sha256 + .meta.json + .redacted.json +
+  // .encrypted.json 的可移植集合。webdav/s3/gist 本轮只做**推送**（pull 仍走 GitHub）。
+  let syncChannels = {};
+  const SYNC_CHANNEL_TYPES = new Set(['webdav', 's3', 'gist']);
+
+  /** 校验并归一化通道配置；非法返回原因，合法返回归一化对象。 */
+  function normalizeSyncChannel(channel, config) {
+    if (!SYNC_CHANNEL_TYPES.has(channel)) return { error: `不支持的通道类型 ${channel}（支持 webdav/s3/gist）` };
+    const c = config && typeof config === 'object' ? config : {};
+    if (channel === 'webdav') {
+      const url = typeof c.url === 'string' ? c.url.trim() : '';
+      if (!/^https?:\/\//i.test(url)) return { error: 'WebDAV 需要 http(s):// 开头的 url' };
+      return { value: { type: 'webdav', url, username: typeof c.username === 'string' ? c.username : '', password: typeof c.password === 'string' ? c.password : '' } };
+    }
+    if (channel === 's3') {
+      const endpoint = typeof c.endpoint === 'string' ? c.endpoint.trim() : '';
+      if (!/^https?:\/\//i.test(endpoint)) return { error: 'S3 需要 http(s):// 开头的 endpoint' };
+      const region = typeof c.region === 'string' && c.region.trim() ? c.region.trim() : 'us-east-1';
+      const bucket = typeof c.bucket === 'string' ? c.bucket.trim() : '';
+      if (!bucket) return { error: 'S3 需要 bucket 名' };
+      const accessKey = typeof c.accessKey === 'string' ? c.accessKey.trim() : '';
+      const secretKey = typeof c.secretKey === 'string' ? c.secretKey : '';
+      if (!accessKey || !secretKey) return { error: 'S3 需要 accessKey 与 secretKey' };
+      return { value: { type: 's3', endpoint, region, bucket, accessKey, secretKey, pathPrefix: typeof c.pathPrefix === 'string' ? c.pathPrefix.replace(/^\/+|\/+$/g, '') : '', pathStyle: c.pathStyle !== false } };
+    }
+    if (channel === 'gist') {
+      const token = typeof c.token === 'string' ? c.token.trim() : '';
+      if (!/^[A-Za-z0-9_-]{20,255}$/.test(token)) return { error: 'Gist 需要合法 GitHub token（ghp_…/github_pat_…/经典 40 位）' };
+      return { value: { type: 'gist', token, gistId: typeof c.gistId === 'string' ? c.gistId.trim() : '' } };
+    }
+    return { error: `不支持的通道类型 ${channel}` };
+  }
+
+  /** 状态回显用脱敏视图：凭据只给「已配置/未配置」，绝不含明文。 */
+  function redactSyncChannel(channel, ch) {
+    if (!ch) return { channel, type: channel, configured: false };
+    const out = { channel, type: ch.type, configured: true, lastPush: ch.lastPush ?? null, lastError: ch.lastError ?? null };
+    if (ch.type === 'webdav') out.url = ch.url; out.username = ch.username; out.passwordSet = Boolean(ch.password);
+    if (ch.type === 's3') { out.endpoint = ch.endpoint; out.region = ch.region; out.bucket = ch.bucket; out.pathPrefix = ch.pathPrefix || ''; out.accessKey = ch.accessKey; out.secretKeySet = Boolean(ch.secretKey); out.pathStyle = ch.pathStyle !== false; }
+    if (ch.type === 'gist') { out.gistId = ch.gistId || ''; out.tokenSet = Boolean(ch.token); }
+    return out;
+  }
+
+  async function loadSyncChannels() {
+    const { root } = paths();
+    try {
+      const parsed = JSON.parse(await readFile(`${root}/${SYNC_CONFIG_FILE}`, 'utf8'));
+      const disk = parsed && typeof parsed === 'object' ? parsed : {};
+      // 合并而非整对象覆盖：boot 钩子加载若与面板 setSyncChannel 并发，后者可能
+      // 已先把某通道写进内存并落盘，此处整对象覆盖会把刚 set 的通道清成空（真实
+      // 竞态）。只填充内存里还没有的通道；已有通道一律保留。显式 set/remove 才落盘。
+      for (const [k, v] of Object.entries(disk)) {
+        if (!(k in syncChannels)) syncChannels[k] = v;
+      }
+    } catch (err) {
+      // ENOENT（首次使用）或读失败都保持内存现状，不覆盖——宁可少回填一次，
+      // 也不把并发写入的内存态清掉。
+      if (err && err.code !== 'ENOENT') console.warn(`[dsh-backup] 同步通道配置读取失败（不影响备份）: ${String(err && err.message ? err.message : err)}`);
+    }
+    return syncChannels;
+  }
+
+  async function saveSyncChannels() {
+    const { root } = paths();
+    await mkdir(root, { recursive: true });
+    const target = `${root}/${SYNC_CONFIG_FILE}`;
+    const tmp = `${target}.${randomUUID()}.tmp`;
+    try {
+      await writeOwned(tmp, `${JSON.stringify(syncChannels)}\n`);
+      await rename(tmp, target);
+    } catch (err) {
+      await rm(tmp, { force: true }).catch(() => {});
+      throw err;
+    }
+    if (!IS_WIN) await chmod(target, 0o600).catch(() => {});
+  }
+
+  /** 全部通道（含 github）的脱敏状态视图。 */
+  async function listSyncChannels() {
+    const cfg = githubConfig();
+    return {
+      github: { channel: 'github', type: 'github', configured: Boolean(cfg), repo: cfg ? cfg.repo : null, tokenSet: hasGithubToken(), lastPush: githubState.lastPush, lastError: githubState.lastError },
+      webdav: redactSyncChannel('webdav', syncChannels.webdav),
+      s3: redactSyncChannel('s3', syncChannels.s3),
+      gist: redactSyncChannel('gist', syncChannels.gist),
+    };
+  }
+
+  async function setSyncChannel(channel, config) {
+    const n = normalizeSyncChannel(channel, config);
+    if (n.error) return { ok: false, summary: n.error };
+    syncChannels[channel] = { ...n.value, lastPush: syncChannels[channel]?.lastPush ?? null, lastError: null };
+    await saveSyncChannels();
+    return { ok: true, summary: `${channel} 同步通道已保存（凭据仅存本机备份目录 0600，不进归档不进日志）`, channel: redactSyncChannel(channel, syncChannels[channel]) };
+  }
+
+  async function removeSyncChannel(channel) {
+    delete syncChannels[channel];
+    await saveSyncChannels();
+    return { ok: true, summary: `${channel} 同步通道已清除` };
+  }
+
+  /** 组装同步文件清单（全量归档 + 边车），返回已存在的文件绝对路径列表。 */
+  async function syncFileSet() {
+    const { root } = paths();
+    const out = [];
+    for (const b of await listBackups()) {
+      for (const f of sidecarsFor(b.name)) {
+        if (await existsStat(`${root}/${f}`)) out.push(f);
+      }
+    }
+    return out;
+  }
+
+  /**
+   * 推送到指定通道。github 复用现有 githubSync（含拉取语义）；webdav/s3/gist
+   * 走 lib/sync-channels.js 的传输层，只推送。返回 { pushed, count, at, tooBig,
+   * error?, skipped?, gistUrl? }，凭据绝不进返回。
+   */
+  async function syncNow(channel, signal) {
+    if (channel === 'github') return githubSync(signal);
+    const ch = syncChannels[channel];
+    if (!ch) return { error: `未配置同步通道 ${channel}（/backup sync ${channel} set … 或面板配置）` };
+    const { root } = paths();
+    const set = await syncFileSet();
+    const tooBig = [];
+    const max = ch.type === 'gist' ? GIST_MAX_BYTES : SYNC_MAX_BYTES;
+    const at = new Date().toISOString();
+    try {
+      if (ch.type === 'webdav' || ch.type === 's3') {
+        let count = 0;
+        for (const f of set) {
+          if (signal?.aborted) throw new Error('操作已取消');
+          const p = `${root}/${f}`;
+          const st = await fsStat(p).then((s) => s, () => null);
+          if (!st) continue;
+          if (st.size > max) { tooBig.push(f); continue; }
+          const body = await readFile(p);
+          if (ch.type === 'webdav') {
+            await webdavPut({ url: ch.url, username: ch.username, password: ch.password, key: f, body, signal });
+          } else {
+            const key = [ch.pathPrefix, f].filter(Boolean).join('/');
+            await s3Put({ endpoint: ch.endpoint, region: ch.region, bucket: ch.bucket, key, body, accessKey: ch.accessKey, secretKey: ch.secretKey, pathStyle: ch.pathStyle !== false, signal });
+          }
+          count += 1;
+        }
+        syncChannels[channel] = { ...ch, lastPush: at, lastError: null };
+        await saveSyncChannels();
+        return { pushed: count > 0, count, at, tooBig };
+      }
+      if (ch.type === 'gist') {
+        const files = {};
+        for (const f of set) {
+          if (signal?.aborted) throw new Error('操作已取消');
+          const p = `${root}/${f}`;
+          const st = await fsStat(p).then((s) => s, () => null);
+          if (!st) continue;
+          if (st.size > max) { tooBig.push(f); continue; }
+          const buf = await readFile(p);
+          files[f] = { content: gistContent(buf, { binary: f.endsWith('.tar.gz') }) };
+        }
+        const g = await gistSync({ token: ch.token, gistId: ch.gistId || null, files, description: 'dsh-backup sync', signal });
+        if (g.gistId && g.gistId !== ch.gistId) {
+          syncChannels[channel] = { ...ch, gistId: g.gistId, lastPush: at, lastError: null };
+          await saveSyncChannels();
+        } else {
+          syncChannels[channel] = { ...ch, lastPush: at, lastError: null };
+          await saveSyncChannels();
+        }
+        return { pushed: Object.keys(files).length > 0, count: Object.keys(files).length, at, tooBig, gistUrl: g.htmlUrl };
+      }
+      return { error: `未知通道类型 ${ch.type}` };
+    } catch (err) {
+      const message = String(err && err.message ? err.message : err);
+      syncChannels[channel] = { ...ch, lastError: message };
+      await saveSyncChannels().catch(() => {});
+      return { error: message };
+    }
+  }
+
   // ---------- Web 下载路由（仅 loopback，附件形式） ----------
   async function handleDownload(req, res) {
     try {
@@ -1682,7 +2344,9 @@ export function apply(ctx, pluginConfig) {
       }
       const pathname = new URL(req.url || '', 'http://x').pathname;
       const name = decodeURIComponent(pathname.slice(DOWNLOAD_PREFIX.length).replace(/^\//, ''));
-      if (!/^dsh-[A-Za-z0-9._-]+\.tar\.gz$/.test(name)) {
+      const isTarGz = /^dsh-[A-Za-z0-9._-]+\.tar\.gz$/.test(name);
+      const isZip = /^dsh-config-[A-Za-z0-9._-]+\.zip$/.test(name);
+      if (!isTarGz && !isZip) {
         res.writeHead(400);
         res.end('bad name');
         return;
@@ -1691,7 +2355,7 @@ export function apply(ctx, pluginConfig) {
       const abs = `${root}/${name}`;
       await fsStat(abs);
       res.writeHead(200, {
-        'Content-Type': 'application/gzip',
+        'Content-Type': isZip ? 'application/zip' : 'application/gzip',
         'Content-Disposition': `attachment; filename="${name}"`,
       });
       createReadStream(abs).on('error', () => { res.destroy(); }).pipe(res);
@@ -1703,6 +2367,53 @@ export function apply(ctx, pluginConfig) {
   }
 
   // ---------- 校验与恢复 ----------
+  /**
+   * 判断归档是否加密：优先看 .encrypted.json 边车（实际密文参数所在），
+   * 再回退 meta.encrypted（老边车缺位但 meta 有标记时的兜底）。只增不改：
+   * 边车存在即加密，不存在则不是——不把 meta 与边车不一致当作可恢复状态。
+   */
+  async function isArchiveEncrypted(archiveName) {
+    const { root } = paths();
+    if (await existsStat(`${root}/${archiveName}.encrypted.json`)) return true;
+    try {
+      const meta = JSON.parse(await readFile(`${root}/${archiveName}.meta.json`, 'utf8'));
+      // 用真值判定而非严格 === true：未来若 meta.encrypted 升级为版本号（如 2），
+      // 真值仍会把归档判为「加密」，交给 decryptBuffer 的版本门安全拒绝，而不是
+      // 静默当明文 tar 去啃密文。false/缺省仍判未加密。
+      return Boolean(meta && meta.encrypted);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 把加密归档解密成备份目录内的一份临时 tar.gz，返回 { name, cleanup }。
+   * 临时文件用相对名（cwd=备份目录），规避 Windows GNU tar 盘符冒号问题；
+   * 解密失败（口令错/边车坏）抛人话报错，调用方直接展示。
+   */
+  async function decryptArchiveFile(archiveName, password, signal) {
+    const { root } = paths();
+    if (signal?.aborted) throw new Error('操作已取消');
+    if (typeof password !== 'string' || !password) {
+      throw new Error('这份备份已加密，恢复需要口令（口令只经面板 RPC 传入、内存态，命令行暂不支持输入口令）');
+    }
+    let sidecar;
+    try {
+      sidecar = JSON.parse(await readFile(`${root}/${archiveName}.encrypted.json`, 'utf8'));
+    } catch (err) {
+      // meta.encrypted 标记了加密但边车缺失：这是不一致状态，拒绝而非猜着解
+      throw new Error(`加密边车（.encrypted.json）缺失或损坏，无法解密——请核对备份是否完整（技术细节: ${snippet(String(err && err.message ? err.message : err), 80)}）`);
+    }
+    const ciphertext = await readFile(`${root}/${archiveName}`);
+    const plain = await decryptBuffer(ciphertext, sidecar, password);
+    // 隐藏名 `.decrypt-<时间戳>.tar.gz`：listBackups 要求 `dsh-` 前缀，隐藏点开头
+    // 的临时文件绝不进用户列表/轮换；位于备份目录内、相对名传 tar，规避 Windows
+    // GNU tar 盘符冒号问题。finally 里必清理（明文 tar.gz 不能遗留）。
+    const tmpName = `.decrypt-${stampNow()}.tar.gz`;
+    await writeBinary(`${root}/${tmpName}`, plain);
+    return { name: tmpName, cleanup: () => rm(`${root}/${tmpName}`, { force: true }) };
+  }
+
   async function verifyOne(name, home, signal) {
     const { root } = paths();
     const archive = `${root}/${name}`;
@@ -1713,17 +2424,32 @@ export function apply(ctx, pluginConfig) {
     } catch {
       // 边车缺失
     }
+    const encrypted = await isArchiveEncrypted(name);
     if (!/^[0-9a-f]{64}$/.test(expected)) {
-      return { name, ok: false, note: '缺少或无效的配套校验文件（.sha256）——无法确认这份备份是否完好' };
+      return { name, ok: false, encrypted, note: '缺少或无效的配套校验文件（.sha256）——无法确认这份备份是否完好' };
     }
     const actual = await sha256File(archive, home, signal);
-    return { name, ok: actual === expected, note: actual === expected ? '完整' : '校验和不匹配（归档或校验文件之一可能损坏）' };
+    return {
+      name,
+      ok: actual === expected,
+      encrypted,
+      // 加密归档的 sha256 是密文的：完整性校验无需口令，口令只影响恢复时的解密。
+      note: actual === expected ? (encrypted ? '完整（🔒 加密归档：完整性校验无需口令）' : '完整') : '校验和不匹配（归档或校验文件之一可能损坏）',
+    };
   }
 
   async function pickArchive(selector) {
     const all = await listBackups();
-    if (!all.length) throw new Error('暂无备份');
-    if (!selector || selector === 'latest') return all[0];
+    // 无全量归档时不能早退「暂无备份」——跨机首恢复现场正是只有分类型归档
+    // （#126：新机从另一台机器只拷来一份 dsh-t- 归档，全量列表为空）。下面
+    // 的显式名/前缀分支会把分类型归档一并纳入候选；仅在候选全空时才报错。
+    const wantsLatest = !selector || selector === 'latest';
+    if (!all.length && wantsLatest) {
+      const typedLatest = await listTypedBackups();
+      if (typedLatest.length) throw new Error('本机只有分类型归档（dsh-t- 前缀），没有全量归档可用 latest 选中——请用完整归档名或前缀，并带 --types');
+      throw new Error('暂无备份');
+    }
+    if (wantsLatest) return all[0];
     const exact = all.filter((b) => b.name === selector);
     const hits = exact.length ? exact : all.filter((b) => b.name.startsWith(selector));
     if (hits.length === 1) return hits[0];
@@ -1929,6 +2655,10 @@ export function apply(ctx, pluginConfig) {
   }
 
   async function restoreArchive(selector, dryRun, signal, opts = {}) {
+    return withOperationLock('restore', () => restoreArchiveInner(selector, dryRun, signal, opts));
+  }
+
+  async function restoreArchiveInner(selector, dryRun, signal, opts = {}) {
     const { home, dshHome, root } = paths();
     const picked = await pickArchive(selector);
     const archive = `${root}/${picked.name}`;
@@ -1937,9 +2667,29 @@ export function apply(ctx, pluginConfig) {
     const v = await verifyOne(picked.name, home, signal);
     if (!v.ok) throw new Error(`校验未通过（${v.note}），恢复已中止`);
 
+    // 加密归档：先解密到备份目录内临时 tar.gz（隐藏名 .decrypt-*，不进列表/轮换），
+    // 后续 tar 全部针对明文临时文件；口令只经 opts.password（面板 RPC 内存态）传入，
+    // 绝不落盘。finally 必清临时文件——它是明文 tar.gz，遗留会绕过加密边界。
+    const encrypted = await isArchiveEncrypted(picked.name);
+    let workName = picked.name;
+    let cleanupArchive = null;
+    if (encrypted) {
+      const dec = await decryptArchiveFile(picked.name, opts?.password, signal);
+      workName = dec.name;
+      cleanupArchive = dec.cleanup;
+    }
+    try {
+      return await restoreArchiveFromPlain(picked, workName, archive, dryRun, signal, opts, { home, dshHome, root });
+    } finally {
+      if (cleanupArchive) await cleanupArchive().catch(() => { /* 清理失败尽力而为 */ });
+    }
+  }
+
+  async function restoreArchiveFromPlain(picked, workName, archive, dryRun, signal, opts, env) {
+    const { home, dshHome, root } = env;
     const base = dshHome.split('/').pop();
     const parent = dshHome.slice(0, -(base.length + 1)) || '/';
-    const entries = await safeArchiveEntries(picked.name, signal);
+    const entries = await safeArchiveEntries(workName, signal);
 
     // 预检（dry-run 与真实恢复共用）：跨机 home 对比 + 脱敏清单 + profile 依赖。
     const { meta, redactedFiles } = await readArchiveMeta(picked.name);
@@ -2017,7 +2767,7 @@ export function apply(ctx, pluginConfig) {
       }
       try {
         const tar = await ctx.subprocess.resolveExecutable('tar');
-        await spawnRun([tar, '-xzf', picked.name, '-C', parentTar(parent), ...fileTargets], root, signal);
+        await spawnRun([tar, '-xzf', workName, '-C', parentTar(parent), ...fileTargets], root, signal);
       } catch (err) {
         // 对齐 #28 / doctorRepair 回滚：从留档还原每个被覆盖项；连还原都失败
         // 时把留档路径交代清楚，绝不静默停在半截状态。
@@ -2091,7 +2841,7 @@ export function apply(ctx, pluginConfig) {
     }
     try {
       const tar = await ctx.subprocess.resolveExecutable('tar');
-      await spawnRun([tar, '-xzf', picked.name, '-C', parentTar(parent)], root, signal);
+      await spawnRun([tar, '-xzf', workName, '-C', parentTar(parent)], root, signal);
     } catch (err) {
       // 挪旁之后解压失败会让 .dsh 处于空位——这是恢复流程里用户最容易慌
       // 的时刻。尽力自动回滚：清掉半截解压产物、把原数据改回原名；连回滚
@@ -2241,63 +2991,1264 @@ export function apply(ctx, pluginConfig) {
     return lines.join('\n');
   }
 
-  // ---------- 会话日志体检（doctor） ----------
+  // ---------- 导出 / 导入（P2 宿主半边） ----------
   //
-  // 布局与格式依据宿主内置的 @deepseek-ai/dsh-session-persistence-jsonl：
-  //   <会话根>/--<项目目录>--/<编码后 id>/session.jsonl.zstd（compression:'none' 时为 .jsonl）
-  // zstd 文件是独立帧的拼接：首帧是带校验和的 SessionHeader 行，其后每个追加批一帧。
-  // 两条硬契约都对齐宿主读端：①行级——首行 SessionHeader、seq 连续；②容器级——
-  // 首帧解出来恰好一行 header（宿主 assertZstdHeaderFrame；外部工具把整份日志
-  // 压成单帧时内容完整可解、宿主却拒载，行级校验覆盖不到，必须单独判）。
-  // Node 内置 zstd 解码器不跨帧续读，因此先按 RFC 8878 走帧字节边界
-  // （魔数/帧头/块序列/校验和），再逐帧解出逻辑行。检测目标正是社区高频的
-  // "corrupt session log"灾难：并发写 seq 撞号、坏帧、尾部截断、单帧重写。
-  const ZSTD_MAGIC = 0xfd2fb528;
-  // 会话日志文件名 = 宿主 sessionFormatLogFilename 的形态：session[.v<N>].jsonl[.zstd]
-  // （N≥1 可多位；无 .vN 后缀即第 0 代）。**代数是文件名的一部分、会随格式换代前进**，
-  // 写死具体名字会在换代当天整体失明（#117：v4 机器上 doctor/migrate 一份都看不见），
-  // 故按形态匹配，让新代文件至少进入校验/预检流程（代的判定另见迁移预检）。
-  const SESSION_LOG_RE = /^session(?:\.v([1-9][0-9]*))?\.jsonl(?:\.zstd)?$/;
-  const isSessionLogName = (name) => SESSION_LOG_RE.test(name);
-  /** 从会话日志文件名取格式代；非会话日志名返回 null（无 .vN 后缀即 v0）。 */
-  function sessionLogVersion(name) {
-    const m = SESSION_LOG_RE.exec(name);
-    return m ? Number(m[1] ?? 0) : null;
+  // 导出：把 ~/.dsh 打包成单文件 ZIP（零依赖 STORE），节段化（settings/ui/providers/
+  // plugins/mcp/skills/prompts/workspaces/sessions/credentials + other 兜底）。凭据节段
+  // 默认脱敏（不进 ZIP），仅 includeCredentials + 口令加密才入包。可选加密复用
+  // lib/encrypt.js（scrypt + AES-256-GCM），密文覆盖 ZIP 本体、参数进 `<zip>.encrypted.json`
+  // 边车。导出 ZIP 落到备份目录 `dsh-config-<时间戳>.zip`，回执给绝对路径。
+  //
+  // 导入：ZIP 是不可信输入——listZip/extractZip 全套 Zip Slip / 符号链接 / zip bomb /
+  // CRC 防线；先 importPreview（dry-run 计划：节段、目标冲突、跨机 remap 需求、
+  // 兼容性评分），再 importApply（自动快照 → 应用 → 校验 → 失败回滚）。
+  //
+  // 节段归类：ZIP 条目名 = 相对 ~/.dsh 的 POSIX 路径；section = 按顶层名归类。
+  // 这样既避免「sessions/sessions/…」双重前缀，又让导入目标路径 = dshHome + 条目名。
+
+  /** 按顶层条目名归类节段 key；未匹配 → other 兜底（绝不丢弃任何文件）。 */
+  function sectionKeyForTop(top) {
+    for (const s of EXPORT_SECTIONS) if (s.paths.includes(top)) return s.key;
+    return EXPORT_OTHER_KEY;
   }
-  const SCAN_SKIP_DIRS = new Set(['node_modules', '.system', '.git', 'vault']);
-  const SCAN_MAX_FILES = 4000;
-  const SCAN_MAX_DEPTH = 8;
-  // Node 内置 zstd API 要 v22.15 / v23.8 才进 node:zlib；更老运行时没有这个
-  // 导出。必须用命名空间导入 + 运行时探测——具名导入是静态校验的，在缺导出
-  // 的运行时上会让整个插件模块加载失败，比少一个体检功能严重得多。
-  const HAS_NODE_ZSTD = typeof zlib.zstdDecompressSync === 'function';
 
-  /** 截断超长内容用于缺陷描述。 */
-  function snippet(text, max = 60) {
-    return text.length > max ? `${text.slice(0, max)}…` : text;
+  /** 节段 key → 人话标签（含 other 兜底）。 */
+  function sectionLabel(key) {
+    const hit = EXPORT_SECTIONS.find((s) => s.key === key);
+    return hit ? hit.label : (key === EXPORT_OTHER_KEY ? '其他（未归类）' : key);
   }
 
   /**
-   * 按 RFC 8878 结构走查拼接帧的字节边界（不解压）：返回 [start,end] 区间数组；
-   * 结构不合法（截断/未知魔数/保留位/越界块）抛错。
-   * skippable 帧直接判非法——宿主 scanZstdFrames 拒绝一切非数据帧魔数，
-   * 这类文件宿主整体拒载，容忍它们会造成「doctor 报 OK、宿主编译系统读不了」。
+   * 递归走查 ~/.dsh 收集可导出的普通文件。跳过符号链接/特殊文件/node_modules/
+   * .git/.system（任意深度）；凭据节段按 includeCredentials 决定入包或记入脱敏清单。
    */
-  function walkZstdFrames(buf) {
-    const frames = [];
-    let off = 0;
-    while (off < buf.length) {
-      if (buf.length - off < 4) throw new Error(`尾部截断（余 ${buf.length - off} 字节不成帧）`);
-      const magic = buf.readUInt32LE(off);
-      if (magic === ZSTD_MAGIC) {
-        let pos = off + 4;
-        if (pos >= buf.length) throw new Error('帧头描述符缺失');
-        const desc = buf[pos++];
-        if (desc & 0x08) throw new Error('帧头保留位置位');
-        const singleSegment = Boolean(desc & 0x20);
-        const checksum = Boolean(desc & 0x04);
-        const dictSize = [0, 1, 2, 4][desc & 0x03];
-        const fcsSize = singleSegment ? [1, 2, 4, 8][desc >> 6] : [0, 2, 4, 8][desc >> 6];
+  async function walkExportFiles(dshHome, includeCredentials, signal) {
+    const files = [];
+    const redacted = [];
+    const skipDirs = new Set(['node_modules', '.git', '.system']);
+    async function walk(abs, rel) {
+      if (signal?.aborted) throw new Error('操作已取消');
+      if (files.length >= EXPORT_MAX_FILES) throw new Error(`导出文件数超过上限（${EXPORT_MAX_FILES}），请检查 ~/.dsh 是否有异常目录树`);
+      let st;
+      try { st = await lstat(abs); } catch { return; }
+      if (st.isSymbolicLink()) return;
+      if (st.isDirectory()) {
+        if (rel && skipDirs.has(rel.split('/').pop())) return;
+        let names;
+        try { names = await readdir(abs); } catch { return; }
+        for (const n of names) {
+          if (n === '.DS_Store') continue;
+          await walk(`${abs}/${n}`, rel ? `${rel}/${n}` : n);
+        }
+        return;
+      }
+      if (!st.isFile()) return;
+      const section = sectionKeyForTop(rel.split('/')[0]);
+      if (section === 'credentials' && !includeCredentials) { redacted.push(rel); return; }
+      files.push({ rel, abs, bytes: st.size, section });
+    }
+    await walk(dshHome, '');
+    return { files, redacted };
+  }
+
+  /** 组装导出 manifest（JSON，作为 ZIP 首条目写入；导入读端据此识别包）。 */
+  function buildManifest(home, encrypted, redacted, sectionStats) {
+    const sections = [...sectionStats.entries()].map(([key, v]) => ({ key, label: sectionLabel(key), files: v.files, bytes: v.bytes }));
+    return {
+      format: EXPORT_FORMAT,
+      version: EXPORT_FORMAT_VERSION,
+      createdAt: new Date().toISOString(),
+      source: { host: hostname(), home, platform: process.platform, pluginVersion: SELF_META.version },
+      redacted,
+      encrypted,
+      sections,
+      totalFiles: [...sectionStats.values()].reduce((s, v) => s + v.files, 0),
+      totalBytes: [...sectionStats.values()].reduce((s, v) => s + v.bytes, 0),
+    };
+  }
+
+  /** 导出：把 ~/.dsh 打成单文件 ZIP（可选加密）。 */
+  async function exportConfig(opts, signal) {
+    const { home, dshHome, root } = paths();
+    const includeCredentials = opts?.includeCredentials === true;
+    const password = typeof opts?.password === 'string' && opts.password ? opts.password : null;
+    // 凭据入包必须加密：明文凭据打成一个可随意拷贝的 ZIP 是自找泄密。
+    if (includeCredentials && !password) {
+      throw new Error('包含凭据的导出必须加密（口令只经面板 RPC 内存态传入，绝不落盘）——请勾选加密并输入口令');
+    }
+    const { files, redacted } = await walkExportFiles(dshHome, includeCredentials, signal);
+    const sectionStats = new Map();
+    for (const f of files) {
+      const cur = sectionStats.get(f.section) || { files: 0, bytes: 0 };
+      cur.files += 1; cur.bytes += f.bytes;
+      sectionStats.set(f.section, cur);
+    }
+    // 本地 link:/file: 插件迁移：npm pack 成 tarball 打进导出，导入侧解包改 file:
+    const localPlugins = await scanLocalPlugins(signal);
+    const packedPlugins = localPlugins.filter((p) => p.status === 'packed');
+    const encrypted = Boolean(password);
+    const manifest = buildManifest(home, encrypted, redacted, sectionStats);
+    manifest.localPlugins = localPlugins.map((p) => ({ profile: p.profile, name: p.name, spec: p.spec, status: p.status, tarball: p.tarballName ?? null, warning: p.warning ?? null }));
+    const finalName = `dsh-config-${stampNow()}.zip`;
+    const finalPath = `${root}/${finalName}`;
+    const tmpPath = `${root}/.export-${stampNow()}.tmp.zip`;
+    // 备份目录可能尚未创建（用户从没备份过就直接点导出）：先 mkdir，避免
+    // buildZip 的 createWriteStream 对不存在的 root 抛未捕获 ENOENT。
+    await mkdir(root, { recursive: true });
+    try {
+      const entryList = [{ name: 'manifest.json', data: Buffer.from(JSON.stringify(manifest)) }];
+      for (const f of files) entryList.push({ name: f.rel, sourcePath: f.abs });
+      for (const p of packedPlugins) entryList.push({ name: `local-plugins/${p.tarballName}`, sourcePath: p.tarballPath });
+      await buildZip(tmpPath, entryList, { signal });
+      if (encrypted) {
+        const plain = await readFile(tmpPath);
+        const enc = await encryptBuffer(plain, password);
+        await writeBinary(finalPath, enc.ciphertext);
+        await writeOwned(`${finalPath}.encrypted.json`, `${JSON.stringify(enc.sidecar)}\n`);
+      } else {
+        await rename(tmpPath, finalPath);
+      }
+    } finally {
+      await rm(tmpPath, { force: true }).catch(() => {});
+    }
+    const size = (await fsStat(finalPath)).size;
+    const summary = `✅ 导出完成: ${finalName}（${encrypted ? '🔒 已加密' : '未加密'}，${files.length} 个文件）\n位置: ${finalPath}${redacted.length ? `\n🔐 已脱敏 ${redacted.length} 个凭据文件（不在包里，跨机需重填）` : ''}`;
+    return { ok: true, path: finalPath, name: finalName, size, encrypted, manifest, redactedFiles: redacted, summary };
+  }
+
+  // ---------------- 配置市场（P4b-2） ----------------
+  // 索引来自用户配置的 marketUrl，是**不可信输入**：只做 schema 校验与体积/条数
+  // 上限，绝不执行 bundle 代码；断网/非法/超大一律优雅降级为空列表并如实说明。
+  const MARKET_MAX_ENTRIES = 500;
+  const MARKET_MAX_BYTES = 5 * 1024 * 1024;
+  const MARKET_TIMEOUT_MS = 8000;
+
+  /** 把市场索引里的一条原始记录归一化；缺 id/name/url 或 URL 非 http(s) 的条目直接丢弃。 */
+  function normalizeMarketEntry(raw) {
+    if (!raw || typeof raw !== 'object') return null;
+    const id = typeof raw.id === 'string' ? raw.id.trim() : '';
+    const name = typeof raw.name === 'string' ? raw.name.trim() : '';
+    const url = typeof raw.url === 'string' ? raw.url.trim() : '';
+    if (!id || !name || !url) return null;
+    let parsed;
+    try { parsed = new URL(url); } catch { return null; }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+    return {
+      id,
+      name,
+      desc: typeof raw.desc === 'string' ? raw.desc.slice(0, 500) : '',
+      sections: Array.isArray(raw.sections) ? raw.sections.filter((s) => typeof s === 'string').slice(0, 32) : [],
+      url,
+      source: typeof raw.source === 'string' ? raw.source.slice(0, 200) : '',
+      risk: raw.risk === 'high' || raw.risk === 'medium' ? raw.risk : 'low',
+      version: typeof raw.version === 'string' ? raw.version.slice(0, 64) : '',
+    };
+  }
+
+  /** 拉取并校验市场索引。返回 { enabled, entries, notice }，永不抛网络错误。 */
+  async function fetchMarketIndex(signal) {
+    const cfg = resolvedConfig();
+    const url = typeof cfg.marketUrl === 'string' ? cfg.marketUrl.trim() : '';
+    if (!url) return { enabled: false, entries: [], notice: '未配置市场地址（设置 → 备份设置 → 市场地址）' };
+    let parsed;
+    try { parsed = new URL(url); } catch { return { enabled: false, entries: [], notice: '市场地址不是合法 URL' }; }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+      return { enabled: false, entries: [], notice: '市场地址必须是 http(s)' };
+    }
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), MARKET_TIMEOUT_MS);
+    const onAbort = () => ctrl.abort();
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    try {
+      const res = await fetch(url, { signal: ctrl.signal, headers: { accept: 'application/json' } });
+      if (!res.ok) return { enabled: true, entries: [], notice: `市场索引拉取失败：HTTP ${res.status}` };
+      const len = Number(res.headers.get('content-length') || 0);
+      if (len > MARKET_MAX_BYTES) return { enabled: true, entries: [], notice: '市场索引过大（>5MB），已拒绝' };
+      const text = await res.text();
+      if (text.length > MARKET_MAX_BYTES) return { enabled: true, entries: [], notice: '市场索引过大（>5MB），已拒绝' };
+      let data;
+      try { data = JSON.parse(text); } catch { return { enabled: true, entries: [], notice: '市场索引不是合法 JSON' }; }
+      const list = Array.isArray(data) ? data : (Array.isArray(data?.entries) ? data.entries : null);
+      if (!list) return { enabled: true, entries: [], notice: '市场索引格式不对（需要数组或 { entries: [...] }）' };
+      const entries = list.slice(0, MARKET_MAX_ENTRIES).map(normalizeMarketEntry).filter(Boolean);
+      return { enabled: true, entries, notice: entries.length ? '' : '市场里没有有效条目' };
+    } catch (err) {
+      if (signal?.aborted) throw new Error('操作已取消');
+      return { enabled: true, entries: [], notice: `市场索引拉取失败：${String(err && err.message ? err.message : err)}` };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', onAbort);
+    }
+  }
+
+  /** 市场列表（只读）。 */
+  async function marketList(signal) {
+    const { enabled, entries, notice } = await fetchMarketIndex(signal);
+    let host = '市场';
+    try { host = new URL(resolvedConfig().marketUrl).host; } catch { /* 保持默认 */ }
+    const summary = enabled
+      ? (entries.length
+        ? `🛒 市场共 ${entries.length} 个配置（来源：${host}）`
+        : `🛒 市场暂无可用配置${notice ? `：${notice}` : ''}`)
+      : `🛒 市场未启用${notice ? `：${notice}` : ''}`;
+    return { ok: true, enabled, entries, summary };
+  }
+
+  /** 市场搜索（只读，本地过滤 name/desc）。 */
+  async function marketSearch(query, signal) {
+    const r = await marketList(signal);
+    const q = typeof query === 'string' ? query.trim().toLowerCase() : '';
+    if (!q) return r;
+    const entries = r.entries.filter((e) => `${e.name} ${e.desc}`.toLowerCase().includes(q));
+    return { ...r, entries, summary: `🛒 搜索「${query.trim()}」：${entries.length} 个结果` };
+  }
+
+  /**
+   * 市场安装：下载条目 bundle ZIP → importPreview（只读计划）→ importApply
+   * （自动快照 + 失败回滚）；默认 dry-run，confirm:true 才真正写入。
+   * 供应链提示始终随结果返回，绝不静默安装。
+   */
+  async function marketInstall(opts, signal) {
+    const id = typeof opts?.id === 'string' ? opts.id.trim() : '';
+    if (!id) throw new Error('缺少市场条目 id');
+    const { entries } = await fetchMarketIndex(signal);
+    const entry = entries.find((e) => e.id === id);
+    if (!entry) throw new Error(`市场里找不到条目：${id}`);
+    const { root } = paths();
+    await mkdir(root, { recursive: true });
+    const tmp = `${root}/.market-${stampNow()}.zip`;
+    const supplyChain = [];
+    if (!entry.source) supplyChain.push('⚠️ 该条目未声明来源，无法确认发布者');
+    if (entry.risk === 'high') supplyChain.push('⚠️ 该条目被标记为高风险配置');
+    try {
+      const host = new URL(entry.url).host;
+      if (!/(^|\.)(github\.com|githubusercontent\.com|deepseek\.com)$/i.test(host)) {
+        supplyChain.push(`⚠️ 下载来源为第三方域名：${host}`);
+      }
+    } catch { /* URL 已在归一化阶段过滤 */ }
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), MARKET_TIMEOUT_MS);
+    const onAbort = () => ctrl.abort();
+    signal?.addEventListener?.('abort', onAbort, { once: true });
+    try {
+      const res = await fetch(entry.url, { signal: ctrl.signal });
+      if (!res.ok) throw new Error(`下载配置包失败：HTTP ${res.status}`);
+      const len = Number(res.headers.get('content-length') || 0);
+      if (len > MARKET_MAX_BYTES) throw new Error('配置包过大（>5MB），已拒绝');
+      const buf = Buffer.from(await res.arrayBuffer());
+      if (buf.length > MARKET_MAX_BYTES) throw new Error('配置包过大（>5MB），已拒绝');
+      await writeBinary(tmp, buf);
+      const preview = await importPreview({ sourcePath: tmp }, signal);
+      if (opts?.confirm !== true) {
+        return {
+          ok: true,
+          dryRun: true,
+          entry: { id: entry.id, name: entry.name },
+          preview,
+          supplyChain,
+          summary: `🛒 市场预览：${entry.name}\n${preview.summary}${supplyChain.length ? `\n${supplyChain.join('\n')}` : ''}\n\n确认无误后再执行安装（confirm=true）。`,
+        };
+      }
+      const applied = await importApply({ sourcePath: tmp, decisions: opts?.decisions || {}, sections: opts?.sections }, signal);
+      return {
+        ok: applied.ok !== false,
+        dryRun: false,
+        entry: { id: entry.id, name: entry.name },
+        applied,
+        supplyChain,
+        summary: `🛒 市场安装：${entry.name}\n${applied.summary}${supplyChain.length ? `\n${supplyChain.join('\n')}` : ''}`,
+      };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', onAbort);
+      await rm(tmp, { force: true }).catch(() => {});
+    }
+  }
+
+  // ---------------- 外部 agent 导入（P4b-3） ----------------
+  // 从本机已安装的其它 AI agent 读取「技能 + 全局指令」，翻译成标准 dsh-config
+  // 包后走 importPreview/importApply（预览/冲突/快照/回滚）。MCP 服务器只检测
+  // 并如实报告——DSH 的 MCP 载体是 cordis 配置，v1 不自动改写，避免装坏。
+  const FOREIGN_SOURCES = Object.freeze([
+    { id: 'claude-code', label: 'Claude Code', skillsDir: '.claude/skills', instructions: ['.claude/CLAUDE.md'], mcpFiles: ['.claude/settings.json', '.claude.json'] },
+    { id: 'cursor', label: 'Cursor', skillsDir: null, instructions: ['.cursorrules'], mcpFiles: ['.cursor/mcp.json'] },
+    { id: 'codex', label: 'Codex', skillsDir: null, instructions: ['.codex/AGENTS.md'], mcpFiles: ['.codex/config.toml'] },
+  ]);
+  const FOREIGN_MAX_FILES = 500;
+  const FOREIGN_MAX_BYTES = 10 * 1024 * 1024;
+  const FOREIGN_MAX_INSTRUCTION_BYTES = 200 * 1024;
+
+  /** 安全相对路径：拒绝空、绝对路径与 `..` 段。 */
+  function safeForeignRel(rel) {
+    return typeof rel === 'string' && rel !== '' && !rel.startsWith('/') && !rel.split('/').includes('..');
+  }
+
+  async function collectForeignSkills(home, source, signal) {
+    const out = [];
+    if (!source.skillsDir) return out;
+    let names;
+    try { names = await readdir(`${home}/${source.skillsDir}`); } catch { return out; }
+    const walkDir = async (abs, rel) => {
+      let entries;
+      try { entries = await readdir(abs); } catch { return; }
+      for (const n of entries) {
+        if (signal?.aborted) throw new Error('操作已取消');
+        if (!safeForeignRel(n)) continue;
+        const childAbs = `${abs}/${n}`;
+        const childRel = `${rel}/${n}`;
+        let st;
+        try { st = await lstat(childAbs); } catch { continue; }
+        if (st.isSymbolicLink()) continue;
+        if (st.isDirectory()) { await walkDir(childAbs, childRel); continue; }
+        if (!st.isFile()) continue;
+        if (out.length >= FOREIGN_MAX_FILES) throw new Error(`外部技能文件数超过上限（${FOREIGN_MAX_FILES}）`);
+        out.push({ rel: childRel, abs: childAbs, bytes: st.size });
+      }
+    };
+    for (const n of names) {
+      if (!safeForeignRel(n)) continue;
+      const abs = `${home}/${source.skillsDir}/${n}`;
+      let st;
+      try { st = await lstat(abs); } catch { continue; }
+      if (!st.isDirectory()) continue;
+      await walkDir(abs, `skills/${n}`);
+    }
+    return out;
+  }
+
+  async function collectForeignInstructions(home, source) {
+    for (const rel of source.instructions) {
+      try {
+        const st = await fsStat(`${home}/${rel}`);
+        if (!st.isFile() || st.size > FOREIGN_MAX_INSTRUCTION_BYTES) continue;
+        const content = await readFile(`${home}/${rel}`, 'utf8');
+        return { rel, content };
+      } catch { /* 试下一个 */ }
+    }
+    return null;
+  }
+
+  async function detectForeignSource(home, source) {
+    const files = await collectForeignSkills(home, source, null);
+    const instructions = await collectForeignInstructions(home, source);
+    const mcpServers = [];
+    for (const rel of source.mcpFiles) {
+      let text;
+      try { text = await readFile(`${home}/${rel}`, 'utf8'); } catch { continue; }
+      if (!rel.endsWith('.json')) { mcpServers.push(`${rel}（存在，未解析）`); continue; }
+      try {
+        const data = JSON.parse(text);
+        const servers = data?.mcpServers && typeof data.mcpServers === 'object' ? Object.keys(data.mcpServers) : [];
+        for (const s of servers) mcpServers.push(`${s}（来自 ${rel}）`);
+      } catch { mcpServers.push(`${rel}（存在，JSON 解析失败）`); }
+    }
+    return {
+      id: source.id,
+      label: source.label,
+      detected: files.length > 0 || Boolean(instructions) || mcpServers.length > 0,
+      files,
+      instructions,
+      mcpServers,
+    };
+  }
+
+  /** 外部 agent 列表（只读检测）。 */
+  async function foreignSources() {
+    const { home } = paths();
+    const list = [];
+    for (const source of FOREIGN_SOURCES) {
+      const r = await detectForeignSource(home, source);
+      list.push({
+        id: r.id,
+        label: r.label,
+        detected: r.detected,
+        skills: r.files.length,
+        instructions: r.instructions ? r.instructions.rel : null,
+        mcpServers: r.mcpServers,
+      });
+    }
+    const found = list.filter((s) => s.detected).map((s) => s.label);
+    return {
+      ok: true,
+      sources: list,
+      summary: found.length ? `🧳 检测到 ${found.length} 个可导入来源：${found.join('、')}` : '🧳 没有检测到可导入的外部 agent 配置',
+    };
+  }
+
+  /** 把某来源翻译成标准 dsh-config 包（技能 + AGENTS.md），返回 { zipPath, report, cleanup }。 */
+  async function buildForeignBundle(sourceId, signal) {
+    const { home, root } = paths();
+    const source = FOREIGN_SOURCES.find((s) => s.id === sourceId);
+    if (!source) throw new Error(`未知来源：${sourceId}`);
+    const r = await detectForeignSource(home, source);
+    if (!r.detected) throw new Error(`本机没有检测到 ${source.label} 的配置`);
+    let bytes = 0;
+    for (const f of r.files) bytes += f.bytes;
+    if (bytes > FOREIGN_MAX_BYTES) throw new Error(`外部配置体积超过上限（${(FOREIGN_MAX_BYTES / 1048576).toFixed(0)}MB）`);
+    const instructionBytes = r.instructions ? Buffer.byteLength(r.instructions.content) : 0;
+    const entries = r.files.map((f) => ({ name: f.rel, sourcePath: f.abs }));
+    if (r.instructions) entries.unshift({ name: 'AGENTS.md', data: Buffer.from(r.instructions.content) });
+    const manifest = {
+      format: EXPORT_FORMAT,
+      version: EXPORT_FORMAT_VERSION,
+      createdAt: new Date().toISOString(),
+      source: { host: r.label, platform: process.platform, pluginVersion: SELF_META.version, home: '~' },
+      redacted: [],
+      encrypted: false,
+      sections: [
+        ...(r.instructions ? [{ key: 'other', label: '其他（未归类）', files: 1, bytes: instructionBytes }] : []),
+        ...(r.files.length ? [{ key: 'skills', label: '技能', files: r.files.length, bytes }] : []),
+      ],
+      totalFiles: r.files.length + (r.instructions ? 1 : 0),
+      totalBytes: bytes + instructionBytes,
+      foreign: { source: r.id, label: r.label, mcpServers: r.mcpServers },
+    };
+    const zipPath = `${root}/.foreign-${stampNow()}.zip`;
+    await mkdir(root, { recursive: true });
+    try {
+      await buildZip(zipPath, [{ name: 'manifest.json', data: Buffer.from(JSON.stringify(manifest)) }, ...entries], { signal });
+    } catch (err) {
+      await rm(zipPath, { force: true }).catch(() => {});
+      throw err;
+    }
+    return {
+      zipPath,
+      report: {
+        source: r.id,
+        label: r.label,
+        skills: r.files.length,
+        instructions: r.instructions ? r.instructions.rel : null,
+        mcpServers: r.mcpServers,
+        totalFiles: manifest.totalFiles,
+        totalBytes: manifest.totalBytes,
+      },
+      cleanup: () => rm(zipPath, { force: true }),
+    };
+  }
+
+  /** 外部 agent 预览（只读计划，不写 ~/.dsh）。 */
+  async function foreignPreview(options, signal) {
+    const sourceId = typeof options?.source === 'string' ? options.source : '';
+    if (!sourceId) throw new Error('缺少来源（source）');
+    const bundle = await buildForeignBundle(sourceId, signal);
+    try {
+      const preview = await importPreview({ sourcePath: bundle.zipPath }, signal);
+      const mcp = bundle.report.mcpServers.length
+        ? `\n\n检测到 ${bundle.report.mcpServers.length} 个 MCP 服务器（v1 不自动导入，请手动配置）：\n${bundle.report.mcpServers.map((m) => `  · ${m}`).join('\n')}`
+        : '';
+      return { ok: true, report: bundle.report, preview, summary: `🧳 ${bundle.report.label} 预览\n${preview.summary}${mcp}` };
+    } finally {
+      await bundle.cleanup().catch(() => {});
+    }
+  }
+
+  /** 外部 agent 导入：默认 dry-run；confirm:true 才真正写入（自动快照 + 回滚）。 */
+  async function foreignImport(options, signal) {
+    const sourceId = typeof options?.source === 'string' ? options.source : '';
+    if (!sourceId) throw new Error('缺少来源（source）');
+    const bundle = await buildForeignBundle(sourceId, signal);
+    try {
+      if (options?.confirm !== true) {
+        const preview = await importPreview({ sourcePath: bundle.zipPath }, signal);
+        return { ok: true, dryRun: true, report: bundle.report, preview, summary: `🧳 ${bundle.report.label} 预览（未写入）\n${preview.summary}` };
+      }
+      const applied = await importApply({ sourcePath: bundle.zipPath, decisions: options?.decisions || {} }, signal);
+      return { ok: applied.ok !== false, dryRun: false, report: bundle.report, applied, summary: `🧳 ${bundle.report.label} 导入\n${applied.summary}` };
+    } finally {
+      await bundle.cleanup().catch(() => {});
+    }
+  }
+
+  // ---------------- 会话 Rewind（P4b-3b） ----------------
+  // 把会话「分叉」到指定轮次：原会话一个字节都不改，新会话写到同一项目目录下
+  // 的新会话目录，header.id 换成新 id、parentSession 指向原会话。v1 只复制会话
+  // 日志（不做工作区文件回滚、不复制附件），预览里如实标注。
+  const REWIND_MAX_SESSIONS = 50;
+
+  /** 与宿主 session-persistence-jsonl 的 encodeSegment 逐字符一致（见其源码注释）。 */
+  function encodeSessionSegment(raw) {
+    if (typeof raw !== 'string' || raw.length === 0) throw new Error('会话 id 不能为空');
+    if (raw === '.') return '~002E';
+    if (raw === '..') return '~002E~002E';
+    let out = '';
+    for (let i = 0; i < raw.length; i++) {
+      const code = raw.charCodeAt(i);
+      const ch = String.fromCharCode(code);
+      if (ch !== '~' && /^[A-Za-z0-9._-]$/.test(ch)) out += ch;
+      else out += '~' + code.toString(16).toUpperCase().padStart(4, '0');
+    }
+    return out;
+  }
+
+  /** 只解首帧拿 header（列表用，避免整读大日志）。 */
+  function readSessionHeader(buf) {
+    const frames = walkZstdFrames(buf);
+    if (!frames.length) throw new Error('空日志');
+    const first = zlib.zstdDecompressSync(buf.subarray(frames[0][0], frames[0][1]));
+    const line = first.toString('utf8').split('\n').find((l) => l.length > 0);
+    if (!line) throw new Error('首帧没有 header 行');
+    const header = JSON.parse(line);
+    if (!header || header.type !== 'session' || typeof header.id !== 'string') throw new Error('首帧不是会话 header');
+    return header;
+  }
+
+  /** 一行记录的 seq 跨度 [start,end)；无 seq 返回 null。 */
+  function rowSeqSpan(rec) {
+    if (!rec || typeof rec !== 'object') return null;
+    if (rec.type === 'text-chunks' || rec.type === 'reasoning-chunks' || rec.type === 'tool-call-chunks') {
+      const data = rec.data ?? {};
+      const members = Array.isArray(data.texts) ? data.texts.length : Array.isArray(data.args) ? data.args.length : 0;
+      if (Number.isSafeInteger(rec.seq0) && members > 0) return [rec.seq0, rec.seq0 + members];
+      return null;
+    }
+    if (typeof rec.seq === 'number') return [rec.seq, rec.seq + 1];
+    return null;
+  }
+
+  /** 会话日志列表（只读；header + 文件名）。 */
+  async function sessionRewindList(signal) {
+    const { dshHome } = paths();
+    if (!HAS_NODE_ZSTD) return { ok: true, sessions: [], summary: '🧭 运行时 Node 无内置 zstd，无法列出压缩会话日志' };
+    const found = [];
+    await collectSessionLogs(dshHome, '', 0, found);
+    const out = [];
+    for (const f of found.slice(0, REWIND_MAX_SESSIONS)) {
+      if (signal?.aborted) throw new Error('操作已取消');
+      if (!f.abs.endsWith('.zstd')) continue;
+      try {
+        const header = readSessionHeader(await readFile(f.abs));
+        out.push({ id: header.id, rel: f.rel, file: f.rel.split('/').pop(), cwd: header.cwd ?? null, version: Number(header.version) || 0 });
+      } catch { /* 损坏/无法解析的日志跳过（doctor 负责体检） */ }
+    }
+    out.sort((a, b) => a.id.localeCompare(b.id));
+    return { ok: true, sessions: out, summary: out.length ? `🧭 找到 ${out.length} 个可回退会话` : '🧭 没有找到可回退的会话日志' };
+  }
+
+  /** 按 id 找会话日志：header.id 精确匹配，或目录名 = encodeSegment(id)。 */
+  async function findSessionLog(sessionId, signal) {
+    const { dshHome } = paths();
+    if (!HAS_NODE_ZSTD) throw new Error('运行时 Node 无内置 zstd 支持，无法分叉压缩会话日志');
+    const found = [];
+    await collectSessionLogs(dshHome, '', 0, found);
+    const wantEnc = encodeSessionSegment(sessionId);
+    for (const f of found) {
+      if (signal?.aborted) throw new Error('操作已取消');
+      if (!f.abs.endsWith('.zstd')) continue;
+      const parts = f.abs.split('/');
+      const dirName = parts[parts.length - 2];
+      let header = null;
+      try { header = readSessionHeader(await readFile(f.abs)); } catch { /* 坏日志 */ }
+      if ((header && header.id === sessionId) || dirName === wantEnc || dirName === sessionId) {
+        return { ...f, header };
+      }
+    }
+    return null;
+  }
+
+  /** 计算分叉计划（只读）。seq 缺省 = 最后一个用户消息。 */
+  async function planSessionRewind(sessionId, seqInput, signal) {
+    const target = await findSessionLog(sessionId, signal);
+    if (!target) throw new Error(`找不到会话：${sessionId}`);
+    const { lines } = decodeZstdLog(await readFile(target.abs));
+    if (!lines.length) throw new Error('会话日志为空');
+    const header = JSON.parse(lines[0]);
+    const rows = lines.slice(1);
+    let targetSeq = Number.isInteger(seqInput) ? seqInput : null;
+    if (targetSeq === null) {
+      for (let i = rows.length - 1; i >= 0; i--) {
+        let rec;
+        try { rec = JSON.parse(rows[i]); } catch { continue; }
+        if (rec && typeof rec.seq === 'number' && (rec.role === 'user' || rec.type === 'user/message')) {
+          targetSeq = rec.seq;
+          break;
+        }
+      }
+      if (targetSeq === null) targetSeq = rows.length;
+    }
+    const kept = [];
+    let dropped = 0;
+    for (const line of rows) {
+      let rec;
+      try { rec = JSON.parse(line); } catch { throw new Error('会话日志包含非法 JSON 行，拒绝分叉'); }
+      const span = rowSeqSpan(rec);
+      if (span && span[1] > targetSeq) {
+        dropped = rows.length - kept.length;
+        break;
+      }
+      kept.push(line);
+    }
+    const keptLines = [lines[0], ...kept];
+    const defect = validateSessionLines(keptLines);
+    if (defect !== null) throw new Error(`分叉后的日志未通过宿主容器校验，已拒绝：${defect}`);
+    const newId = `${header.id}-rewind-${stampNow()}`;
+    return { target, header, rows, kept, dropped, targetSeq, newId, keptLines };
+  }
+
+  /** 预览分叉计划（只读，不写盘）。 */
+  async function sessionRewindPreview(sessionId, seq, signal) {
+    const plan = await planSessionRewind(sessionId, seq, signal);
+    const parts = plan.target.abs.split('/');
+    const file = parts[parts.length - 1];
+    const projectDir = parts.slice(0, -2).join('/');
+    const newPath = `${projectDir}/${encodeSessionSegment(plan.newId)}/${file}`;
+    return {
+      ok: true,
+      session: plan.header.id,
+      targetSeq: plan.targetSeq,
+      keepRecords: plan.kept.length,
+      dropRecords: plan.dropped,
+      newId: plan.newId,
+      newPath,
+      warnings: ['v1 只复制会话日志，不复制附件、不回滚工作区文件'],
+      summary: `🧭 回退预览：${plan.header.id}\n保留 ${plan.kept.length} 条记录（回退到 seq < ${plan.targetSeq}）\n原会话保持不变；新分叉：${plan.newId}\n⚠️ v1 只复制会话日志，不复制附件、不回滚工作区文件`,
+    };
+  }
+
+  /** 执行分叉（默认 dry-run；confirm:true 才写）。原会话永不修改。 */
+  /**
+   * 分叉日志的宿主不变量：header.isSeeded 必须与「会话内 inherited end-seed 标记」一致，
+   * 否则宿主解码器 finish() 直接报错（seeded 缺标记 / unseeded 带标记），分叉根本打不开。
+   * 这里统一修正：seeded 缺标记 → 降级为普通会话；unseeded 带标记 → 丢弃标记并重编号。
+   */
+  const SURFACE_EVENT_TYPES = new Set(['system/message', 'developer/message', 'user/message', 'assistant/message', 'tool/result']);
+
+  function normalizeForkLog(header, rows) {
+    // 宿主附加不变量:surface 事件必须带 surfaceOp,log-only 事件必须不带。
+    const normalized = rows.map((row) => {
+      const surface = SURFACE_EVENT_TYPES.has(row.type);
+      if (surface && row.surfaceOp === undefined) return { ...row, surfaceOp: 'append' };
+      if (!surface && row.surfaceOp !== undefined) {
+        const next = { ...row };
+        delete next.surfaceOp;
+        return next;
+      }
+      return row;
+    });
+    const isMarker = (row) => row.type === 'session/end-seed' && row.data?.inherited === true;
+    const markerIndex = normalized.findIndex(isMarker);
+    if (header.isSeeded === true) {
+      if (markerIndex >= 0) return { header, rows: normalized };
+      return { header: { ...header, isSeeded: false }, rows: normalized };
+    }
+    if (markerIndex < 0) return { header, rows: normalized };
+    const kept = normalized.filter((row) => !isMarker(row));
+    const map = new Map();
+    kept.forEach((row, index) => map.set(row.seq, index));
+    const remap = (seq) => (map.has(seq) ? map.get(seq) : undefined);
+    const out = kept.map((row) => {
+      const next = { ...row, seq: map.get(row.seq) };
+      if (Array.isArray(row.sourceEventSeqs)) {
+        const mapped = row.sourceEventSeqs.map(remap).filter((value) => value !== undefined);
+        if (mapped.length) next.sourceEventSeqs = mapped;
+        else delete next.sourceEventSeqs;
+      }
+      if (row.surfaceOp && typeof row.surfaceOp === 'object') {
+        const start = remap(row.surfaceOp.startSeq);
+        const end = remap(row.surfaceOp.endSeq);
+        next.surfaceOp = start === undefined || end === undefined ? 'append' : { op: 'replace', startSeq: start, endSeq: end };
+      }
+      return next;
+    });
+    return { header, rows: out };
+  }
+
+  async function sessionRewindApply(opts, signal) {
+    const sessionId = typeof opts?.session === 'string' ? opts.session : '';
+    if (!sessionId) throw new Error('缺少会话 id');
+    const seq = Number.isInteger(opts?.seq) ? opts.seq : undefined;
+    if (opts?.confirm !== true) {
+      const preview = await sessionRewindPreview(sessionId, seq, signal);
+      return { ...preview, dryRun: true };
+    }
+    const plan = await planSessionRewind(sessionId, seq, signal);
+    const parts = plan.target.abs.split('/');
+    const file = parts[parts.length - 1];
+    const projectDir = parts.slice(0, -2).join('/');
+    const newDir = `${projectDir}/${encodeSessionSegment(plan.newId)}`;
+    const newPath = `${newDir}/${file}`;
+    if (pathExists(newDir)) throw new Error('目标分叉目录已存在，拒绝覆盖');
+    const header = { ...plan.header, id: plan.newId, parentSession: plan.header.id };
+    const normalized = normalizeForkLog(header, plan.kept.map((line) => JSON.parse(line)));
+    const keptLines = normalized.rows.map((row) => JSON.stringify(row));
+    const headerLine = JSON.stringify({ ...normalized.header, id: plan.newId, parentSession: plan.header.id });
+    let buf;
+    if (file.endsWith('.zstd')) {
+      const frames = [zlib.zstdCompressSync(Buffer.from(headerLine + '\n'))];
+      if (keptLines.length) frames.push(zlib.zstdCompressSync(Buffer.from(keptLines.join('\n') + '\n')));
+      buf = Buffer.concat(frames);
+    } else {
+      buf = Buffer.from([headerLine, ...keptLines].join('\n') + '\n');
+    }
+    await mkdir(newDir, { recursive: true });
+    try {
+      await writeFile(newPath, buf);
+      // 写完立刻用同一套宿主容器校验回读，坏包不留
+      const back = decodeZstdLog(await readFile(newPath));
+      const defect = validateSessionLines(back.lines);
+      if (defect !== null) throw new Error(`写出的分叉未通过校验：${defect}`);
+    } catch (err) {
+      await rm(newDir, { recursive: true, force: true }).catch(() => {});
+      throw err;
+    }
+    return {
+      ok: true,
+      dryRun: false,
+      session: plan.header.id,
+      newId: plan.newId,
+      newPath,
+      keepRecords: plan.kept.length,
+      summary: `🧭 已分叉会话：${plan.header.id} → ${plan.newId}\n保留 ${plan.kept.length} 条记录；原会话未改动。\n重启 dsh 后可在会话列表看到新分支。`,
+    };
+  }
+
+  // ---------------- 外部聊天记录导入 v1（Claude Code） ----------------
+  // 把 Claude Code 的会话 JSONL 翻译成 DSH v4 会话日志（新建会话、绝不改原数据）。
+  // 只映射「用户/助手文本 + 工具调用/结果」；图片/文件块与私有事件跳过并计数。
+  // 行格式对齐宿主：{type,seq,time,data} + 消息事件带 surfaceOp:'append'。
+  const CLAUDE_PROJECTS_DIR = '.claude/projects';
+  const CHAT_IMPORT_MAX_MESSAGES = 5000;
+
+  function claudeSessionId(file, slug) {
+    const tail = String(file).replace(/[^A-Za-z0-9]/g, '').slice(-12);
+    const head = String(slug || 'session').replace(/[^A-Za-z0-9]/g, '').slice(-16);
+    return `claude-${head || 'session'}-${tail || '0'}`;
+  }
+
+  async function listClaudeSessions() {
+    const { home } = paths();
+    const root = `${home}/${CLAUDE_PROJECTS_DIR}`;
+    let projects;
+    try { projects = await readdir(root, { withFileTypes: true }); } catch { return []; }
+    const out = [];
+    for (const proj of projects) {
+      if (!proj.isDirectory()) continue;
+      let files;
+      try { files = await readdir(`${root}/${proj.name}`); } catch { continue; }
+      for (const f of files) {
+        if (!f.endsWith('.jsonl')) continue;
+        const abs = `${root}/${proj.name}/${f}`;
+        let st;
+        try { st = await fsStat(abs); } catch { continue; }
+        out.push({ abs, rel: `${CLAUDE_PROJECTS_DIR}/${proj.name}/${f}`, slug: proj.name, file: f, id: claudeSessionId(f, proj.name), bytes: st.size, mtime: st.mtimeMs });
+      }
+    }
+    return out;
+  }
+
+  /** 解析 Claude Code JSONL → 归一化消息序列。 */
+  async function parseClaudeSession(abs) {
+    const text = await readFile(abs, 'utf8');
+    const messages = [];
+    let skipped = 0;
+    for (const line of text.split('\n')) {
+      if (!line.trim()) continue;
+      if (messages.length >= CHAT_IMPORT_MAX_MESSAGES) break;
+      let rec;
+      try { rec = JSON.parse(line); } catch { skipped += 1; continue; }
+      const type = rec.type || rec.message?.role;
+      const msg = rec.message;
+      if (!msg || (type !== 'user' && type !== 'assistant')) { skipped += 1; continue; }
+      const blocks = Array.isArray(msg.content)
+        ? msg.content
+        : (typeof msg.content === 'string' ? [{ type: 'text', text: msg.content }] : []);
+      const time = rec.timestamp ? (Date.parse(rec.timestamp) || Date.now()) : Date.now();
+      if (type === 'user') {
+        const texts = [];
+        const results = [];
+        for (const b of blocks) {
+          if (b && b.type === 'text' && typeof b.text === 'string') texts.push(b.text);
+          else if (b && b.type === 'tool_result') {
+            results.push({
+              callId: String(b.tool_use_id || b.toolUseId || ''),
+              text: typeof b.content === 'string' ? b.content : JSON.stringify(b.content ?? ''),
+              isError: b.is_error === true,
+            });
+          } else skipped += 1;
+        }
+        if (texts.length) messages.push({ role: 'user', texts, reasoning: [], toolCalls: [], time });
+        for (const r of results) messages.push({ role: 'tool', texts: [r.text], reasoning: [], toolCalls: [], callId: r.callId, isError: r.isError, time });
+      } else {
+        const texts = [];
+        const reasoning = [];
+        const toolCalls = [];
+        for (const b of blocks) {
+          if (b && b.type === 'text' && typeof b.text === 'string') texts.push(b.text);
+          else if (b && b.type === 'thinking' && typeof b.thinking === 'string') reasoning.push(b.thinking);
+          else if (b && b.type === 'tool_use') toolCalls.push({ id: String(b.id || `call-${toolCalls.length}`), name: String(b.name || 'tool'), input: b.input });
+          else skipped += 1;
+        }
+        if (texts.length || reasoning.length || toolCalls.length) {
+          messages.push({ role: 'assistant', texts, reasoning, toolCalls, time });
+        }
+      }
+    }
+    return { messages, skipped };
+  }
+
+  /** 归一化消息 → DSH v4 事件行（seq 连续；消息事件带 surfaceOp）。 */
+  function claudeMessagesToEvents(messages, baseTime) {
+    const rows = [];
+    let seq = 0;
+    let turn = 0;
+    const push = (type, data, surface = false) => {
+      const row = { type, seq, time: baseTime + seq, data };
+      if (surface) row.surfaceOp = 'append';
+      rows.push(row);
+      seq += 1;
+    };
+    for (const m of messages) {
+      turn += 1;
+      push('turn/start', { turn });
+      push('step/start', { turn, step: 1 });
+      if (m.role === 'user') {
+        push('user/message', { id: `u${turn}`, role: 'user', content: m.texts.map((t) => ({ type: 'text', text: t })), source: { kind: 'user' } }, true);
+      } else if (m.role === 'tool') {
+        push('tool/result', {
+          turn,
+          step: 1,
+          message: {
+            id: `t${turn}`,
+            role: 'tool',
+            toolCallId: m.callId,
+            content: [{ type: 'text', text: m.texts.join('') }],
+            source: { kind: 'tool', callId: m.callId },
+            ...(m.isError ? { isError: true } : {}),
+          },
+        }, true);
+      } else {
+        const content = [];
+        for (const r of m.reasoning) content.push({ type: 'reasoning', text: r });
+        for (const t of m.texts) content.push({ type: 'text', text: t });
+        for (const c of m.toolCalls) content.push({ type: 'tool-call', id: c.id, name: c.name, arguments: JSON.stringify(c.input ?? {}) });
+        push('assistant/message', {
+          turn,
+          step: 1,
+          message: { id: `a${turn}`, role: 'assistant', content, source: { kind: 'model', provider: 'claude-code', model: 'imported' } },
+          stream: [],
+        }, true);
+      }
+      push('step/end', { turn, step: 1 });
+      push('turn/end', { turn, reason: { kind: 'completed' } });
+    }
+    return rows;
+  }
+
+  /** 外部聊天来源（v1 只有 Claude Code）。 */
+  async function chatSources() {
+    const list = await listClaudeSessions();
+    const sessions = [];
+    for (const s of list.slice(0, 50)) {
+      try {
+        const parsed = await parseClaudeSession(s.abs);
+        const firstUser = parsed.messages.find((m) => m.role === 'user');
+        sessions.push({
+          id: s.id,
+          file: s.file,
+          project: s.slug,
+          messages: parsed.messages.length,
+          title: firstUser ? String(firstUser.texts[0] || '').slice(0, 60) : '',
+        });
+      } catch { /* 单文件解析失败不影响其它会话 */ }
+    }
+    return {
+      ok: true,
+      source: 'claude-code',
+      detected: list.length > 0,
+      sessions,
+      summary: list.length ? `💬 检测到 ${list.length} 个 Claude Code 会话` : '💬 没有检测到 Claude Code 会话（~/.claude/projects）',
+    };
+  }
+
+  async function buildClaudeImport(sessionId) {
+    const list = await listClaudeSessions();
+    const target = list.find((s) => s.id === sessionId || s.file === sessionId || s.abs === sessionId);
+    if (!target) throw new Error(`找不到 Claude Code 会话：${sessionId}`);
+    const parsed = await parseClaudeSession(target.abs);
+    if (!parsed.messages.length) throw new Error('该会话没有可导入的文本消息');
+    // 宿主要求 time 是安全整数:毫秒时间戳必须取整(mtimeMs 可能是小数)。
+    const rows = claudeMessagesToEvents(parsed.messages, Math.floor(target.mtime || Date.now()));
+    const id = `${target.id}-${stampNow()}`;
+    const header = { type: 'session', version: 4, id, createdAt: Math.floor(target.mtime || Date.now()), isSeeded: false, delegationDepth: 0 };
+    const lines = [JSON.stringify(header), ...rows.map((r) => JSON.stringify(r))];
+    const defect = validateSessionLines(lines);
+    if (defect !== null) throw new Error(`导入会话未通过宿主容器校验，已中止：${defect}`);
+    return { target, parsed, rows, header, id, lines };
+  }
+
+  /** 预览：只读，不写盘。 */
+  async function chatPreview(opts, signal) {
+    const sessionId = typeof opts?.session === 'string' ? opts.session : '';
+    if (!sessionId) throw new Error('缺少会话 id');
+    if (signal?.aborted) throw new Error('操作已取消');
+    const bundle = await buildClaudeImport(sessionId);
+    const userCount = bundle.parsed.messages.filter((m) => m.role === 'user').length;
+    const asstCount = bundle.parsed.messages.filter((m) => m.role === 'assistant').length;
+    const toolCount = bundle.parsed.messages.filter((m) => m.role === 'tool').length;
+    return {
+      ok: true,
+      dryRun: true,
+      source: 'claude-code',
+      session: bundle.target.id,
+      file: bundle.target.file,
+      messages: bundle.parsed.messages.length,
+      userCount,
+      asstCount,
+      toolCount,
+      skipped: bundle.parsed.skipped,
+      events: bundle.rows.length,
+      newId: bundle.id,
+      warnings: ['仅导入文本与工具调用/结果；图片/文件块与私有事件已跳过', '导入为新的 DSH 会话，不改动原会话'],
+      summary: `💬 Claude Code 导入预览\n${bundle.parsed.messages.length} 条消息（用户 ${userCount} / 助手 ${asstCount} / 工具结果 ${toolCount}）→ ${bundle.rows.length} 个事件\n跳过 ${bundle.parsed.skipped} 个非文本块；导入为新会话，原会话不动`,
+    };
+  }
+
+  /** 执行导入：默认 dry-run；confirm:true 才写（新会话目录，绝不覆盖）。 */
+  async function chatApply(opts, signal) {
+    const sessionId = typeof opts?.session === 'string' ? opts.session : '';
+    if (!sessionId) throw new Error('缺少会话 id');
+    if (opts?.confirm !== true) return chatPreview(opts, signal);
+    const bundle = await buildClaudeImport(sessionId);
+    const { dshHome } = paths();
+    const dir = `${dshHome}/sessions/_no-cwd/${encodeSessionSegment(bundle.id)}`;
+    if (pathExists(dir)) throw new Error('目标会话目录已存在，拒绝覆盖');
+    await mkdir(dir, { recursive: true });
+    const headerFrame = zlib.zstdCompressSync(Buffer.from(`${JSON.stringify(bundle.header)}\n`));
+    const bodyFrame = zlib.zstdCompressSync(Buffer.from(`${bundle.rows.map((r) => JSON.stringify(r)).join('\n')}\n`));
+    const file = `${dir}/session.v4.jsonl.zstd`;
+    try {
+      await writeFile(file, Buffer.concat([headerFrame, bodyFrame]));
+      // 回读校验：同一套容器契约（首帧恰好一行 header + seq 连续）
+      const back = decodeZstdLog(await readFile(file));
+      const defect = validateSessionLines(back.lines);
+      if (defect !== null) throw new Error(defect);
+    } catch (err) {
+      await rm(dir, { recursive: true, force: true }).catch(() => {});
+      throw new Error(`写出的会话未通过校验：${String(err && err.message ? err.message : err)}`);
+    }
+    return {
+      ok: true,
+      dryRun: false,
+      newId: bundle.id,
+      path: file,
+      messages: bundle.parsed.messages.length,
+      events: bundle.rows.length,
+      summary: `💬 已导入 Claude Code 会话：${bundle.parsed.messages.length} 条消息（${bundle.rows.length} 个事件）\n新会话 id: ${bundle.id}\n重启 dsh 后可在会话列表看到（仅文本与工具调用/结果）`,
+    };
+  }
+
+  /**
+   * 打开导出 ZIP（必要时用口令解密到备份目录临时文件）。返回 { zipPath, encrypted,
+   * cleanup }；调用方在 finally 里必调 cleanup（解密出的明文 ZIP 不能遗留）。
+   */
+  async function openExportZip(sourcePath, password, signal) {
+    const src = typeof sourcePath === 'string' ? sourcePath : '';
+    if (!src || !src.endsWith('.zip')) throw new Error('导出文件路径无效（需指向 .zip 文件）');
+    if (signal?.aborted) throw new Error('操作已取消');
+    const sidecarPath = `${src}.encrypted.json`;
+    const encrypted = await existsStat(sidecarPath);
+    if (encrypted) {
+      if (!password) throw new Error('这份导出已加密，需要口令才能读取（口令只经面板 RPC 内存态传入，绝不落盘）');
+      const sidecar = JSON.parse(await readFile(sidecarPath, 'utf8'));
+      const ciphertext = await readFile(src);
+      const plain = await decryptBuffer(ciphertext, sidecar, password);
+      const { root } = paths();
+      const tmp = `${root}/.export-dec-${stampNow()}.zip`;
+      await writeBinary(tmp, plain);
+      return { zipPath: tmp, encrypted: true, cleanup: () => rm(tmp, { force: true }) };
+    }
+    return { zipPath: src, encrypted: false, cleanup: null };
+  }
+
+  /** 读取并校验导出 manifest（未知格式/过新版本一律拒绝）。 */
+  async function readExportManifest(zipPath) {
+    let manifest;
+    try {
+      manifest = JSON.parse((await readZipEntry(zipPath, 'manifest.json')).toString('utf8'));
+    } catch (err) {
+      throw new Error(`不是有效的 dsh-config 导出包（缺少 manifest.json）: ${String(err && err.message ? err.message : err)}`);
+    }
+    if (manifest?.format !== EXPORT_FORMAT) throw new Error('不是 dsh-config 导出包（manifest.format 不匹配）——请选择本插件导出的 ZIP');
+    if (Number(manifest?.version) > EXPORT_FORMAT_VERSION) {
+      throw new Error(`导出包版本过新（version=${manifest.version}，本机支持 ${EXPORT_FORMAT_VERSION}）——请升级插件后导入`);
+    }
+    return manifest;
+  }
+
+  /** 兼容性评分：来源平台/家目录/插件版本 vs 本地，结构化给原因（只提示，不阻断）。 */
+  function compatScore(manifest, home) {
+    const reasons = [];
+    let score = 100;
+    const src = manifest?.source || {};
+    if (src.platform && src.platform !== process.platform) {
+      score -= 30;
+      reasons.push('来源平台与本机不同：绝对路径、换行符与权限语义可能需要调整');
+    }
+    if (src.home && src.home !== home) {
+      score -= 25;
+      reasons.push('来源家目录与本机不同：settings 里的绝对路径需要 remap');
+    }
+    if (src.pluginVersion && SELF_META.version !== 'unknown' && semverGt(src.pluginVersion, SELF_META.version)) {
+      score -= 15;
+      reasons.push(`导出由更新版本插件生成（${src.pluginVersion}），本机 ${SELF_META.version}，个别新字段可能被忽略`);
+    }
+    return { score: Math.max(0, score), reasons };
+  }
+
+  /** 按节段聚合条目并探测目标冲突（只读，不写盘）。 */
+  async function buildImportPlan(entries, dshHome) {
+    const sectionStats = new Map();
+    const conflicts = [];
+    for (const e of entries) {
+      if (e.isDirectory || e.name === 'manifest.json') continue;
+      const section = sectionKeyForTop(e.name.split('/')[0]);
+      const cur = sectionStats.get(section) || { files: 0, bytes: 0, conflictNames: [] };
+      cur.files += 1; cur.bytes += e.usize;
+      const targetAbs = `${dshHome}/${e.name}`;
+      if (await existsStat(targetAbs)) {
+        cur.conflictNames.push(e.name);
+        conflicts.push({ name: e.name, rel: e.name, section, exists: true });
+      }
+      sectionStats.set(section, cur);
+    }
+    const sections = [...sectionStats.entries()].map(([key, v]) => ({
+      key, label: sectionLabel(key), files: v.files, bytes: v.bytes,
+      conflicts: v.conflictNames.map((n) => ({ name: n, rel: n, exists: true })),
+    }));
+    return { sections, conflicts };
+  }
+
+  /** 跨机 remap 需求扫描：settings 里出现来源家目录绝对路径时提示（只读）。 */
+  async function remapScan(zipPath, manifest, home) {
+    const srcHome = manifest?.source?.home;
+    if (!srcHome || srcHome === home) return [];
+    const out = [];
+    for (const rel of ['settings.yaml', 'settings.json']) {
+      let text;
+      try { text = (await readZipEntry(zipPath, rel)).toString('utf8'); } catch { continue; }
+      let count = 0;
+      let idx = text.indexOf(srcHome);
+      const sample = new Set();
+      while (idx >= 0 && count < 20) {
+        count += 1;
+        if (sample.size < 3) sample.add(text.slice(Math.max(0, idx - 20), idx + srcHome.length + 20));
+        idx = text.indexOf(srcHome, idx + 1);
+      }
+      if (count) out.push({ section: 'settings', file: rel, count, sample: [...sample] });
+    }
+    return out;
+  }
+
+  /** 导入预览（dry-run）：返回计划（节段 / 冲突 / remap / 兼容性评分），不写任何文件。 */
+  async function importPreview(opts, signal) {
+    const { home, dshHome } = paths();
+    const { zipPath, encrypted, cleanup } = await openExportZip(opts?.sourcePath, opts?.password, signal);
+    try {
+      const manifest = await readExportManifest(zipPath);
+      const entries = await listZip(zipPath);
+      const { sections, conflicts } = await buildImportPlan(entries, dshHome);
+      const remap = await remapScan(zipPath, manifest, home);
+      const compatibility = compatScore(manifest, home);
+      const totalFiles = sections.reduce((s, x) => s + x.files, 0);
+      const summary = `📦 导入预览 —— 只读，还没动磁盘\n来源: ${manifest.source?.host ?? '未知'}（${manifest.source?.platform ?? '未知平台'}）\n将导入 ${totalFiles} 个文件、${sections.length} 个节段${conflicts.length ? `\n⚠️ 其中 ${conflicts.length} 个目标文件已存在（默认保留本机，可在界面逐项选择覆盖）` : ''}${remap.length ? '\n⚠️ 需要跨机绝对路径 remap（见 remap 列表）' : ''}\n兼容性: ${compatibility.score}/100${compatibility.reasons.length ? `（${compatibility.reasons.join('；')}）` : ''}`;
+      return { ok: true, encrypted, manifest, sections, totalFiles, totalBytes: manifest.totalBytes ?? 0, conflicts, remap, compatibility, summary };
+    } finally {
+      if (cleanup) await cleanup().catch(() => {});
+    }
+  }
+
+  /** 导入应用：自动快照 → 解压到暂存 → 按决策拷入 → 校验 → 失败回滚。 */
+  async function importApply(opts, signal) {
+    return withOperationLock('import', () => importApplyInner(opts, signal));
+  }
+
+  async function importApplyInner(opts, signal) {
+    const { dshHome, root } = paths();
+    const { zipPath, encrypted, cleanup } = await openExportZip(opts?.sourcePath, opts?.password, signal);
+    let staging = null;
+    try {
+      const manifest = await readExportManifest(zipPath);
+      const entries = await listZip(zipPath);
+      // 选节段：显式 opts.sections 则用；否则导入全部非凭据节段（凭据需显式点选，默认不碰）
+      const wantedSections = Array.isArray(opts?.sections) && opts.sections.length ? new Set(opts.sections) : null;
+      const decisions = opts?.decisions && typeof opts.decisions === 'object' ? opts.decisions : {};
+      const fileEntries = entries.filter((e) => !e.isDirectory && e.name !== 'manifest.json');
+      const selected = fileEntries.filter((e) => {
+        const section = sectionKeyForTop(e.name.split('/')[0]);
+        if (section === 'credentials') return wantedSections ? wantedSections.has('credentials') : false;
+        return wantedSections ? wantedSections.has(section) : true;
+      });
+      if (!selected.length) throw new Error('没有可导入的内容（未选中任何节段，或所选节段在包里为空）');
+
+      // 决定写集：默认 keep（目标已存在就跳过，绝不静默覆盖）
+      const willWrite = [];
+      const willSkip = [];
+      for (const e of selected) {
+        const targetAbs = `${dshHome}/${e.name}`;
+        const exists = await existsStat(targetAbs);
+        if (exists && decisions[e.name] !== 'overwrite') { willSkip.push(e.name); continue; }
+        willWrite.push({ ...e, targetAbs, conflict: exists });
+      }
+      if (!willWrite.length) {
+        // 全部冲突都选「保留本机」且没有新增文件：这是合法的无操作成功，而非错误。
+        // 明确告知没改任何文件，别让用户以为导入失败。
+        return {
+          ok: true,
+          encrypted,
+          applied: 0,
+          skipped: willSkip.length,
+          overwrote: 0,
+          snapshot: null,
+          remapped: 0,
+          summary: `✅ 导入完成（无需写入）\n  所有 ${willSkip.length} 个选中条目都已存在于本机且选择「保留本机」，未改动任何文件。`,
+        };
+      }
+
+      // 自动快照当前数据（导入前安全网）；失败不阻断，如实告知。
+      let snapshotName = null;
+      try {
+        const snap = await doBackup(undefined, signal, { namePrefix: IMPORT_SNAPSHOT_PREFIX, skipVault: true, skipRotate: true });
+        snapshotName = snap.name;
+        await prunePrefixedSnapshots(IMPORT_SNAPSHOT_PREFIX, 1, snap.name);
+      } catch { /* 快照失败不阻断导入 */ }
+
+      // 测试专用故障注入（test-only）：DSH_BACKUP_IMPORT_FAIL=1 时，在「自动快照完成
+      // 之后、真正写入之前」抛一次错，模拟导入中途失败——零依赖 smoke 据此断言失败
+      // 路径与快照安全网（~/.dsh 未被改动）。生产默认绝不触发：环境变量未显式命中
+      // '1' 时此分支永不进入。
+      if (process.env.DSH_BACKUP_IMPORT_FAIL === '1') {
+        throw new Error('test-only import fault injection (DSH_BACKUP_IMPORT_FAIL=1)');
+      }
+
+      // 解压到暂存目录（extractZip 内 Zip Slip/符号链接/zip bomb/CRC 全套防线），再拷入 ~/.dsh
+      staging = `${root}/.import-stage-${stampNow()}`;
+      await extractZip(zipPath, staging, { names: new Set(willWrite.map((e) => e.name)), signal });
+      const stamp = stampNow();
+      const backups = [];
+      const applied = [];
+      const overwrote = [];
+      try {
+        for (const e of willWrite) {
+          if (signal?.aborted) throw new Error('操作已取消');
+          await mkdir(dirname(e.targetAbs), { recursive: true });
+          if (e.conflict) {
+            const keep = `${e.targetAbs}.pre-import-${stamp}`;
+            await copyFile(e.targetAbs, keep);
+            backups.push({ name: e.name, targetAbs: e.targetAbs, keep });
+          }
+          await copyFile(`${staging}/${e.name}`, e.targetAbs);
+          applied.push(e.name);
+          if (e.conflict) overwrote.push(e.name);
+        }
+      } catch (err) {
+        // 回滚：覆盖的先还原留档，新增的删除；回滚再失败则给出快照/留档指引，绝不静默停在半截。
+        const failed = [];
+        for (const b of backups) {
+          try { await copyFile(b.keep, b.targetAbs); } catch { failed.push(b.name); }
+        }
+        for (const n of applied) {
+          if (!backups.some((b) => b.name === n)) await rm(`${dshHome}/${n}`, { force: true }).catch(() => {});
+        }
+        const snapNote = snapshotName ? `\n已自动快照: ${snapshotName}，可 /backup restore ${snapshotName} 整体回滚。` : '';
+        if (failed.length) {
+          throw new Error(`导入失败并已尽力回滚：${friendlyReason(err)}。部分留档未还原: ${failed.join(', ')}（对应 *.pre-import-${stamp} 留档在原目录旁）。${snapNote}`);
+        }
+        throw new Error(`导入失败，已自动回滚到导入前状态：${friendlyReason(err)}。${snapNote}`);
+      }
+
+      // 校验：写入的文件必须存在（防半截写入被误判成功）
+      const missing = [];
+      for (const e of willWrite) if (!(await existsStat(e.targetAbs))) missing.push(e.name);
+      if (missing.length) throw new Error(`导入校验失败，部分文件未落盘: ${missing.slice(0, 5).join(', ')}（快照: ${snapshotName ?? '未生成'}）`);
+
+      // 跨机 remap：对写入的文本配置做 from→to 前缀替换（settings / cordis）
+      let remapped = 0;
+      if (Array.isArray(opts?.remap) && opts.remap.length) {
+        for (const m of opts.remap) {
+          if (!m || typeof m.from !== 'string' || !m.from || typeof m.to !== 'string') continue;
+          for (const rel of ['settings.yaml', 'settings.json', 'cordis.yml', 'cordis.patch.yml']) {
+            if (!willWrite.some((e) => e.name === rel)) continue;
+            const p = `${dshHome}/${rel}`;
+            if (!(await existsStat(p))) continue;
+            const text = await readFile(p, 'utf8');
+            const next = text.split(m.from).join(m.to);
+            if (next !== text) { await writeFile(p, next, 'utf8'); remapped += 1; }
+          }
+        }
+      }
+
+      // 本地 link:/file: 插件迁移：解包 local-plugins tarball 到 ~/.dsh/local-plugins/ 并改回 file:
+      const localPluginEntries = entries.filter((e) => !e.isDirectory && e.name.startsWith('local-plugins/'));
+      let pluginsRestored = { restored: [], skipped: [] };
+      if (localPluginEntries.length && Array.isArray(manifest?.localPlugins)) {
+        await extractZip(zipPath, dshHome, { names: new Set(localPluginEntries.map((e) => e.name)), signal });
+        pluginsRestored = await restoreLocalPlugins(manifest.localPlugins, signal);
+      }
+
+      const summary = `✅ 导入完成\n  已写入: ${applied.length} 个文件（覆盖 ${overwrote.length}、新增 ${applied.length - overwrote.length}、跳过已存在 ${willSkip.length}）${remapped ? `\n  已 remap: ${remapped} 个配置文件` : ''}${pluginsRestored.restored.length ? `\n  本地插件已装回 file:: ${pluginsRestored.restored.map((p) => p.name).join(', ')}` : ''}${pluginsRestored.skipped.length ? `\n  ⚠️ 本地插件需手动处理: ${pluginsRestored.skipped.map((p) => `${p.name}（${p.reason}）`).join(', ')}` : ''}${snapshotName ? `\n  导入前快照: ${snapshotName}` : '\n  ⚠️ 导入前快照未生成（建议确认无误后手动备份一次）'}${backups.length ? `\n  覆盖的旧文件已留档 *.pre-import-${stamp}（确认后可删）` : ''}\n  ⏸️ 待办: 重启 dsh 生效`;
+      return { ok: true, encrypted, applied: applied.length, skipped: willSkip.length, overwrote: overwrote.length, snapshot: snapshotName, remapped, pluginsRestored, summary };
+    } finally {
+      if (staging) await rm(staging, { recursive: true, force: true }).catch(() => {});
+      if (cleanup) await cleanup().catch(() => {});
+    }
+  }
+
+  // ---------- 会话日志体检（doctor） ----------
+  //
+  // 布局与格式依据宿主内置的 @deepseek-ai/dsh-session-persistence-jsonl：
+  //   <会话根>/--<项目目录>--/<编码后 id>/session.jsonl.zstd（compression:'none' 时为 .jsonl）
+  // zstd 文件是独立帧的拼接：首帧是带校验和的 SessionHeader 行，其后每个追加批一帧。
+  // 两条硬契约都对齐宿主读端：①行级——首行 SessionHeader、seq 连续；②容器级——
+  // 首帧解出来恰好一行 header（宿主 assertZstdHeaderFrame；外部工具把整份日志
+  // 压成单帧时内容完整可解、宿主却拒载，行级校验覆盖不到，必须单独判）。
+  // Node 内置 zstd 解码器不跨帧续读，因此先按 RFC 8878 走帧字节边界
+  // （魔数/帧头/块序列/校验和），再逐帧解出逻辑行。检测目标正是社区高频的
+  // "corrupt session log"灾难：并发写 seq 撞号、坏帧、尾部截断、单帧重写。
+  const ZSTD_MAGIC = 0xfd2fb528;
+  // 会话日志文件名 = 宿主 sessionFormatLogFilename 的形态：session[.v<N>].jsonl[.zstd]
+  // （N≥1 可多位；无 .vN 后缀即第 0 代）。**代数是文件名的一部分、会随格式换代前进**，
+  // 写死具体名字会在换代当天整体失明（#117：v4 机器上 doctor/migrate 一份都看不见），
+  // 故按形态匹配，让新代文件至少进入校验/预检流程（代的判定另见迁移预检）。
+  const SESSION_LOG_RE = /^session(?:\.v([1-9][0-9]*))?\.jsonl(?:\.zstd)?$/;
+  const isSessionLogName = (name) => SESSION_LOG_RE.test(name);
+  /** 从会话日志文件名取格式代；非会话日志名返回 null（无 .vN 后缀即 v0）。 */
+  function sessionLogVersion(name) {
+    const m = SESSION_LOG_RE.exec(name);
+    return m ? Number(m[1] ?? 0) : null;
+  }
+  const SCAN_SKIP_DIRS = new Set(['node_modules', '.system', '.git', 'vault']);
+  const SCAN_MAX_FILES = 4000;
+  const SCAN_MAX_DEPTH = 8;
+  // Node 内置 zstd API 要 v22.15 / v23.8 才进 node:zlib；更老运行时没有这个
+  // 导出。必须用命名空间导入 + 运行时探测——具名导入是静态校验的，在缺导出
+  // 的运行时上会让整个插件模块加载失败，比少一个体检功能严重得多。
+  const HAS_NODE_ZSTD = typeof zlib.zstdDecompressSync === 'function';
+
+  /** 截断超长内容用于缺陷描述。 */
+  function snippet(text, max = 60) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+  }
+
+  /**
+   * 按 RFC 8878 结构走查拼接帧的字节边界（不解压）：返回 [start,end] 区间数组；
+   * 结构不合法（截断/未知魔数/保留位/越界块）抛错。
+   * skippable 帧直接判非法——宿主 scanZstdFrames 拒绝一切非数据帧魔数，
+   * 这类文件宿主整体拒载，容忍它们会造成「doctor 报 OK、宿主编译系统读不了」。
+   */
+  function walkZstdFrames(buf) {
+    const frames = [];
+    let off = 0;
+    while (off < buf.length) {
+      if (buf.length - off < 4) throw new Error(`尾部截断（余 ${buf.length - off} 字节不成帧）`);
+      const magic = buf.readUInt32LE(off);
+      if (magic === ZSTD_MAGIC) {
+        let pos = off + 4;
+        if (pos >= buf.length) throw new Error('帧头描述符缺失');
+        const desc = buf[pos++];
+        if (desc & 0x08) throw new Error('帧头保留位置位');
+        const singleSegment = Boolean(desc & 0x20);
+        const checksum = Boolean(desc & 0x04);
+        const dictSize = [0, 1, 2, 4][desc & 0x03];
+        const fcsSize = singleSegment ? [1, 2, 4, 8][desc >> 6] : [0, 2, 4, 8][desc >> 6];
         if (!singleSegment) pos += 1; // Window_Descriptor
         pos += dictSize + fcsSize;
         if (pos > buf.length) throw new Error('帧头越界');
@@ -2773,6 +4724,10 @@ export function apply(ctx, pluginConfig) {
    * 归档里没有对应条目的文件列入 unrecoverable（提示改用全量恢复）。
    */
   async function runDoctorRepair(selector, signal) {
+    return withOperationLock('doctor-repair', () => runDoctorRepairInner(selector, signal));
+  }
+
+  async function runDoctorRepairInner(selector, signal) {
     const { home, dshHome, root } = paths();
     const scan = await runDoctorScan(signal);
     if (!scan.corruptCount) return { repaired: [], unrecoverable: [], stillBad: [], scanned: scan.scanned, summary: summarizeDoctorScan(scan) };
@@ -2780,6 +4735,12 @@ export function apply(ctx, pluginConfig) {
     const picked = await pickArchive(selector || 'latest');
     const v = await verifyOne(picked.name, home, signal);
     if (!v.ok) throw new Error(`归档校验未通过（${v.note}），定点修复已中止`);
+    // 加密归档的定点修复暂不支持：doctor 定点修复直接从归档解出单个会话文件，
+    // 解密整包再解压的成本与泄密面都更高（明文临时 tar.gz）。这里给清晰指引而非
+    // 让 tar 去啃密文报一堆英文。用户可在面板先恢复（支持口令解密），或用未加密归档。
+    if (await isArchiveEncrypted(picked.name)) {
+      throw new Error('定点修复暂不支持加密归档——请在设置面板用「恢复」先解密恢复，或选一份未加密归档（dsh- 开头且无 🔒）再修复');
+    }
     const base = dshHome.split('/').pop();
     const parent = dshHome.slice(0, -(base.length + 1)) || '/';
     const entries = await safeArchiveEntries(picked.name, signal);
@@ -2803,12 +4764,23 @@ export function apply(ctx, pluginConfig) {
       kept.push(keep);
     }
 
-    // 提取可能半途失败、只替换了一部分目标——对齐恢复流程 #28 的回滚哲学：
-    // 用留档副本尽力还原每个目标的修复前状态；连还原都失败时把留档路径
-    // 交代清楚，绝不静默停在最糟的中间态。
+    // #131（Windows）：bsdtar 遇到「同名已存在对象」会拒绝覆盖（附件对象/硬链接
+    // 目标与活树同名时刷 `Can't unlink already-existing object` 并整条非零退出）。
+    // 改为「解到备份目录下的暂存区 → 只把目标文件 copyFile 到位」，与平台 tar 的
+    // 覆盖语义解耦；同时 guard 住「targets 为空时会退化成整包解压」的危险路径。
+    let stage = null;
     try {
-      const tar = await ctx.subprocess.resolveExecutable('tar');
-      await spawnRun([tar, '-xzf', picked.name, '-C', parentTar(parent), ...targets.map((t) => t.entry)], root, signal);
+      if (targets.length) {
+        stage = `${root}/.repair-stage-${stamp}`;
+        await mkdir(stage, { recursive: true });
+        const tar = await ctx.subprocess.resolveExecutable('tar');
+        await spawnRun([tar, '-xzf', picked.name, '-C', stage, ...targets.map((t) => t.entry)], root, signal);
+        for (const t of targets) {
+          const dest = `${dshHome}/${t.rel}`;
+          await mkdir(dirname(dest), { recursive: true });
+          await copyFile(`${stage}/${t.entry}`, dest);
+        }
+      }
     } catch (err) {
       const restored = new Set();
       for (let i = 0; i < targets.length; i++) {
@@ -2822,6 +4794,8 @@ export function apply(ctx, pluginConfig) {
       }
       const missing = targets.filter((t) => !restored.has(t.rel)).map((t) => t.rel);
       throw new Error(`定点修复失败：${friendlyReason(err)}，且部分现场未自动还原: ${missing.join(', ')}。对应的 *.corrupt-${stamp} 留档仍在原目录旁，手工拷回原位即可`);
+    } finally {
+      if (stage) await rm(stage, { recursive: true, force: true }).catch(() => {});
     }
 
     // 修完复检：从归档解出的副本必须健康，否则如实报告（skipped 不算失败——
@@ -2844,6 +4818,9 @@ export function apply(ctx, pluginConfig) {
   // ---------- 自动备份与 GitHub 同步状态（落盘，重启续跑） ----------
   let autoDispose = null;
   let autoHours = 0;
+  // 每周调度（P3）：[{ day: 1-7 (1=周一..7=周日), time: 'HH:MM' }]，可多个。
+  // 与 autoHours 互斥：设置 weekly 时 autoHours 归 0（反之亦然）。空数组=未设置。
+  let weeklySchedules = [];
   let lastAuto = null;
   let lastAutoAt = null;
   let githubState = { repo: null, lastPush: null, lastError: null };
@@ -2875,6 +4852,41 @@ export function apply(ctx, pluginConfig) {
     return next;
   }
 
+  /**
+   * 旧默认目录 → 新默认目录的一次性改名（0.14.0）。
+   *
+   * 只处理「从未配置过 destination」的用户：≤0.13.4 的默认值
+   * `~/Desktop/dsh-backups` 同盘 rename 成 `~/Desktop/DSH Backups`——原子、
+   * 不拷贝数据、不丢备份；用户显式配置过的目录一律不碰。迁移失败时
+   * paths() 的兜底逻辑会继续用老目录，功能不受影响。
+   */
+  async function migrateLegacyDefaultDir() {
+    const cfg = resolvedConfig();
+    if (cfg.destination !== DEFAULTS.destination) return;
+    const { home } = paths();
+    const expandHome = (p) => (p.startsWith('~') ? `${home}${p.slice(1)}` : p);
+    const target = expandHome(DEFAULTS.destination);
+    if (pathExists(target)) {
+      // 新旧目录同时存在（用户手动建过新目录，或迁移后手动放回了老目录）：
+      // 继续用新默认目录，老目录不自动合并——只提示一次，避免静默丢视角。
+      if (LEGACY_DEFAULT_DESTINATIONS.some((p) => pathExists(expandHome(p)))) {
+        console.warn(`[dsh-backup] 检测到旧备份目录与 ${DEFAULTS.destination} 同时存在，继续使用新目录；旧目录里的备份如需保留请手动移入`);
+      }
+      return;
+    }
+    for (const legacyRaw of LEGACY_DEFAULT_DESTINATIONS) {
+      const legacy = expandHome(legacyRaw);
+      if (!pathExists(legacy)) continue;
+      try {
+        await rename(legacy, target);
+        console.log(`[dsh-backup] 备份目录已改名为 ${DEFAULTS.destination}（旧版默认名不再使用；可在设置面板自定义位置）`);
+      } catch (err) {
+        console.warn(`[dsh-backup] 备份目录改名失败，继续使用旧目录 ${legacyRaw}: ${String(err && err.message ? err.message : err)}`);
+      }
+      return;
+    }
+  }
+
   /**
    * 等待 settings 用户层加载完成（describe 出现 revision）。启动钩子若在
    * settings 装配完成前运行，resolvedConfig 会拿到 base 默认值——升级快照
@@ -2916,7 +4928,7 @@ export function apply(ctx, pluginConfig) {
     // （先到者 rename 走，后到者 ENOENT），UUID 跨实例唯一
     const tmp = `${target}.${randomUUID()}.tmp`;
     try {
-      await writeOwned(tmp, `${JSON.stringify({ hours: autoHours, lastAutoAt, github: githubState, lastTrain, starHinted, lastAutoAttemptAt, lastAutoError })}\n`);
+      await writeOwned(tmp, `${JSON.stringify({ hours: autoHours, weekly: weeklySchedules, lastAutoAt, github: githubState, lastTrain, starHinted, lastAutoAttemptAt, lastAutoError })}\n`);
       await rename(tmp, target);
     } catch (err) {
       await rm(tmp, { force: true }).catch(() => {});
@@ -2975,6 +4987,11 @@ export function apply(ctx, pluginConfig) {
       lastAutoError = e && typeof e === 'object' && typeof e.message === 'string'
         ? { at: typeof e.at === 'string' ? e.at : '', message: e.message }
         : null;
+      // weekly（P3）：数组形态，每项 { day: 1-7, time: 'HH:MM' }；非法项过滤
+      weeklySchedules = Array.isArray(parsed?.weekly)
+        ? parsed.weekly.filter((s) => s && typeof s === 'object' && Number.isInteger(Number(s.day)) && Number(s.day) >= 1 && Number(s.day) <= 7 && /^\d{2}:\d{2}$/.test(String(s.time || '')))
+          .map((s) => ({ day: Number(s.day), time: String(s.time) }))
+        : [];
       // 旧版写的 auto.json 没有这些字段 → 全部按缺失处理，行为与旧版一致
       await refreshNewestArchiveAt();
       return Number.isFinite(h) && h >= 1 && h <= 720 ? Math.floor(h) : 0;
@@ -2994,10 +5011,37 @@ export function apply(ctx, pluginConfig) {
     return Math.max(Number(new Date(lastAutoAt)) || 0, newestArchiveAt || 0);
   }
 
-  /** 下次自动备份触发时间（毫秒）：锚点 + 周期；无锚点从当前时间起算。 */
+  /** 调度是否开启：每小时或每周任一模式非空即开启。 */
+  function autoEnabled() {
+    return autoHours > 0 || weeklySchedules.length > 0;
+  }
+
+  /** 下一个每周触发时刻（毫秒）；无 weekly 返回 Infinity。 */
+  function nextWeeklyOccurrence(now = Date.now()) {
+    let best = Infinity;
+    for (const s of weeklySchedules) {
+      const hh = Number(String(s.time || '').slice(0, 2));
+      const mm = Number(String(s.time || '').slice(3, 5));
+      const day = Number(s.day);
+      if (!Number.isFinite(hh) || !Number.isFinite(mm) || !Number.isInteger(day) || day < 1 || day > 7) continue;
+      const dow = day === 7 ? 0 : day; // ISO(1=周一..7=周日) → JS getDay(0=周日..6=周六)
+      const base = new Date(now);
+      const addDays = (dow - base.getDay() + 7) % 7;
+      const cand = new Date(base);
+      cand.setDate(cand.getDate() + addDays);
+      cand.setHours(hh, mm, 0, 0);
+      if (cand.getTime() < now) cand.setDate(cand.getDate() + 7); // 本周该时刻已过 → 下周
+      if (cand.getTime() < best) best = cand.getTime();
+    }
+    return best;
+  }
+
+  /** 下次自动备份触发时间（毫秒）：每小时与每周取更早者；无锚点从当前时间起算。 */
   function nextAutoAt() {
-    const cycle = autoHours * 3600 * 1000;
-    return Math.max(autoAnchorAt() + cycle, Date.now());
+    let at = Infinity;
+    if (autoHours > 0) at = Math.max(autoAnchorAt() + autoHours * 3600 * 1000, Date.now());
+    if (weeklySchedules.length) at = Math.min(at, nextWeeklyOccurrence());
+    return at === Infinity ? Date.now() : at;
   }
 
   /** 本地时间显示：YYYY-MM-DD HH:mm——不依赖运行时 locale（裸跑环境会落 en-US）。 */
@@ -3015,82 +5059,427 @@ export function apply(ctx, pluginConfig) {
     return `\n⚠️ 上次自动备份未完成${when ? `（${when}）` : ''}：${msg}`;
   }
 
-  function autoSummary() {
-    if (!autoDispose) return `自动备份未开启（/backup auto <N小时> 开启）${autoErrorNote()}`;
-    // 绝对节奏：下次 = 锚点 + 周期；错过（重启间隔超周期）则按现在显示，调度会在启动宽限后补跑。
-    return `自动备份已开启：每 ${autoHours} 小时一次（已持久化，重启续跑），下次 ${formatWhen(nextAutoAt())}${lastAuto ? `；上次自动备份: ${lastAuto}` : ''}${autoErrorNote()}`;
+  function autoSummary() {
+    if (!autoDispose) return `自动备份未开启（/backup auto <N小时> 开启，或 /backup auto weekly <周几-时:分>）${autoErrorNote()}`;
+    // 绝对节奏：下次 = 锚点 + 周期；错过（重启间隔超周期）则按现在显示，调度会在启动宽限后补跑。
+    const mode = weeklySchedules.length
+      ? `每周 ${weeklySchedules.map((s) => `${s.day}-${s.time}`).join('、')}`
+      : `每 ${autoHours} 小时一次`;
+    return `自动备份已开启：${mode}（已持久化，重启续跑），下次 ${formatWhen(nextAutoAt())}${lastAuto ? `；上次自动备份: ${lastAuto}` : ''}${autoErrorNote()}`;
+  }
+
+  /**
+   * 链式 timeout 调度：每次触发后按锚点推算下一次，重启后节奏不重置。
+   * #103 两条断路，缺一不可：
+   *  1. boot 宽限——启动路径的首次触发绝不落在宿主 boot 窗口内（delay≤0 的补跑
+   *     正是把 GB 级 tar 塞进 boot 窗口、拖垮 HostRpc 的元凶）；
+   *  2. 尝试冷却——上次**起跑**（不要求成功）之后 30 分钟（失败按 2^n 退避）内
+   *     不再起跑。锚点落盘，所以"干到一半被强杀 → 下次启动又立刻重跑"的循环断开。
+   */
+  function scheduleAuto(opts = {}) {
+    // 关闭竞态保护：auto off 时 in-flight 备份完成后的续链会以 autoHours=0
+    // 算出 delay=0，形成无限备份循环——关闭后绝不续链。
+    if (!autoEnabled()) return;
+    const cycle = autoHours > 0 ? autoHours * 3600 * 1000 : 7 * 24 * 3600 * 1000;
+    let delay = nextAutoAt() - Date.now();
+    const attemptAt = Number(new Date(lastAutoAttemptAt)) || 0;
+    const cooldown = autoFailStreak > 0
+      ? Math.min(AUTO_RETRY_MS * 2 ** (autoFailStreak - 1), cycle)
+      : AUTO_RETRY_MS;
+    if (attemptAt) delay = Math.max(delay, attemptAt + cooldown - Date.now());
+    if (opts.boot) delay = Math.max(delay, AUTO_BOOT_GRACE_MS);
+    autoDispose = ctx.timeout(async () => {
+      // 无人值守重活串行：与列车快照等其它无人值守任务排队，不并行抢机器
+      await enqueueHeavy(runAutoBackup);
+      scheduleAuto();
+    }, delay);
+  }
+
+  async function runAutoBackup() {
+    // 起跑留痕（先写盘再干活）：进程被强杀也不丢"刚试过"这个事实，
+    // 下次启动据此冷却，不会在 boot 窗口里重跑（#103）。
+    lastAutoAttemptAt = new Date().toISOString();
+    await saveAutoState().catch(() => { /* 记录失败不阻断备份本身 */ });
+    try {
+      const r = await doBackup(autoKeep());
+      lastAuto = r.path.split('/').pop();
+      lastAutoAt = new Date().toISOString();
+      lastAutoError = null;
+      autoFailStreak = 0;
+      newestArchiveAt = Date.now();
+      await saveAutoState();
+      console.log(`[dsh-backup] 自动备份完成: ${r.path} (sha ${r.sha.slice(0, 12)}…)`);
+    } catch (err) {
+      // 失败不再"只推进内存锚点"（旧实现不落盘 → 每次启动 delay≤0 重跑，
+      // 3GB 归档必然失败时就是无限重跑；#103）。改记失败原因 + 退避重试，
+      // 由 lastAutoAttemptAt（已落盘）负责跨重启冷却。
+      autoFailStreak += 1;
+      const message = String(err && err.message ? err.message : err);
+      lastAutoError = { at: new Date().toISOString(), message };
+      await saveAutoState().catch(() => { /* 失败路径写盘也可能失败，不影响内存退避 */ });
+      console.error(`[dsh-backup] 自动备份失败（第 ${autoFailStreak} 次，${Math.round(Math.min(AUTO_RETRY_MS * 2 ** (autoFailStreak - 1), autoHours * 3600 * 1000) / 60000)} 分钟后重试）: ${message}`);
+    }
+  }
+
+  async function setAuto(h) {
+    if (autoDispose) { autoDispose(); autoDispose = null; }
+    autoHours = h;
+    weeklySchedules = []; // 每小时与每周互斥：设置每小时即清掉每周调度
+    // 开启/重设 = 用户要一次基线备份：清掉旧锚点与失败退避，让下次触发落在"现在"
+    lastAutoAt = null;
+    lastAutoAttemptAt = null;
+    newestArchiveAt = 0;
+    autoFailStreak = 0;
+    lastAutoError = null;
+    if (autoEnabled()) scheduleAuto();
+    await saveAutoState();
+  }
+
+  /** 校验并归一化每周调度列表：[{ day: 1-7, time: 'HH:MM' }]；非法返回原因。 */
+  function normalizeWeekly(schedules) {
+    if (schedules === undefined || schedules === null || schedules === '') return { value: [] };
+    if (!Array.isArray(schedules)) return { error: 'weekly 需为 [{ day: 1-7, time: "HH:MM" }] 数组（1=周一..7=周日）' };
+    const out = [];
+    const seen = new Set();
+    for (const s of schedules) {
+      if (!s || typeof s !== 'object') return { error: 'weekly 每项需为 { day, time } 对象' };
+      const day = Number(s.day);
+      const time = String(s.time || '');
+      if (!Number.isInteger(day) || day < 1 || day > 7) return { error: `weekly 的 day 需为 1-7（1=周一..7=周日），收到 ${s.day}` };
+      if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(time)) return { error: `weekly 的 time 需为 HH:MM（00:00-23:59），收到 ${s.time}` };
+      const key = `${day}-${time}`;
+      if (seen.has(key)) continue; // 去重
+      seen.add(key);
+      out.push({ day, time });
+    }
+    return { value: out };
+  }
+
+  /** 设置每周调度（可多个）；空数组=关闭每周模式。与每小时互斥：设置后 autoHours 归 0。 */
+  async function setWeekly(schedules) {
+    const n = normalizeWeekly(schedules);
+    if (n.error) return { ok: false, summary: n.error };
+    if (autoDispose) { autoDispose(); autoDispose = null; }
+    weeklySchedules = n.value;
+    if (weeklySchedules.length) autoHours = 0;
+    lastAutoAt = null;
+    lastAutoAttemptAt = null;
+    newestArchiveAt = 0;
+    autoFailStreak = 0;
+    lastAutoError = null;
+    if (autoEnabled()) scheduleAuto();
+    await saveAutoState();
+    return { ok: true, weekly: weeklySchedules, summary: weeklySchedules.length ? `每周备份已开启：${weeklySchedules.map((s) => `${s.day}-${s.time}`).join('、')}\n${autoSummary()}` : '自动备份已关闭。' };
+  }
+
+  // ---------- 磁盘占用报告 + 分级清理（P3） ----------
+  // 报告归档/快照/同步副本/缓存/暂存各自占用；一键清理只删**可再生缓存**与
+  // **过期备份**，快照与同步数据永不删（它们是不可再生的安全网）。
+
+  async function diskUsage() {
+    const { root } = paths();
+    const cat = { archives: 0, typed: 0, snapshots: 0, sync: 0, vault: 0, cache: 0, other: 0 };
+    const files = { archives: 0, typed: 0, snapshots: 0, sync: 0, vault: 0, cache: 0, other: 0 };
+    async function du(dir) {
+      let total = 0;
+      let count = 0;
+      let dirents;
+      try { dirents = await readdir(dir, { withFileTypes: true }); } catch { return { total, count }; }
+      for (const d of dirents) {
+        if (d.isDirectory()) {
+          const sub = await du(`${dir}/${d.name}`);
+          total += sub.total; count += sub.count;
+        } else if (d.isFile()) {
+          try { total += (await fsStat(`${dir}/${d.name}`)).size; } catch { /* 竞态忽略 */ }
+          count += 1;
+        }
+      }
+      return { total, count };
+    }
+    let dirents;
+    try { dirents = await readdir(root, { withFileTypes: true }); } catch { dirents = []; }
+    for (const d of dirents) {
+      const name = d.name;
+      const isFile = d.isFile();
+      const size = isFile ? await fsStat(`${root}/${name}`).then((s) => s.size, () => 0) : 0;
+      if (name === '.github-sync') { const s = await du(`${root}/${name}`); cat.sync += s.total; files.sync += s.count; }
+      else if (name === 'vault') { const s = await du(`${root}/${name}`); cat.vault += s.total; files.vault += s.count; }
+      else if (name.startsWith('.import-stage-') || name.startsWith('.export-') || name.startsWith('.decrypt-') || name.startsWith('.pull-')) { cat.cache += size; files.cache += 1; }
+      else if (SNAPSHOT_PREFIXES.some((p) => name.startsWith(p))) { cat.snapshots += size; files.snapshots += 1; }
+      else if (name.startsWith(TYPED_PREFIX) && name.endsWith('.tar.gz')) { cat.typed += size; files.typed += 1; }
+      else if (name.startsWith('dsh-') && name.endsWith('.tar.gz')) { cat.archives += size; files.archives += 1; }
+      else if (isFile) { cat.other += size; files.other += 1; }
+    }
+    const labels = { archives: '全量归档', typed: '分类型归档', snapshots: '内部快照', sync: '同步副本', vault: '凭据 vault', cache: '缓存/暂存', other: '其他' };
+    const categories = Object.keys(cat).map((k) => ({ key: k, label: labels[k], bytes: cat[k], files: files[k] }));
+    const total = categories.reduce((s, c) => s + c.bytes, 0);
+    const mb = (b) => `${(b / 1048576).toFixed(1)}MB`;
+    const lines = categories.filter((c) => c.bytes > 0).map((c) => `  ${c.label}: ${mb(c.bytes)}（${c.files} 个）`);
+    return { total, totalText: mb(total), categories, summary: `磁盘占用（备份目录）: 共 ${mb(total)}\n${lines.join('\n') || '  （空）'}` };
+  }
+
+  /** 分级清理：'cache' 只删可再生缓存/暂存；'expired' 再删过期备份（快照/同步/vault 永不删）。 */
+  async function cleanup(scope, signal) {
+    const { root } = paths();
+    const removed = [];
+    const rmdir = (dir) => rm(`${root}/${dir}`, { recursive: true, force: true });
+    // 可再生缓存/暂存：永远安全删除
+    let dirents;
+    try { dirents = await readdir(root, { withFileTypes: true }); } catch { dirents = []; }
+    for (const d of dirents) {
+      const n = d.name;
+      if (n.startsWith('.import-stage-') || n.startsWith('.export-') || n.startsWith('.decrypt-') || n.startsWith('.pull-')) {
+        await rm(`${root}/${n}`, { recursive: true, force: true });
+        removed.push(n);
+      }
+    }
+    if (scope === 'expired') {
+      // 过期备份：keep 窗口外且不在日/周/月/年分层保护内的全量归档才删
+      const keepN = defaultKeep();
+      const all = await listBackups();
+      const tail = all.slice(keepN);
+      const cfg = resolvedConfig();
+      const gfsProtect = gfsProtectedSet(tail, all[0]?.name, {
+        monthly: Number(cfg.gfsMonthly) > 0 ? Math.floor(Number(cfg.gfsMonthly)) : 0,
+        yearly: Number(cfg.gfsYearly) > 0 ? Math.floor(Number(cfg.gfsYearly)) : 0,
+      });
+      const tierProtect = tierProtectedSet(tail, all[0]?.name);
+      const stale = tail.filter((b) => !tierProtect.has(b.name) && !gfsProtect.has(b.name)).map((b) => b.name);
+      if (stale.length) {
+        await removeFiles(stale.flatMap((n) => sidecarsFor(n)), root, signal);
+        removed.push(...stale);
+      }
+    }
+    return { ok: true, removed: removed.length, names: removed, summary: removed.length ? `已清理 ${removed.length} 项（快照/同步/vault 未动）:\n${removed.slice(0, 10).map((n) => `  ${n}`).join('\n')}` : '没有可清理的内容（快照/同步/vault 永不删）。' };
+  }
+
+  // ---------- 操作锁：状态 + 回收入口（P3） ----------
+  async function lockStatus() {
+    const { root } = paths();
+    const lockPath = `${root}/${LOCK_FILE}`;
+    try {
+      const lock = JSON.parse(await readFile(lockPath, 'utf8'));
+      return { held: true, stale: isLockStale(lock), pid: lock.pid, operation: lock.operation, startedAt: lock.startedAt, heartbeatAt: lock.heartbeatAt };
+    } catch (err) {
+      if (err && err.code === 'ENOENT') return { held: false, stale: false, pid: null, operation: null, startedAt: null, heartbeatAt: null };
+      return { held: true, stale: false, pid: null, operation: 'unreadable', startedAt: null, heartbeatAt: null };
+    }
+  }
+
+  async function reclaimLockEntry(force) {
+    const { root } = paths();
+    const r = await reclaimOplock(`${root}/${LOCK_FILE}`, { force: force === true });
+    return { ok: r.reclaimed, summary: r.reclaimed ? `操作锁已回收${r.heldBy ? `（原 pid=${r.heldBy.pid}，operation=${r.heldBy.operation}）` : ''}` : (r.reason || '回收失败'), heldBy: r.heldBy ?? null };
+  }
+
+  // ---------- Profiles 管理（P4b-1：list/create/rename/delete/launch/stop） ----------
+  // 「应用自己的 desktop profile」与面板所在的 web profile 都是宿主内置、只读：
+  // 官方说明应用运行期间命令行改不了它——本插件对二者只标注 app-owned，拒绝任何写/启停。
+  const APP_OWNED_PROFILES = new Set(['desktop', 'web']);
+  /** 独立实例的运行态（内存态 Map：name → { child, pid, startedAt }）。 */
+  const runningProfiles = new Map();
+
+  function profilesDir() {
+    return `${paths().dshHome}/profiles`;
+  }
+
+  /** 校验 profile 名（拒绝空/路径段/非法字符/保留名）。 */
+  function validateProfileName(name) {
+    if (typeof name !== 'string' || !name.trim()) return 'profile 名不能为空';
+    if (!/^[A-Za-z0-9._-]+$/.test(name)) return `profile 名只能含字母数字 . _ -（收到 ${name}）`;
+    if (APP_OWNED_PROFILES.has(name)) return `profile ${name} 是应用内置 profile，只读不可改`;
+    return null;
+  }
+
+  async function profilesList() {
+    const dir = profilesDir();
+    let dirents;
+    try { dirents = await readdir(dir, { withFileTypes: true }); } catch { return []; }
+    const out = [];
+    for (const d of dirents) {
+      if (!d.isDirectory()) continue;
+      let meta = null;
+      try { meta = JSON.parse(await readFile(`${dir}/${d.name}/package.json`, 'utf8')); } catch { meta = null; }
+      const appOwned = APP_OWNED_PROFILES.has(d.name);
+      out.push({
+        name: d.name,
+        version: meta?.version ?? null,
+        appOwned,
+        readonly: appOwned,
+        running: runningProfiles.has(d.name),
+        pid: runningProfiles.get(d.name)?.pid ?? null,
+      });
+    }
+    return out.sort((a, b) => (a.name < b.name ? -1 : 1));
+  }
+
+  async function profileCreate(name) {
+    const err = validateProfileName(name);
+    if (err) return { ok: false, summary: err };
+    const dir = `${profilesDir()}/${name}`;
+    if (await existsStat(dir)) return { ok: false, summary: `profile ${name} 已存在` };
+    await mkdir(dir, { recursive: true });
+    await writeOwned(`${dir}/package.json`, `${JSON.stringify({ name, version: '0.1.0', private: true })}\n`);
+    await writeOwned(`${dir}/cordis.yml`, '# dsh-backup 从内置模板创建的空 profile\n# 在此写插件条目，然后 dsh web --profile <name> 启动\n');
+    return { ok: true, name, summary: `已创建 profile: ${name}（模板：package.json + cordis.yml）` };
+  }
+
+  async function profileRename(oldName, newName) {
+    const errOld = validateProfileName(oldName);
+    if (errOld) return { ok: false, summary: errOld };
+    const errNew = validateProfileName(newName);
+    if (errNew) return { ok: false, summary: errNew };
+    const dir = profilesDir();
+    if (!(await existsStat(`${dir}/${oldName}`))) return { ok: false, summary: `profile ${oldName} 不存在` };
+    if (await existsStat(`${dir}/${newName}`)) return { ok: false, summary: `目标 ${newName} 已存在` };
+    await rename(`${dir}/${oldName}`, `${dir}/${newName}`);
+    return { ok: true, from: oldName, to: newName, summary: `已把 profile ${oldName} 改名为 ${newName}` };
+  }
+
+  /** 硬删（二次确认语义由客户端/CLI --yes 承担；宿主绝不删内置 profile）。 */
+  async function profileDelete(name) {
+    const err = validateProfileName(name);
+    if (err) return { ok: false, summary: err };
+    const dir = `${profilesDir()}/${name}`;
+    if (!(await existsStat(dir))) return { ok: false, summary: `profile ${name} 不存在` };
+    if (runningProfiles.has(name)) return { ok: false, summary: `profile ${name} 有正在运行的独立实例，请先 stop 再删除` };
+    await rm(dir, { recursive: true, force: true });
+    return { ok: true, name, summary: `已硬删 profile: ${name}（不可恢复）` };
+  }
+
+  /** 启动独立实例：detached + unref，绝不把宿主进程拖死；找不到 dsh 给人话。 */
+  async function profileLaunch(name) {
+    const err = validateProfileName(name);
+    if (err) return { ok: false, summary: err };
+    const dir = `${profilesDir()}/${name}`;
+    if (!(await existsStat(dir))) return { ok: false, summary: `profile ${name} 不存在` };
+    if (runningProfiles.has(name)) return { ok: true, pid: runningProfiles.get(name).pid, running: true, summary: `profile ${name} 已在运行（pid=${runningProfiles.get(name).pid}）` };
+    let dsh;
+    try {
+      dsh = await ctx.subprocess.resolveExecutable('dsh');
+    } catch {
+      return { ok: false, summary: '找不到 dsh 命令——请先安装 DeepSeek Harness CLI（npm i -g @deepseek-ai/dsh）或从官方入口启动' };
+    }
+    try {
+      const child = spawn(dsh, ['web', '--profile', name], { detached: true, stdio: 'ignore', cwd: profilesDir() });
+      child.unref();
+      child.on('exit', () => { runningProfiles.delete(name); });
+      runningProfiles.set(name, { child, pid: child.pid, startedAt: new Date().toISOString() });
+      return { ok: true, pid: child.pid, running: true, summary: `已启动独立实例 ${name}（pid=${child.pid}）` };
+    } catch (err) {
+      return { ok: false, summary: `启动失败: ${friendlyReason(err)}` };
+    }
+  }
+
+  /** 停止独立实例（运行态按钮翻转）。 */
+  async function profileStop(name) {
+    const r = runningProfiles.get(name);
+    if (!r) return { ok: true, running: false, summary: `profile ${name} 没有正在运行的独立实例（或已退出）` };
+    try { r.child.kill(); } catch { /* 可能已退出 */ }
+    runningProfiles.delete(name);
+    return { ok: true, running: false, summary: `已停止独立实例 ${name}（pid=${r.pid}）` };
   }
 
-  /**
-   * 链式 timeout 调度：每次触发后按锚点推算下一次，重启后节奏不重置。
-   * #103 两条断路，缺一不可：
-   *  1. boot 宽限——启动路径的首次触发绝不落在宿主 boot 窗口内（delay≤0 的补跑
-   *     正是把 GB 级 tar 塞进 boot 窗口、拖垮 HostRpc 的元凶）；
-   *  2. 尝试冷却——上次**起跑**（不要求成功）之后 30 分钟（失败按 2^n 退避）内
-   *     不再起跑。锚点落盘，所以"干到一半被强杀 → 下次启动又立刻重跑"的循环断开。
-   */
-  function scheduleAuto(opts = {}) {
-    // 关闭竞态保护：auto off 时 in-flight 备份完成后的续链会以 autoHours=0
-    // 算出 delay=0，形成无限备份循环——关闭后绝不续链。
-    if (autoHours <= 0) return;
-    const cycle = autoHours * 3600 * 1000;
-    let delay = nextAutoAt() - Date.now();
-    const attemptAt = Number(new Date(lastAutoAttemptAt)) || 0;
-    const cooldown = autoFailStreak > 0
-      ? Math.min(AUTO_RETRY_MS * 2 ** (autoFailStreak - 1), cycle)
-      : AUTO_RETRY_MS;
-    if (attemptAt) delay = Math.max(delay, attemptAt + cooldown - Date.now());
-    if (opts.boot) delay = Math.max(delay, AUTO_BOOT_GRACE_MS);
-    autoDispose = ctx.timeout(async () => {
-      // 无人值守重活串行：与列车快照等其它无人值守任务排队，不并行抢机器
-      await enqueueHeavy(runAutoBackup);
-      scheduleAuto();
-    }, delay);
+  // ---------- 本地 link:/file: 插件迁移（P4b-1） ----------
+  /** 单个插件打包上限：>100MB 跳过并警告（避免导出包被巨型 node_modules 撑爆）。 */
+  const PLUGIN_PACK_MAX_BYTES = 100 * 1024 * 1024;
+
+  /** 递归计算目录大小（用于 100MB 门槛）。 */
+  async function dirSize(dir) {
+    let total = 0;
+    let dirents;
+    try { dirents = await readdir(dir, { withFileTypes: true }); } catch { return 0; }
+    for (const d of dirents) {
+      if (d.isDirectory()) total += await dirSize(`${dir}/${d.name}`);
+      else if (d.isFile()) total += await fsStat(`${dir}/${d.name}`).then((s) => s.size, () => 0);
+    }
+    return total;
   }
 
-  async function runAutoBackup() {
-    // 起跑留痕（先写盘再干活）：进程被强杀也不丢"刚试过"这个事实，
-    // 下次启动据此冷却，不会在 boot 窗口里重跑（#103）。
-    lastAutoAttemptAt = new Date().toISOString();
-    await saveAutoState().catch(() => { /* 记录失败不阻断备份本身 */ });
-    try {
-      const r = await doBackup(autoKeep());
-      lastAuto = r.path.split('/').pop();
-      lastAutoAt = new Date().toISOString();
-      lastAutoError = null;
-      autoFailStreak = 0;
-      newestArchiveAt = Date.now();
-      await saveAutoState();
-      console.log(`[dsh-backup] 自动备份完成: ${r.path} (sha ${r.sha.slice(0, 12)}…)`);
-    } catch (err) {
-      // 失败不再"只推进内存锚点"（旧实现不落盘 → 每次启动 delay≤0 重跑，
-      // 3GB 归档必然失败时就是无限重跑；#103）。改记失败原因 + 退避重试，
-      // 由 lastAutoAttemptAt（已落盘）负责跨重启冷却。
-      autoFailStreak += 1;
-      const message = String(err && err.message ? err.message : err);
-      lastAutoError = { at: new Date().toISOString(), message };
-      await saveAutoState().catch(() => { /* 失败路径写盘也可能失败，不影响内存退避 */ });
-      console.error(`[dsh-backup] 自动备份失败（第 ${autoFailStreak} 次，${Math.round(Math.min(AUTO_RETRY_MS * 2 ** (autoFailStreak - 1), autoHours * 3600 * 1000) / 60000)} 分钟后重试）: ${message}`);
+  /**
+   * 扫描 profile 依赖里 link:/file: 的本地开发插件，npm pack 打包成 tarball。
+   * 返回 [{ profile, name, spec, status, tarballName?, tarballPath?, warning? }]。
+   * status: packed=已打包 / too-big=超 100MB 跳过 / npm-missing=无 npm 回退 / missing=路径不存在 / pack-failed。
+   */
+  async function scanLocalPlugins(signal) {
+    const { dshHome, root } = paths();
+    const result = [];
+    const profilesRoot = `${dshHome}/profiles`;
+    let dirents;
+    try { dirents = await readdir(profilesRoot, { withFileTypes: true }); } catch { return result; }
+    for (const d of dirents) {
+      if (!d.isDirectory()) continue;
+      const profile = d.name;
+      let pkg;
+      try { pkg = JSON.parse(await readFile(`${profilesRoot}/${profile}/package.json`, 'utf8')); } catch { continue; }
+      const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+      for (const [name, spec] of Object.entries(deps)) {
+        if (typeof spec !== 'string') continue;
+        const m = /^(link|file):(.*)$/.exec(spec);
+        if (!m) continue;
+        const ref = m[2];
+        const abs = ref.startsWith('/') || /^[A-Za-z]:/.test(ref) ? ref : `${profilesRoot}/${profile}/${ref}`;
+        const resolved = resolve(abs);
+        if (!(await existsStat(resolved))) {
+          result.push({ profile, name, spec, status: 'missing', warning: `本地插件 ${name} 路径不存在（${spec}）` });
+          continue;
+        }
+        if (await dirSize(resolved) > PLUGIN_PACK_MAX_BYTES) {
+          result.push({ profile, name, spec, status: 'too-big', warning: `本地插件 ${name} 超过 100MB，跳过打包（新机需手动装）` });
+          continue;
+        }
+        let npm;
+        try { npm = await ctx.subprocess.resolveExecutable(IS_WIN ? 'npm.cmd' : 'npm'); }
+        catch { result.push({ profile, name, spec, status: 'npm-missing', warning: '本机无 npm，保留原 spec（新机需手动装）' }); continue; }
+        const packDir = `${root}/.plugin-pack-${stampNow()}`;
+        await mkdir(packDir, { recursive: true });
+        try {
+          const r = await spawnRun([npm, 'pack', resolved, '--pack-destination', packDir], dshHome, signal);
+          const tarballName = r.out.trim().split('\n').filter((l) => l.endsWith('.tgz')).pop()?.trim();
+          if (!tarballName) throw new Error('npm pack 未产出 .tgz');
+          result.push({ profile, name, spec, status: 'packed', tarballName, tarballPath: `${packDir}/${tarballName}` });
+        } catch (err) {
+          result.push({ profile, name, spec, status: 'pack-failed', warning: `npm pack 失败（${String(err && err.message ? err.message : err).slice(0, 120)}）` });
+        }
+      }
     }
+    return result;
   }
 
-  async function setAuto(h) {
-    if (autoDispose) { autoDispose(); autoDispose = null; }
-    autoHours = h;
-    // 开启/重设 = 用户要一次基线备份：清掉旧锚点与失败退避，让下次触发落在"现在"
-    lastAutoAt = null;
-    lastAutoAttemptAt = null;
-    newestArchiveAt = 0;
-    autoFailStreak = 0;
-    lastAutoError = null;
-    if (h > 0) scheduleAuto();
-    await saveAutoState();
+  /** 导入侧：把打包的本地插件解包到 `<dshHome>/local-plugins/<name>/` 并改回 file:。 */
+  async function restoreLocalPlugins(localPlugins, signal) {
+    const { dshHome, root } = paths();
+    const restored = [];
+    const skipped = [];
+    for (const p of Array.isArray(localPlugins) ? localPlugins : []) {
+      if (p.status !== 'packed' || !p.tarballName) { skipped.push({ name: p.name, reason: p.warning || p.status }); continue; }
+      // 导入包内 tarball 已随 export 打进了 ZIP（importApply 解压到暂存后经 names 落盘到 dshHome 下）
+      const src = `${dshHome}/local-plugins/${p.tarballName}`;
+      if (!(await existsStat(src))) { skipped.push({ name: p.name, reason: 'tarball 不在导入包内' }); continue; }
+      const targetDir = `${dshHome}/local-plugins/${p.name}`;
+      await mkdir(targetDir, { recursive: true });
+      const tar = await ctx.subprocess.resolveExecutable('tar');
+      await spawnRun([tar, '-xzf', src, '-C', parentTar(targetDir)], dshHome, signal);
+      // 把 profile 的 package.json 里 link:/file: 改回 file: 指向解包目录
+      const pkgPath = `${dshHome}/profiles/${p.profile}/package.json`;
+      try {
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+        for (const field of ['dependencies', 'devDependencies']) {
+          if (pkg[field] && typeof pkg[field] === 'object' && pkg[field][p.name]) {
+            pkg[field][p.name] = `file:${targetDir}`;
+          }
+        }
+        await writeOwned(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+      } catch { /* package.json 改不了就跳过，如实标注 */ }
+      restored.push({ name: p.name, profile: p.profile, dir: targetDir });
+    }
+    return { restored, skipped };
   }
 
   // ---------- /backup 命令 ----------
   ctx.commands.register({
     name: 'backup',
-    description: '备份/恢复 DSH 数据；子命令: list | verify [前缀|all] | restore <前缀|latest> [--dry-run] [--sync-deps] | doctor [--repair <前缀|latest>] | migrate-check | auto [N小时|off] | github status|sync|pull|repo|token <token|off> | check-update | update [--profile <名>] | [--keep N]',
+    description: '备份/恢复 DSH 数据；子命令: list | verify [前缀|all] | restore <前缀|latest> [--dry-run] [--sync-deps] | doctor [--repair <前缀|latest>] | migrate-check | auto [N小时|off] | github status|sync|pull|repo|token <token|off> | market list|search|install | foreign list|preview|import | rewind list|preview|apply | chat list|preview|import | check-update | update [--profile <名>] | [--keep N]',
     handler: async (invocation) => {
       const input = invocation.rawInput.trim();
       try {
@@ -3098,13 +5487,87 @@ export function apply(ctx, pluginConfig) {
         const head = parts[0] || '';
         const { home } = paths();
 
+        if (head === 'market') {
+          const sub = parts[1] || 'list';
+          if (sub === 'list' || sub === 'search') {
+            const r = sub === 'search'
+              ? await marketSearch(parts.slice(2).join(' '), invocation.signal)
+              : await marketList(invocation.signal);
+            const lines = r.entries.map((e) => `  ${e.id}  ${e.name}${e.risk === 'high' ? '  ⚠️高风险' : ''}${e.source ? `  来源:${e.source}` : ''}`);
+            return { kind: 'success', text: `${r.summary}${lines.length ? `\n${lines.join('\n')}\n\n安装：/backup market install <id> [--yes]` : ''}` };
+          }
+          if (sub === 'install') {
+            const id = parts[2];
+            if (!id) return { kind: 'error', text: '用法：/backup market install <id> [--yes]' };
+            const r = await marketInstall({ id, confirm: parts.includes('--yes') }, invocation.signal);
+            return { kind: r.ok === false ? 'error' : 'success', text: r.summary };
+          }
+          return { kind: 'error', text: '用法：/backup market list | search <q> | install <id> [--yes]' };
+        }
+
+        if (head === 'foreign') {
+          const sub = parts[1] || 'list';
+          if (sub === 'list') {
+            const r = await foreignSources();
+            const lines = r.sources.map((s) => `  ${s.detected ? '✅' : '·'} ${s.id}  ${s.label}${s.detected ? `（技能 ${s.skills} · 指令 ${s.instructions ? '有' : '无'} · MCP ${s.mcpServers.length}）` : ''}`);
+            return { kind: 'success', text: `${r.summary}\n${lines.join('\n')}\n\n预览：/backup foreign preview <id>；导入：/backup foreign import <id> [--yes]` };
+          }
+          if (sub === 'preview' || sub === 'import') {
+            const sourceId = parts[2];
+            if (!sourceId) return { kind: 'error', text: `用法：/backup foreign ${sub} <来源 id>${sub === 'import' ? ' [--yes]' : ''}` };
+            const r = sub === 'preview'
+              ? await foreignPreview({ source: sourceId }, invocation.signal)
+              : await foreignImport({ source: sourceId, confirm: parts.includes('--yes') }, invocation.signal);
+            return { kind: r.ok === false ? 'error' : 'success', text: r.summary };
+          }
+          return { kind: 'error', text: '用法：/backup foreign list | preview <id> | import <id> [--yes]' };
+        }
+
+        if (head === 'rewind') {
+          const sub = parts[1] || 'list';
+          if (sub === 'list') {
+            const r = await sessionRewindList(invocation.signal);
+            const lines = r.sessions.map((s) => `  ${s.id}  ${s.cwd ? `项目 ${s.cwd}` : ''}  ${s.file}`);
+            return { kind: 'success', text: `${r.summary}${lines.length ? `\n${lines.join('\n')}\n\n预览：/backup rewind preview <id> [seq]；分叉：/backup rewind apply <id> [seq] [--yes]` : ''}` };
+          }
+          if (sub === 'preview' || sub === 'apply') {
+            const id = parts[2];
+            if (!id) return { kind: 'error', text: `用法：/backup rewind ${sub} <会话 id> [seq]${sub === 'apply' ? ' [--yes]' : ''}` };
+            const seqArg = parts[3] && !parts[3].startsWith('--') ? Number(parts[3]) : undefined;
+            const seq = Number.isInteger(seqArg) ? seqArg : undefined;
+            const r = sub === 'preview'
+              ? await sessionRewindPreview(id, seq, invocation.signal)
+              : await sessionRewindApply({ session: id, seq, confirm: parts.includes('--yes') }, invocation.signal);
+            return { kind: r.ok === false ? 'error' : 'success', text: r.summary };
+          }
+          return { kind: 'error', text: '用法：/backup rewind list | preview <id> [seq] | apply <id> [seq] [--yes]' };
+        }
+
+        if (head === 'chat') {
+          const sub = parts[1] || 'list';
+          if (sub === 'list') {
+            const r = await chatSources();
+            const lines = r.sessions.map((s) => `  ${s.id}  ${s.messages} 条  ${s.title ? `「${s.title}」` : ''}`);
+            return { kind: 'success', text: `${r.summary}${lines.length ? `\n${lines.join('\n')}\n\n预览：/backup chat preview <id>；导入：/backup chat import <id> [--yes]` : ''}` };
+          }
+          if (sub === 'preview' || sub === 'import') {
+            const id = parts[2];
+            if (!id) return { kind: 'error', text: `用法：/backup chat ${sub} <会话 id>${sub === 'import' ? ' [--yes]' : ''}` };
+            const r = sub === 'preview'
+              ? await chatPreview({ session: id }, invocation.signal)
+              : await chatApply({ session: id, confirm: parts.includes('--yes') }, invocation.signal);
+            return { kind: r.ok === false ? 'error' : 'success', text: r.summary };
+          }
+          return { kind: 'error', text: '用法：/backup chat list | preview <id> | import <id> [--yes]' };
+        }
+
         if (head === 'list') {
           const all = await listBackups();
           const total = all.reduce((s, b) => s + (b.size || 0), 0);
-          const lines = all.map((b) => `  ${b.name}${b.size !== undefined ? `  ${(b.size / 1048576).toFixed(1)}MB` : ''}`);
+          const lines = all.map((b) => `  ${b.encrypted ? '🔒 ' : ''}${b.name}${b.size !== undefined ? `  ${(b.size / 1048576).toFixed(1)}MB` : ''}`);
           // 内部快照分区展示：升级前（最多 2 份）/ 恢复前（最近 1 份），可按前缀选用
           const snaps = await listSnapshotNames('dsh-pre-');
-          const snapLines = snaps.map((n) => `  ${n}${n.startsWith('dsh-pre-upgrade-') ? '  （升级前快照）' : '  （恢复前快照）'}`);
+          const snapLines = snaps.map((n) => `  ${n}${n.startsWith('dsh-pre-upgrade-') ? '  （升级前快照）' : n.startsWith(IMPORT_SNAPSHOT_PREFIX) ? '  （导入前快照）' : '  （恢复前快照）'}`);
           const snapText = snapLines.length ? `\n\n内部快照（可 restore 前缀选用，不占保留配额）:\n${snapLines.join('\n')}` : '';
           const text = all.length
             ? `已有备份 (${all.length} 份，共 ${(total / 1048576).toFixed(1)}MB):\n${lines.join('\n')}${snapText}\n\n${autoSummary()}`
@@ -3243,6 +5706,103 @@ export function apply(ctx, pluginConfig) {
           return { kind: 'error', text: '用法: /backup github status|sync|pull [--restore <前缀|latest>]|repo <地址|off>' };
         }
 
+        if (head === 'sync') {
+          const channel = parts[1];
+          if (!channel) {
+            const chs = await listSyncChannels();
+            const text = Object.entries(chs).map(([k, c]) => `  ${k}: ${c.configured ? '已配置' : '未配置'}${c.url ? ` (${c.url})` : ''}${c.bucket ? ` (${c.bucket})` : ''}${c.lastPush ? ` · 上次 ${c.lastPush}` : ''}${c.lastError ? ` · ⚠️ ${c.lastError}` : ''}`).join('\n');
+            return { kind: 'success', text: `同步通道:\n${text}\n/backup sync <webdav|s3|gist|github> sync 立即推送` };
+          }
+          const action = parts[2] || 'status';
+          if (action === 'off') {
+            const r = await removeSyncChannel(channel);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          if (action === 'status') {
+            const chs = await listSyncChannels();
+            const c = chs[channel];
+            return { kind: 'success', text: c?.configured ? `通道 ${channel} 已配置: ${JSON.stringify(c)}` : `通道 ${channel} 未配置（/backup sync ${channel} set <JSON> 配置）` };
+          }
+          if (action === 'sync') {
+            const s = await syncNow(channel, invocation.signal);
+            if (s.error) return { kind: 'error', text: `同步失败: ${s.error}` };
+            const text = s.pushed
+              ? `✅ ${channel} 同步完成: 推送 ${s.count ?? 'N'} 个文件，${s.at}${s.gistUrl ? `\nGist: ${s.gistUrl}` : ''}${s.tooBig?.length ? `\n跳过超大文件: ${s.tooBig.join(', ')}` : ''}`
+              : `${channel} 同步: ${s.skipped || '无变更'}${s.tooBig?.length ? `\n跳过超大文件: ${s.tooBig.join(', ')}` : ''}`;
+            return { kind: 'success', text };
+          }
+          if (action === 'set') {
+            const jsonText = parts.slice(3).join(' ').trim();
+            if (!jsonText) return { kind: 'error', text: '用法: /backup sync <channel> set \'{"url":"...",...}\'（JSON 配置，凭据只存本机 0600）' };
+            let cfg;
+            try { cfg = JSON.parse(jsonText); } catch { return { kind: 'error', text: '配置需为合法 JSON 对象' }; }
+            const r = await setSyncChannel(channel, cfg);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          return { kind: 'error', text: '用法: /backup sync <channel> status|sync|set <JSON>|off' };
+        }
+
+        if (head === 'lock') {
+          const arg = parts[1] || 'status';
+          if (arg === 'reclaim') {
+            const r = await reclaimLockEntry(parts.includes('--force'));
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          const st = await lockStatus();
+          if (!st.held) return { kind: 'success', text: '操作锁: 空闲' };
+          return { kind: 'success', text: `操作锁: 已被持有（pid=${st.pid}, operation=${st.operation}${st.stale ? '，已失效（死锁，下次操作会自动回收）' : ''}）\n回收: /backup lock reclaim${st.stale ? '' : ' --force'}（--force 会强删活锁，慎用）` };
+        }
+
+        if (head === 'disk' || head === 'usage') {
+          const arg = parts[1];
+          if (arg === 'clean') { const r = await cleanup('cache', invocation.signal); return { kind: 'success', text: r.summary }; }
+          if (arg === 'clean-expired') { const r = await cleanup('expired', invocation.signal); return { kind: 'success', text: r.summary }; }
+          const u = await diskUsage();
+          return { kind: 'success', text: u.summary };
+        }
+
+        if (head === 'profiles') {
+          const sub = parts[1] || 'list';
+          if (sub === 'list') {
+            const list = await profilesList();
+            const text = list.length
+              ? `Profiles (${list.length}):\n${list.map((p) => `  ${p.name}${p.appOwned ? '（app-owned，只读）' : ''}${p.version ? `  v${p.version}` : ''}${p.running ? `  ▶ 运行中(pid=${p.pid})` : ''}`).join('\n')}`
+              : '还没有 profile（可用 /backup profiles create <名> 创建）';
+            return { kind: 'success', text };
+          }
+          if (sub === 'create') {
+            const name = parts[2];
+            if (!name) return { kind: 'error', text: '用法: /backup profiles create <名>' };
+            const r = await profileCreate(name);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          if (sub === 'rename') {
+            const r = await profileRename(parts[2], parts[3]);
+            if (!parts[2] || !parts[3]) return { kind: 'error', text: '用法: /backup profiles rename <旧名> <新名>' };
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          if (sub === 'delete') {
+            const name = parts[2];
+            if (!name) return { kind: 'error', text: '用法: /backup profiles delete <名> --yes（硬删，不可恢复）' };
+            if (!parts.includes('--yes')) return { kind: 'error', text: `硬删不可恢复——确认删除 ${name} 请加 --yes` };
+            const r = await profileDelete(name);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          if (sub === 'launch') {
+            const name = parts[2];
+            if (!name) return { kind: 'error', text: '用法: /backup profiles launch <名>' };
+            const r = await profileLaunch(name);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          if (sub === 'stop') {
+            const name = parts[2];
+            if (!name) return { kind: 'error', text: '用法: /backup profiles stop <名>' };
+            const r = await profileStop(name);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
+          return { kind: 'error', text: '用法: /backup profiles list|create <名>|rename <旧> <新>|delete <名> --yes|launch <名>|stop <名>' };
+        }
+
         if (head === 'delete' || head === 'rm') {
           const sel = parts[1];
           if (!sel) return { kind: 'error', text: '用法: /backup delete <归档名前缀|latest>（删除不可恢复，需要时可用 /backup 重新备份）' };
@@ -3257,9 +5817,22 @@ export function apply(ctx, pluginConfig) {
             await setAuto(0);
             return { kind: 'success', text: '自动备份已关闭。' };
           }
+          if (arg === 'weekly') {
+            const specs = parts.slice(2).filter(Boolean);
+            if (!specs.length || specs[0] === 'status') return { kind: 'success', text: autoSummary() };
+            if (specs[0] === 'off') { const r = await setWeekly([]); return { kind: r.ok ? 'success' : 'error', text: r.summary }; }
+            const list = [];
+            for (const spec of specs) {
+              const m = /^([1-7])-(\d{2}:\d{2})$/.exec(spec);
+              if (!m) return { kind: 'error', text: `每周时刻格式应为「周几-时:分」（周几 1=周一..7=周日，可多个空格分隔），收到 ${spec}` };
+              list.push({ day: Number(m[1]), time: m[2] });
+            }
+            const r = await setWeekly(list);
+            return { kind: r.ok ? 'success' : 'error', text: r.summary };
+          }
           const h = Number(arg);
           if (!Number.isFinite(h) || h < 1 || h > 720) {
-            return { kind: 'error', text: '小时数需为 1~720 之间的数字（如 /backup auto 12）' };
+            return { kind: 'error', text: '小时数需为 1~720 之间的数字（如 /backup auto 12）；或 /backup auto weekly 1-09:00 5-18:00' };
           }
           await setAuto(h);
           return { kind: 'success', text: `✅ 自动备份已开启：每 ${h} 小时执行一次（保留 ${autoKeep()} 份，已持久化）。\n首次备份正在执行，之后每 ${h} 小时一次。\n${autoSummary()}` };
@@ -3290,6 +5863,155 @@ export function apply(ctx, pluginConfig) {
     },
   });
 
+  // ---------- 配置管理 agent 工具（P4：1 → 5，对齐竞品语义） ----------
+  // 安全不变量：config_restore 默认 dry-run、config_sync_pull 只读不写用户数据、
+  // config_sync_push 是显式写远端、口令/密文值绝不进工具入参/输出/日志。
+
+  /** 列本地回滚快照（恢复前/升级前/导入前内部安全网）：id/时间/来源/状态/条目数。 */
+  async function listRollbackSnapshots(signal) {
+    const { root } = paths();
+    const names = await listSnapshotNames('dsh-pre-');
+    const out = [];
+    for (const name of names) {
+      let meta = null;
+      try { meta = JSON.parse(await readFile(`${root}/${name}.meta.json`, 'utf8')); } catch { /* 边车缺失 */ }
+      const source = name.startsWith('dsh-pre-upgrade-') ? 'upgrade' : name.startsWith(IMPORT_SNAPSHOT_PREFIX) ? 'import' : 'restore';
+      let entries = 0;
+      try { entries = (await safeArchiveEntries(name, signal)).length; } catch { entries = 0; }
+      const size = await fsStat(`${root}/${name}`).then((s) => s.size, () => 0);
+      out.push({ id: name, time: meta?.createdAt ?? null, source, status: 'ok', entries, size });
+    }
+    return out;
+  }
+
+  /** 拉取 diff 预览（零写用户数据：只更新同步缓存工作树，绝不写 ~/.dsh 或本地归档集）。 */
+  async function configSyncPullPreview(channel, signal) {
+    if (channel !== 'github') {
+      return { ok: true, channel, total: 0, missing: [], alreadyHave: 0, summary: `通道 ${channel} 本轮仅支持推送，暂不支持拉取（拉取请用 github）` };
+    }
+    const { root } = paths();
+    const wt = await ensureSyncWorktree(signal);
+    if (wt.reason) return { ok: false, channel, total: 0, missing: [], alreadyHave: 0, summary: wt.reason };
+    const { syncDir, git } = wt;
+    await spawnRun([git, 'fetch', 'origin', 'main'], syncDir, signal);
+    await spawnRun([git, 'reset', '--hard', 'origin/main'], syncDir, signal);
+    let names = [];
+    try {
+      names = (await readdir(syncDir, { withFileTypes: true }))
+        .filter((e) => e.isFile() && /^dsh-[A-Za-z0-9._-]+\.tar\.gz$/.test(e.name))
+        .map((e) => e.name);
+    } catch { names = []; }
+    const missing = [];
+    for (const n of names) if (!(await existsStat(`${root}/${n}`))) missing.push(n);
+    const summary = `远端共 ${names.length} 份备份，本地缺 ${missing.length} 份${missing.length ? `:\n${missing.map((n) => `  ${n}`).join('\n')}` : '（本地均已存在）'}。落地请走 confirm 恢复流程（config_restore）。`;
+    return { ok: true, channel, total: names.length, missing, alreadyHave: names.length - missing.length, summary };
+  }
+
+  ctx.tools.register(defineTool({
+    name: 'config_backup',
+    description: '把 ~/.dsh 配置打包成单文件 ZIP（节段化 settings/ui/providers/plugins/mcp/skills/prompts/workspaces/sessions/credentials + other 兜底）。默认脱敏（凭据不入包）；password 提供时加密（scrypt+AES-256-GCM），并允许 includeCredentials 入包。口令只经工具参数内存态传入，绝不落盘/入日志，密文值绝不进输出。',
+    parameters: {
+      password: { type: 'string', description: '可选口令：提供则加密导出（凭据可入包）；不提供则明文导出且凭据脱敏' },
+      includeCredentials: { type: 'boolean', description: '是否把凭据节段打入导出包（必须配 password 加密，否则拒绝）' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: (_a, v) => [{ type: 'text', text: String(v.summary) }] },
+    execute: async (args, exec) => {
+      const signal = exec && exec.signal ? exec.signal : undefined;
+      try {
+        const password = typeof args?.password === 'string' && args.password ? args.password : undefined;
+        const r = await exportConfig({ password, includeCredentials: args?.includeCredentials === true }, signal);
+        return { ok: true, name: r.name, size: r.size, encrypted: r.encrypted, sections: r.manifest?.sections ?? [], redactedFiles: r.redactedFiles ?? [], summary: r.summary };
+      } catch (err) {
+        return { ok: false, summary: `操作失败: ${friendlyReason(err)}` };
+      }
+    },
+  }));
+
+  ctx.tools.register(defineTool({
+    name: 'config_list_snapshots',
+    description: '列出本地回滚快照（恢复前/升级前/导入前自动拍的内部安全网）。每项给 id/时间/来源/状态/条目数。只读，不写任何文件。',
+    parameters: {},
+    output: { schema: { type: 'object', additionalProperties: true }, render: (_a, v) => [{ type: 'text', text: String(v.summary) }] },
+    execute: async (_args, exec) => {
+      const signal = exec && exec.signal ? exec.signal : undefined;
+      try {
+        const snapshots = await listRollbackSnapshots(signal);
+        const summary = snapshots.length
+          ? `本地回滚快照 ${snapshots.length} 份:\n${snapshots.map((s) => `  ${s.id}（${s.source}，${s.entries} 项${s.time ? `，${s.time}` : ''}）`).join('\n')}`
+          : '暂无回滚快照';
+        return { ok: true, snapshots, summary };
+      } catch (err) {
+        return { ok: false, snapshots: [], summary: `操作失败: ${friendlyReason(err)}` };
+      }
+    },
+  }));
+
+  ctx.tools.register(defineTool({
+    name: 'config_restore',
+    description: '从本地回滚快照恢复（整体替换 ~/.dsh，破坏性）。默认 dry-run=true 只出计划、零写入；confirm:true 才真正执行（执行前自动校验 + 再拍当前数据快照，解压失败自动回滚）。真实恢复前必须先 dry-run 预览并向用户展示确认。',
+    parameters: {
+      snapshot: { type: 'string', description: '快照 id/前缀（config_list_snapshots 里的 id；缺省 latest=最新全量备份）' },
+      confirm: { type: 'boolean', description: 'true=真正执行恢复（破坏性）；false/缺省=仅 dry-run 预览，零写入' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: (_a, v) => [{ type: 'text', text: String(v.summary) }] },
+    execute: async (args, exec) => {
+      const signal = exec && exec.signal ? exec.signal : undefined;
+      try {
+        const selector = typeof args?.snapshot === 'string' && args.snapshot ? args.snapshot : 'latest';
+        const confirm = args?.confirm === true;
+        const r = await restoreArchive(selector, !confirm, signal);
+        return { ok: true, dryRun: !confirm, archive: r.archive, files: r.files, preflight: r.preflight ?? [], summary: summarizeRestore(r) };
+      } catch (err) {
+        return { ok: false, dryRun: args?.confirm !== true, summary: `操作失败: ${friendlyReason(err)}` };
+      }
+    },
+  }));
+
+  ctx.tools.register(defineTool({
+    name: 'config_sync_push',
+    description: '把本地备份集推送到指定同步通道（github/webdav/s3/gist），显式写远端。归档默认脱敏（凭据不进包）；password 提供时先做一份加密全量备份再推送（引擎强制加密后同步）。口令绝不回显/落日志，密文值绝不进输出。',
+    parameters: {
+      channel: { type: 'string', required: true, description: '通道名：github/webdav/s3/gist' },
+      password: { type: 'string', description: '可选口令：提供则先做加密全量备份再推送（强制加密后同步）' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: (_a, v) => [{ type: 'text', text: String(v.summary) }] },
+    execute: async (args, exec) => {
+      const signal = exec && exec.signal ? exec.signal : undefined;
+      try {
+        const channel = typeof args?.channel === 'string' && args.channel ? args.channel : 'github';
+        if (typeof args?.password === 'string' && args.password) {
+          // 强制加密：先做一份加密全量备份（口令内存态），再推远端
+          await doBackup(undefined, signal, { password: args.password });
+        }
+        const s = await syncNow(channel, signal);
+        if (s.error) return { ok: false, summary: `同步失败: ${s.error}` };
+        return { ok: true, pushed: Boolean(s.pushed), count: s.count ?? null, tooBig: s.tooBig ?? [], gistUrl: s.gistUrl ?? null, summary: s.pushed ? `✅ ${channel} 推送完成（${s.count ?? 'N'} 个文件）` : `无变更` };
+      } catch (err) {
+        return { ok: false, summary: `操作失败: ${friendlyReason(err)}` };
+      }
+    },
+  }));
+
+  ctx.tools.register(defineTool({
+    name: 'config_sync_pull',
+    description: '拉取远端备份集的 diff 预览（只下载+分析，绝不写 ~/.dsh 或本地归档集合）。返回远端有哪些、本地缺哪些；落地导入走独立 confirm 流程（config_restore）。webdav/s3/gist 本轮仅推送。',
+    parameters: {
+      channel: { type: 'string', description: '通道名（缺省 github）' },
+    },
+    output: { schema: { type: 'object', additionalProperties: true }, render: (_a, v) => [{ type: 'text', text: String(v.summary) }] },
+    execute: async (args, exec) => {
+      const signal = exec && exec.signal ? exec.signal : undefined;
+      try {
+        const channel = typeof args?.channel === 'string' && args.channel ? args.channel : 'github';
+        const p = await configSyncPullPreview(channel, signal);
+        return { ok: true, ...p };
+      } catch (err) {
+        return { ok: false, summary: `操作失败: ${friendlyReason(err)}` };
+      }
+    },
+  }));
+
+
   // ---------- backup_dsh 模型工具 ----------
   ctx.tools.register(defineTool({
     name: 'backup_dsh',
@@ -3315,7 +6037,7 @@ export function apply(ctx, pluginConfig) {
       try {
         if (mode === 'list') {
           const all = await listBackups();
-          return { ok: true, summary: `已有 ${all.length} 份备份:\n${all.map((b) => `  ${b.name}`).join('\n') || '（无）'}\n\n${autoSummary()}` };
+          return { ok: true, summary: `已有 ${all.length} 份备份:\n${all.map((b) => `  ${b.encrypted ? '🔒 ' : ''}${b.name}`).join('\n') || '（无）'}\n\n${autoSummary()}` };
         }
         if (mode === 'verify') {
           const { home } = paths();
@@ -3406,23 +6128,26 @@ export function apply(ctx, pluginConfig) {
         dshHome,
         keepDefault: defaultKeep(),
         autoHours,
+        weeklySchedules,
         lastAuto,
-        backups: all.map((b) => ({ name: b.name, size: typeof b.size === 'number' ? b.size : null })),
+        backups: all.map((b) => ({ name: b.name, size: typeof b.size === 'number' ? b.size : null, encrypted: Boolean(b.encrypted) })),
         typedBackups,
       };
     },
-    backup: async (keep, types, signal) => {
+    backup: async (keep, types, password, signal) => {
       const validTypes = Array.isArray(types) && types.length ? [...new Set(types.filter((t) => BACKUP_TYPES[t]))] : undefined;
-      const r = await doBackup(keep, signal, validTypes ? { types: validTypes } : {});
+      const pass = typeof password === 'string' && password ? password : undefined;
+      const r = await doBackup(keep, signal, { ...(validTypes ? { types: validTypes } : {}), ...(pass ? { password: pass } : {}) });
       // 面板回执给"成了、叫什么、存哪了"；64 位 sha 全文是噪音（完整值就在
       // 归档旁的 .sha256），路径用文件名——目录已显示在上方总览卡
       return {
         ok: true,
-        summary: `备份完成: ${r.path.split('/').pop()}${validTypes ? `（类型: ${validTypes.join(', ')}${r.hasCredentials ? '，含明文凭据·不进 GitHub 同步' : ''}）` : ''}\nsha256: ${r.sha.slice(0, 16)}…（完整校验值在归档旁的 .sha256 文件）${r.stale ? `\n轮换删除 ${r.stale} 份旧备份（保留 ${r.keep} 份）` : ''}${quarantineNote(r)}`,
+        summary: `备份完成: ${r.path.split('/').pop()}${r.encrypted ? ' 🔒' : ''}${validTypes ? `（类型: ${validTypes.join(', ')}${r.hasCredentials ? '，含明文凭据·不进 GitHub 同步' : ''}）` : ''}\nsha256: ${r.sha.slice(0, 16)}…（完整校验值在归档旁的 .sha256 文件）${r.stale ? `\n轮换删除 ${r.stale} 份旧备份（保留 ${r.keep} 份）` : ''}${quarantineNote(r)}`,
         path: r.path,
         sha: r.sha,
         stale: r.stale,
         keep: r.keep,
+        ...(r.encrypted ? { encrypted: true } : {}),
         ...(validTypes ? { types: validTypes, hasCredentials: Boolean(r.hasCredentials) } : {}),
       };
     },
@@ -3441,10 +6166,11 @@ export function apply(ctx, pluginConfig) {
       }
       return { ok: bad === 0, summary: results.map((r) => `${r.ok ? '✅' : '❌'} ${r.name} — ${r.note}`).join('\n') || '暂无备份可校验。', results };
     },
-    restore: async (selector, dryRun, types, syncDeps, signal) => {
+    restore: async (selector, dryRun, types, syncDeps, password, signal) => {
       try {
         const validTypes = Array.isArray(types) && types.length ? [...new Set(types.filter((t) => BACKUP_TYPES[t]))] : undefined;
-        const r = await restoreArchive(selector || 'latest', Boolean(dryRun), signal, { syncDeps: Boolean(syncDeps), ...(validTypes ? { types: validTypes } : {}) });
+        const pass = typeof password === 'string' && password ? password : undefined;
+        const r = await restoreArchive(selector || 'latest', Boolean(dryRun), signal, { syncDeps: Boolean(syncDeps), ...(validTypes ? { types: validTypes } : {}), ...(pass ? { password: pass } : {}) });
         if (r.dryRun) {
           return { ok: true, dryRun: true, archive: r.archive, files: r.files, sample: r.sample, preflight: r.preflight ?? [], targetExists: r.targetExists, ...(r.merge ? { merge: true, types: r.types, willOverwrite: r.willOverwrite ?? [] } : {}), summary: summarizeRestore(r) };
         }
@@ -3629,6 +6355,130 @@ export function apply(ctx, pluginConfig) {
       const r = await runUpdate(signal, 'web');
       return { ok: r.ok, updated: r.updated, current: r.current ?? null, latest: r.latest ?? null, summary: r.summary };
     },
+    exportConfig: async (options, signal) => {
+      try {
+        return await exportConfig(options || {}, signal);
+      } catch (err) {
+        return { ok: false, summary: friendlyReason(err) };
+      }
+    },
+    importPreview: async (options, signal) => {
+      try {
+        return await importPreview(options || {}, signal);
+      } catch (err) {
+        return { ok: false, summary: friendlyReason(err) };
+      }
+    },
+    importApply: async (options, signal) => {
+      try {
+        return await importApply(options || {}, signal);
+      } catch (err) {
+        return { ok: false, summary: friendlyReason(err) };
+      }
+    },
+    syncStatus: async () => {
+      try {
+        const chs = await listSyncChannels();
+        return { ok: true, channels: chs, summary: Object.entries(chs).map(([k, c]) => `${k}: ${c.configured ? '已配置' : '未配置'}`).join('\n') };
+      } catch (err) {
+        return { ok: false, channels: {}, summary: friendlyReason(err) };
+      }
+    },
+    syncNow: async (channel, signal) => {
+      try {
+        const s = await syncNow(channel, signal);
+        if (s.error) return { ok: false, summary: s.error, ...s };
+        return { ok: true, summary: s.pushed ? `✅ ${channel} 同步完成` : `无变更`, ...s };
+      } catch (err) {
+        return { ok: false, summary: friendlyReason(err) };
+      }
+    },
+    setSyncChannel: async (channel, config) => {
+      try {
+        return await setSyncChannel(channel, config);
+      } catch (err) {
+        return { ok: false, summary: friendlyReason(err) };
+      }
+    },
+    removeSyncChannel: async (channel) => {
+      try {
+        return await removeSyncChannel(channel);
+      } catch (err) {
+        return { ok: false, summary: friendlyReason(err) };
+      }
+    },
+    lockStatus: async () => {
+      try { return { ok: true, ...(await lockStatus()) }; } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    reclaimLock: async (force) => {
+      try { return await reclaimLockEntry(force === true); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    diskUsage: async () => {
+      try { const u = await diskUsage(); return { ok: true, ...u }; } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    cleanup: async (scope, signal) => {
+      try { return await cleanup(scope === 'expired' ? 'expired' : 'cache', signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    setWeekly: async (schedules) => {
+      try { return await setWeekly(schedules); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    about: async () => {
+      try { return { ok: true, ...(await aboutInfo()) }; } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    profilesList: async () => {
+      try { const list = await profilesList(); return { ok: true, profiles: list, summary: `${list.length} 个 profile` }; } catch (err) { return { ok: false, profiles: [], summary: friendlyReason(err) }; }
+    },
+    profileCreate: async (name) => {
+      try { return await profileCreate(name); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    profileRename: async (oldName, newName) => {
+      try { return await profileRename(oldName, newName); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    profileDelete: async (name) => {
+      try { return await profileDelete(name); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    profileLaunch: async (name) => {
+      try { return await profileLaunch(name); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    profileStop: async (name) => {
+      try { return await profileStop(name); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    marketList: async (signal) => {
+      try { return await marketList(signal); } catch (err) { return { ok: false, enabled: false, entries: [], summary: friendlyReason(err) }; }
+    },
+    marketSearch: async (query, signal) => {
+      try { return await marketSearch(query, signal); } catch (err) { return { ok: false, enabled: false, entries: [], summary: friendlyReason(err) }; }
+    },
+    marketInstall: async (options, signal) => {
+      try { return await marketInstall(options || {}, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    foreignSources: async () => {
+      try { return await foreignSources(); } catch (err) { return { ok: false, sources: [], summary: friendlyReason(err) }; }
+    },
+    foreignPreview: async (options, signal) => {
+      try { return await foreignPreview(options || {}, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    foreignImport: async (options, signal) => {
+      try { return await foreignImport(options || {}, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    sessionRewindList: async (signal) => {
+      try { return await sessionRewindList(signal); } catch (err) { return { ok: false, sessions: [], summary: friendlyReason(err) }; }
+    },
+    sessionRewindPreview: async (session, seq, signal) => {
+      try { return await sessionRewindPreview(session, seq, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    sessionRewindApply: async (options, signal) => {
+      try { return await sessionRewindApply(options || {}, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    chatSources: async () => {
+      try { return await chatSources(); } catch (err) { return { ok: false, detected: false, sessions: [], summary: friendlyReason(err) }; }
+    },
+    chatPreview: async (options, signal) => {
+      try { return await chatPreview(options || {}, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
+    chatApply: async (options, signal) => {
+      try { return await chatApply(options || {}, signal); } catch (err) { return { ok: false, summary: friendlyReason(err) }; }
+    },
   };
 
   // 仅在装配了 Typert registry 的 profile（Web）里挂载面板服务；其余 profile 安静跳过。
@@ -3733,10 +6583,13 @@ export function apply(ctx, pluginConfig) {
   // 再继续——命中社区"想试新版怕搞坏"的最大恐惧。首见列车只记录不拍。
   void (async () => {
     await waitForSettingsReady();
+    // 0.14.0：旧默认目录改名（只动从未配置过 destination 的用户）
+    await migrateLegacyDefaultDir();
     await loadStoredGithubToken();
+    await loadSyncChannels();
     const h = await loadAutoState();
-    if (h > 0 && !autoDispose) {
-      autoHours = h;
+    autoHours = h;
+    if (autoEnabled() && !autoDispose) {
       scheduleAuto({ boot: true });
     }
     // 凭据哨兵：宿主首次读档会把扁平布局的 .credentials.yaml 原子替换成