@xiaoyuyu6420/dsh-backup 0.13.2 → 0.13.4

package/lib/index.js

@@ -47,6 +47,7 @@ import { mkdir, open, copyFile, chmod, readdir, readFile, rename, rm, stat as fs
 import { createRequire } from 'node:module';
 import { hostname } from 'node:os';
 import { basename, dirname, join } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
 import { fileURLToPath } from 'node:url';
 import * as zlib from 'node:zlib';
 import { defineTool } from '@deepseek-ai/dsh-tools';
@@ -518,7 +519,7 @@ class BackupPanelService extends TypertRemoteService {
     return this.ops.doctorRepair(selector, signal);
   }
 
-  /** 迁移预检：只读扫描全部会话日志（含 v1/v2/v3 各代），预测升级后哪些会话打不开。 */
+  /** 迁移预检：只读扫描全部会话日志（v0 起各代，按文件名代判定），预测升级后哪些会话打不开。 */
   migrateCheck(signal) {
     return this.ops.migrateCheck(signal);
   }
@@ -610,10 +611,16 @@ export function apply(ctx, pluginConfig) {
 
   // ---------- 工具函数 ----------
   /**
-   * 读取 subprocess 收集的输出流。dsh-subprocess 的收集契约：输出超过
-   * maxBytes（8192）时内存窗口只保留尾部（readFrom 返回 lossy: true），
-   * 完整输出 spill 到 spillPath——restore 的 `tar -tvzf` 校验清单必须看
-   * 全量，否则大归档的校验可被清单前段的恶意条目绕过（8KB 尾窗看不到）。
+   * 读取 subprocess 收集的输出流（诊断/小输出用）。dsh-subprocess 的收集契约：
+   * 输出超过 maxBytes（8192）时内存窗口只保留尾部（readFrom 返回 lossy: true），
+   * 完整输出 spill 到 spillPath。
+   *
+   * ⚠️ **不要用它读体积不可控、且结果参与安全判定的输出**（#119）：spill 自身还有
+   * 上限，宿主对超过上限的流会**丢弃 spill 文件**（`discardSpill()`），此时
+   * `readFrom` 只给内存尾窗、`lossy: true` 且**没有 spillPath**——旧实现把这段
+   * 截断文本原样返回，`tar -tvzf` 校验清单因此把"断在文件名中间的碎片"当成不安全
+   * 条目，整包被拒绝恢复（备份成功、verify 报完整、面板正常列出，只在恢复时炸）。
+   * 这类输出请走 {@link streamListingLines}（原始流逐行消费，无上限）。
    */
   async function collectOutput(col) {
     const read = col?.readFrom(0);
@@ -628,6 +635,65 @@ export function apply(ctx, pluginConfig) {
     return read.text ?? '';
   }
 
+  /**
+   * 逐行消费一条命令的 stdout（`stdio: 'pipe'` 原始流形态），把每一行交给
+   * `onLine`；`onLine` 返回 false 时立即终止子进程并提前返回（"发现违规就不必读完"）。
+   *
+   * 为什么不用有界收集（#119）：见 {@link collectOutput} 的 ⚠️。这里内存只保留
+   * "尚未收尾的一行"，清单多大都不截断，也不会把碎片当成一行；stderr 仍走有界
+   * 收集（只作诊断，几 KB 足够）。
+   */
+  async function streamListingLines(argv, cwd, signal, onLine) {
+    const proc = ctx.subprocess.spawn({
+      argv,
+      cwd,
+      graceMs: 5000,
+      signal,
+      stdio: { stdin: 'ignore', stdout: 'pipe', stderr: { maxBytes: 8192, spill: { maxBytes: 1 << 20 } } },
+    });
+    const stream = proc.stdout;
+    if (!stream) throw new Error('宿主未提供原始输出流（subprocess stdout:"pipe" 不可用）——请升级宿主后重试');
+    // 单行长度的护栏：tar -tv 的一行正常不过几百字节；给足余量后仍设上限，
+    // 避免被构造出的超长名字把 carry 撑成内存炸弹。
+    const MAX_LINE_BYTES = 16 * 1024 * 1024;
+    const decoder = new StringDecoder('utf8');
+    let bytes = 0;
+    let lines = 0;
+    let carry = '';
+    let stopped = false;
+    for await (const chunk of stream) {
+      bytes += chunk.length;
+      carry += decoder.write(chunk);
+      let idx;
+      while ((idx = carry.indexOf('\n')) >= 0) {
+        const line = carry.slice(0, idx);
+        carry = carry.slice(idx + 1);
+        lines += 1;
+        if (onLine(line) === false) { stopped = true; break; }
+      }
+      if (stopped) break;
+      if (carry.length > MAX_LINE_BYTES) throw new Error(`输出单行超过 ${MAX_LINE_BYTES} 字节上限——拒绝继续解析`);
+    }
+    if (stopped) {
+      proc.terminate();
+    } else {
+      carry += decoder.end();
+      if (carry.length) { lines += 1; onLine(carry); }
+    }
+    let err = '';
+    try {
+      err = await collectOutput(proc.collected?.stderr);
+    } catch { /* 诊断文本尽力而为 */ }
+    const outcome = await proc.done;
+    // 取消优先于一切结果分类（与 spawnRun 同款取舍）
+    if (signal?.aborted) throw new Error('操作已取消');
+    if (!stopped) {
+      if (outcome.signal != null) throw new Error(`命令被终止（signal=${outcome.signal}）`);
+      if (outcome.exitCode !== 0) throw new Error(`命令失败 exit=${outcome.exitCode}: ${err}`);
+    }
+    return { bytes, lines, stopped };
+  }
+
   async function spawnRun(argv, cwd, signal) {
     const proc = ctx.subprocess.spawn({
       argv,
@@ -762,17 +828,33 @@ export function apply(ctx, pluginConfig) {
     }
   }
 
+  /** 读回 profile 内实际解析到的本插件版本（pnpm 把直接依赖链接在 profile 的
+   *  node_modules 下）；路径异常或读不到时返回 null，调用方按「无法核对」处理。 */
+  async function installedVersion(profile) {
+    try {
+      const meta = JSON.parse(await readFile(join(paths().dshHome, 'profiles', profile, 'node_modules', SELF_META.name, 'package.json'), 'utf8'));
+      return typeof meta?.version === 'string' && meta.version ? meta.version : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * 一键更新（B）：先拍升级前快照（未过期的退路），再走官方 `dsh plugin
-   * --profile <p> update <pkg>`（pnpm 语义——profile 是 pnpm 项目，插件绝不
-   * 自己覆写依赖文件，否则 lockfile 失配）。完成后提示重启生效：宿主在启动
-   * 时结算 Loader 树，Node 半不可在运行中热替换。
+   * --profile <p> update --latest <pkg>`（pnpm 语义——profile 是 pnpm 项目，
+   * 插件绝不自己覆写依赖文件，否则 lockfile 失配）。完成后提示重启生效：宿主
+   * 在启动时结算 Loader 树，Node 半不可在运行中热替换。
+   *
+   * `--latest` 不可省：pnpm update <pkg> 只在 profile 声明的版本范围内升级
+   * （安装时写入的是 ^x.y.z），跨 minor 会停在旧 minor 上——而升级按钮承诺的
+   * 目标通常正是新 minor，少了它就是「点了更新、版本没动」。命令跑完再读回
+   * profile 内的真实版本核对，不拿 registry 的 latest 冒充结果。
    */
   async function runUpdate(signal, profileArg) {
     const profile = profileArg || 'web';
     const chk = await checkUpdate(signal);
     if (chk.error) {
-      return { ok: false, updated: false, summary: `检查更新失败：${chk.error}\n可手动执行: dsh plugin --profile ${profile} update ${SELF_META.name}` };
+      return { ok: false, updated: false, summary: `检查更新失败：${chk.error}\n可手动执行: dsh plugin --profile ${profile} update --latest ${SELF_META.name}` };
     }
     if (!chk.update) {
       return { ok: true, updated: false, current: chk.current, latest: chk.latest, summary: `已是最新版本 ${chk.current}` };
@@ -788,12 +870,12 @@ export function apply(ctx, pluginConfig) {
     // detectHostTrain 同款定位——`node <入口> plugin ...` 与运行中的宿主同源）
     let argv = null;
     try {
-      argv = [await ctx.subprocess.resolveExecutable('dsh'), 'plugin', '--profile', profile, 'update', SELF_META.name];
+      argv = [await ctx.subprocess.resolveExecutable('dsh'), 'plugin', '--profile', profile, 'update', '--latest', SELF_META.name];
     } catch {
       try {
-        argv = [process.execPath, realpathSync(process.argv[1]), 'plugin', '--profile', profile, 'update', SELF_META.name];
+        argv = [process.execPath, realpathSync(process.argv[1]), 'plugin', '--profile', profile, 'update', '--latest', SELF_META.name];
       } catch {
-        return { ok: false, updated: false, summary: `找不到 dsh 命令，请手动执行: dsh plugin --profile ${profile} update ${SELF_META.name}${snap ? `\n更新前快照已留: ${snap}` : ''}` };
+        return { ok: false, updated: false, summary: `找不到 dsh 命令，请手动执行: dsh plugin --profile ${profile} update --latest ${SELF_META.name}${snap ? `\n更新前快照已留: ${snap}` : ''}` };
       }
     }
     try {
@@ -802,12 +884,26 @@ export function apply(ctx, pluginConfig) {
     } catch (err) {
       return { ok: false, updated: false, summary: `更新失败：${friendlyReason(err)}${snap ? `\n已有升级前快照 ${snap}，可 /backup restore ${snap} 回滚。` : ''}` };
     }
+    // 命令跑完 ≠ 版本已变：profile 里锁着精确版本、pnpm 配置忽略 --latest 等情况
+    // 都会让结果停在旧版，读回真实版本再回执（否则用户重启后仍是旧版，无从解释）。
+    const after = await installedVersion(profile);
+    if (after && after !== chk.latest) {
+      return {
+        ok: false,
+        updated: false,
+        current: after,
+        latest: chk.latest,
+        summary: `更新命令已执行，但 profile 内解析到的仍是 ${after}（目标 ${chk.latest}）。`
+          + `\n请手动执行: dsh plugin --profile ${profile} update --latest ${SELF_META.name}`
+          + (snap ? `\n更新前已留升级前快照 ${snap}。` : ''),
+      };
+    }
     return {
       ok: true,
       updated: true,
-      current: chk.latest,
+      current: after || chk.latest,
       latest: chk.latest,
-      summary: `已更新到 ${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 使新版本生效。`,
     };
   }
 
@@ -1711,7 +1807,29 @@ export function apply(ctx, pluginConfig) {
       }
     }
     if (nameIdx < 0 || nameIdx >= f.length) return null;
-    return { type: f[0][0], name: f.slice(nameIdx).join(' ').replace(/\/$/, '') };
+    const rest = f.slice(nameIdx).join(' ');
+    // tar -tv 的链接形态：硬链接 `<名> link to <目标>`、符号链接 `<名> -> <目标>`。
+    // 必须把目标摘出来单独校验：旧实现把它并进 name，于是硬链接条目的"名字"
+    // 天然含空格与目标路径，必然被判非法而整体拒绝（#112），错误信息里也把
+    // 目标一起印出来。
+    let name = rest;
+    let link = null;
+    const hardAt = rest.indexOf(' link to ');
+    if (hardAt >= 0) {
+      name = rest.slice(0, hardAt);
+      link = rest.slice(hardAt + ' link to '.length);
+    } else {
+      const symAt = rest.lastIndexOf(' -> ');
+      if (symAt >= 0) {
+        name = rest.slice(0, symAt);
+        link = rest.slice(symAt + 4);
+      }
+    }
+    return {
+      type: f[0][0],
+      name: name.replace(/\/$/, ''),
+      link: link === null ? null : link.replace(/\/$/, ''),
+    };
   }
 
   /**
@@ -1772,33 +1890,40 @@ export function apply(ctx, pluginConfig) {
     const { root, dshHome } = paths();
     const base = dshHome.split('/').pop();
     const tar = await ctx.subprocess.resolveExecutable('tar');
-    const listed = await spawnRun([tar, '-tvzf', pickedName], root, signal);
-    // tar 路径穿越防护：逐行解析 -tvzf 输出（双布局，见 parseTarEntry），
-    // 条目必须是普通文件/目录、相对路径且位于备份根目录之下；任一违规
-    // 即整体拒绝，恢复绝不触碰备份根之外的文件。
+    // 清单流式读取（#119）：不用有界收集——大归档的清单超过 spill 上限时会被截断，
+    // 碎片会被误判成"不安全条目"而拒绝整包（详见 streamListingLines 注释）。
     const entries = [];
     const bad = [];
-    for (const line of listed.out.split('\n')) {
+    // 路径检查（反斜杠归一化后再判）：`.dsh/..\..\escape.txt` 与 `/` 分隔的
+    // `..` 段同样拒绝（Windows 风格路径变体）。
+    const insideBase = (p) => Boolean(p)
+      && !p.startsWith('/') && !/^[A-Za-z]:/.test(p)
+      && !p.split('/').includes('..')
+      && (p === base || p.startsWith(`${base}/`));
+    const onLine = (line) => {
       const s = line.trim();
-      if (!s) continue;
+      if (!s) return true;
       const parsed = parseTarEntry(s);
-      // 反斜杠归一化后再做全部路径检查：`.dsh/..\..\escape.txt` 与
-      // `/` 分隔的 `..` 段同样拒绝（Windows 风格路径变体）
       const name = parsed ? parsed.name.replace(/\\/g, '/').replace(/\/$/, '') : null;
-      if (
-        !parsed || !name
-        || (parsed.type !== '-' && parsed.type !== 'd')
-        || name.startsWith('/') || /^[A-Za-z]:/.test(name)
-        || name.split('/').includes('..')
-        || (name !== base && !name.startsWith(`${base}/`))
-      ) {
+      const link = parsed && parsed.link ? parsed.link.replace(/\\/g, '/').replace(/\/$/, '') : null;
+      // 允许的类型：普通文件 '-'、目录 'd'，以及**目标也在备份根内**的硬链接 'h'。
+      // 硬链接是 DSH 附件库（attachments/v1：files/ 与 file-objects/ 同一 inode）的
+      // 正常形态，tar 会把第二个路径写成 'h' 条目——旧实现只放行 -/d，于是**带附件的
+      // 归档一律被判"不安全条目"整体拒绝**，完整恢复/dry-run/分类型合并/doctor 修复/
+      // 救援台全链路失效（#112）。硬链接不能跨文件系统、也不能指向目录，目标同为
+      // 归档内相对路径时解压不会逃出备份根；符号链接（l）、设备等仍一律拒绝。
+      const plainOk = Boolean(parsed) && Boolean(name) && (parsed.type === '-' || parsed.type === 'd') && insideBase(name);
+      const hardOk = Boolean(parsed) && parsed.type === 'h' && insideBase(name) && insideBase(link);
+      if (!plainOk && !hardOk) {
         bad.push(parsed ? name : s);
       } else {
         entries.push(name);
       }
-    }
+      return bad.length === 0; // 发现违规立即停读并终止 tar，不必读完
+    };
+    const listed = await streamListingLines([tar, '-tvzf', pickedName], root, signal, onLine);
     if (bad.length) {
-      throw new Error(`归档包含不安全条目（拒绝恢复）：${bad.slice(0, 3).join(', ')}，恢复已中止`);
+      throw new Error(`归档包含不安全条目（拒绝恢复）：${bad.slice(0, 3).join(', ')}（已读清单 ${listed.lines} 行 / ${listed.bytes} 字节），恢复已中止`);
     }
     return entries;
   }
@@ -2128,7 +2253,17 @@ export function apply(ctx, pluginConfig) {
   // （魔数/帧头/块序列/校验和），再逐帧解出逻辑行。检测目标正是社区高频的
   // "corrupt session log"灾难：并发写 seq 撞号、坏帧、尾部截断、单帧重写。
   const ZSTD_MAGIC = 0xfd2fb528;
-  const SESSION_LOG_NAMES = new Set(['session.jsonl.zstd', 'session.jsonl']);
+  // 会话日志文件名 = 宿主 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;
@@ -2273,7 +2408,7 @@ export function apply(ctx, pluginConfig) {
   }
 
   /** 有界递归收集会话日志文件（相对 ~/.dsh 路径）；跳过依赖/系统目录。 */
-  async function collectSessionLogs(dir, relPrefix, depth, out, names = SESSION_LOG_NAMES) {
+  async function collectSessionLogs(dir, relPrefix, depth, out, isLogName = isSessionLogName) {
     if (depth > SCAN_MAX_DEPTH || out.length >= SCAN_MAX_FILES) return;
     let dirents;
     try {
@@ -2286,8 +2421,8 @@ export function apply(ctx, pluginConfig) {
       const rel = relPrefix ? `${relPrefix}/${d.name}` : d.name;
       if (d.isDirectory()) {
         if (SCAN_SKIP_DIRS.has(d.name)) continue;
-        await collectSessionLogs(`${dir}/${d.name}`, rel, depth + 1, out, names);
-      } else if (names.has(d.name)) {
+        await collectSessionLogs(`${dir}/${d.name}`, rel, depth + 1, out, isLogName);
+      } else if (isLogName(d.name)) {
         out.push({ abs: `${dir}/${d.name}`, rel });
       }
     }
@@ -2371,16 +2506,13 @@ export function apply(ctx, pluginConfig) {
   // （0.1.5-rc.2 校准，与 0.11.2 对齐 isHeaderLine 同一套路），覆盖"解析即判"
   // 的规则；需要重放迁移过程的规则（chunk 折叠溯源、引用重映射、worker 复核）
   // 不在覆盖范围，结果里如实标注。三层判定：fail=会话将打不开；migratable=
-  // 旧代但静态规则全过（首次写开会发布 v3 新代）；ok=已是当前代。
-  const MIGRATE_CURRENT_VERSION = 3;
-  /** 物理代文件名 ↔ 格式代（宿主 sessionFormatLogFilename；文件名与 header 不一致宿主拒载）。 */
-  const MIGRATE_LOG_NAMES = [
-    { name: 'session.jsonl', version: 0 },
-    { name: 'session.v1.jsonl', version: 1 },
-    { name: 'session.v2.jsonl', version: 2 },
-    { name: 'session.v3.jsonl', version: 3 },
-  ];
-  const MIGRATE_LOG_SET = new Set(MIGRATE_LOG_NAMES.flatMap((g) => [g.name, `${g.name}.zstd`]));
+  // 旧代但静态规则全过（首次写开会发布当前代新文件）；ok=已是当前代。
+  //
+  // **校准代（#117）**：宿主会随格式换代推进文件名与 header 的 version（0.1.7 起
+  // 为 v4——迁移包只到 `v3-to-v4`、无 `v4-to-v5`）。此常数是本插件**规则**覆盖到的
+  // 最高代，换代时须同步更新；比它更新的日志只提示、不判"打不开"（见
+  // newer-generation）——"宿主读不读得了"取决于宿主版本，不是我们这张注定滞后的表。
+  const MIGRATE_CALIBRATED_VERSION = 4;
   // 冻结事件清单（RELEASED_V0_EVENT_TYPES / RELEASED_V2_EVENT_TYPES，宿主
   // 按契约不增长旧代清单）；migration 对清单外类型连 ignorable 也拒（#6355）。
   const MIGRATE_V0_EVENT_TYPES = new Set(['agent-preset/selected', 'agent/inbox/spliced', 'approval/asked', 'approval/decided', 'approval/policy', 'assistant/chunk', 'assistant/message', 'command/done', 'command/run', 'compaction/end', 'compaction/prune', 'compaction/start', 'compaction/summary', 'feedback/record', 'goal/change', 'hook/invoked', 'hook/result', 'llm/retry', 'llm/retry-started', 'model/selection', 'permission/preset', 'plan/mode', 'request/context', 'request/header', 'sandbox/mode', 'schedule/change', 'session-log-deepseek/delivery-accepted', 'session/end-seed', 'session/title', 'session/title-llm-request', 'step/end', 'step/start', 'subagent/descriptor', 'subagent/model-selection-policy', 'team/member', 'team/message/delivered', 'team/message/queued', 'team/task', 'todo/write', 'tool-workflow/agent-end', 'tool-workflow/agent-start', 'tool-workflow/run-end', 'tool-workflow/run-start', 'tool/call', 'tool/code-dispatch', 'tool/code-dispatch-start', 'tool/result', 'turn/end', 'turn/start', 'user/message', 'web/deepseek-search-llm-request']);
@@ -2388,14 +2520,26 @@ export function apply(ctx, pluginConfig) {
   /** v0 侧退役类型（pre-react-loop 预发布形态；宿主点名拒绝）。 */
   const MIGRATE_V0_RETIRED_TYPES = new Set(['request/header-delta', 'mode/set']);
   /** 消息来源 kind 白名单（v3 侧 15 类；未知 kind 在 v2→v3 边被拒——#6355 主症状）。 */
-  const MIGRATE_SOURCE_KINDS = new Set(['user', 'plugin', 'model', 'tool', 'agent-instructions', 'session-reference', 'team-message', 'goal', 'skill-invocation', 'skill-catalog', 'coordinator', 'subagent-report', 'subagent-settled', 'webhook', 'agent-message']);
+  /**
+   * 「消息来源 kind」的**已知**集合（#113）。注意语义：宿主的 `source.kind` 是
+   * **可合并扩展的联合类型**——每个生产者在自己的模块里声明自己的 kind，没有
+   * 统一的兜底值，所以任何硬编码清单都**不可能完整**。这里的集合因此只当"已知
+   * 名单"用：命中的静默通过，没命中的记一条**提示**（不再判为"打不开"，见
+   * 下方 unknown-source-kind）——真正会拒载的是旧代**事件类型**的冻结清单。
+   *
+   * 内容来自宿主 `@deepseek-ai/dsh-session-format-v3-to-v4` 自带的
+   * `RENAMED_PRODUCERS` 取值与 `RELEASED_SAME_NAME_PRODUCERS` 名单
+   * （2026-09-29 从 0.2.0-rc.1 实装包逐行核对），外加 `producerKind()` 的兜底
+   * 形态 `plugin:<插件名>`（用前缀匹配，见 MIGRATE_KIND_KNOWN）。
+   */
+  const MIGRATE_SOURCE_KINDS = new Set(['user', 'plugin', 'model', 'tool', 'agent-instructions', 'session-reference', 'team-message', 'goal', 'skill-invocation', 'skill-catalog', 'coordinator', 'subagent-report', 'subagent-settled', 'webhook', 'agent-message', 'compact-checkpoint', 'ptc-mode', 'compact-basic', 'runtime-context', 'system-prompt', 'model-selection', 'plan-mode', 'time-context', 'tmux-context', 'user-approval', 'repeat-tool-reminder', 'tool-cordis', 'cordis-host-runner', 'tool-goal', 'tool-jobs', 'hooks-codex', 'hooks-claude-code', 'schedule', 'dsh-session-title-llm', 'fallback', 'provider']);
   const MIGRATE_MAX_FINDINGS = 3;
+  /** kind 是否在已知名单内：精确命中，或宿主兜底形态 `plugin:<插件名>`（可任意长尾，故用前缀判定）。 */
+  const MIGRATE_KIND_KNOWN = (kind) => MIGRATE_SOURCE_KINDS.has(kind) || kind.startsWith('plugin:');
 
-  /** 从物理文件名推格式代；非代文件名（未来扩展）返回 null。 */
+  /** 非代文件名（未来扩展）返回 null；代的判定与 doctor 共用 SESSION_LOG_RE。 */
   function migrateFilenameVersion(fileName) {
-    const base = fileName.replace(/\.zstd$/, '');
-    const g = MIGRATE_LOG_NAMES.find((x) => x.name === base);
-    return g ? g.version : null;
+    return sessionLogVersion(fileName);
   }
 
   /**
@@ -2413,18 +2557,26 @@ export function apply(ctx, pluginConfig) {
     if (!header || typeof header !== 'object' || typeof header.version !== 'number') return null;
     const sourceVersion = header.version;
     const findings = [];
+    const warnings = [];
     let total = 0;
     const fail = (rule, detail) => {
       total += 1;
       if (findings.length < MIGRATE_MAX_FINDINGS) findings.push({ rule, detail });
     };
-    if (sourceVersion > MIGRATE_CURRENT_VERSION) {
-      fail('newer-than-host', `header version=${sourceVersion} 高于本宿主可读的 v${MIGRATE_CURRENT_VERSION}——日志由更新版本的宿主写出，读/写都会被拒（提示语会要求升级宿主）`);
-      return { sourceVersion, findings, total };
+    // 提示（不判"打不开"）：用于**开放集合**上的命中失败——最典型的是
+    // source.kind（可合并扩展的联合类型，硬编码清单天生补不全，#113）。
+    const warn = (rule, detail) => {
+      if (warnings.length < MIGRATE_MAX_FINDINGS) warnings.push({ rule, detail });
+    };
+    if (sourceVersion > MIGRATE_CALIBRATED_VERSION) {
+      // 更新的格式代：本插件的规则表对它是盲区，但"能不能读"由宿主决定（同代/更新可读、
+      // 降级运行被拒）——按开放集合纪律只提示、不替宿主下"打不开"的判决（#117/#113）。
+      warn('newer-generation', `header version=${sourceVersion} 高于本插件校准到的 v${MIGRATE_CALIBRATED_VERSION}——日志由更新的格式代写出。能否打开取决于宿主：宿主同代或更新即可读，**降级运行会被拒**；若你的宿主已是这一代，说明本插件校准滞后，欢迎反馈。仅提示，不判为打不开`);
+      return { sourceVersion, findings, warnings, total };
     }
     if (fileVersion !== null && fileVersion !== sourceVersion) {
       fail('name-version-mismatch', `文件名标 v${fileVersion}，header 标 v${sourceVersion}——宿主按不一致直接拒载`);
-      return { sourceVersion, findings, total };
+      return { sourceVersion, findings, warnings, total };
     }
     // 事件行静态规则。seq 游标语义与 validateSessionLines 一致：v0 有 packed 行
     //（一条行多个 chunk），v1 起一行一事件。
@@ -2462,14 +2614,22 @@ export function apply(ctx, pluginConfig) {
       if (sourceVersion === 2 && (type === 'tool/code-dispatch' || type === 'tool/code-dispatch-start')) fail('ptc-reserved-v2', `第 ${i + 1} 行 ${type} 是 v3 保留 PTC 标签，v2→v3 拒绝（ignorable 也拒）`);
       if ((sourceVersion === 2 || sourceVersion === 3) && type === 'request/header' && rec.data?.header?.system !== undefined) fail('retired-header-system', `第 ${i + 1} 行 request/header 携带退役的 header.system——v2→v3 无法保留时序地提升它${sourceVersion === 3 ? '，当前代读取同样拒绝' : ''}`);
       const kind = rec?.data?.source?.kind;
-      if (typeof kind === 'string' && !MIGRATE_SOURCE_KINDS.has(kind)) fail('unknown-source-kind', `第 ${i + 1} 行消息来源 kind="${kind}" 不在白名单——v2→v3 边拒绝（社区插件自定义 kind，#6355）`);
+      // kind 只作提示，不作判据（#113）：宿主把它设计成可合并扩展的联合类型，
+      // 每个生产者（含任意社区插件）都能加自己的 kind，且生产端对未知 kind 照读
+      // ——旧实现把"不在白名单"直接判成"打不开"，在一台真实机器上把 81/82 份
+      // 完全健康的日志报成不可打开。
+      if (typeof kind === 'string' && !MIGRATE_KIND_KNOWN(kind)) {
+        warn('unknown-source-kind', `第 ${i + 1} 行消息来源 kind="${kind}" 不在已知名单（宿主为可合并扩展的联合类型，官方/社区插件都能新增）——仅提示，不判为打不开；真正会拒载的是旧代事件类型不在冻结清单内`);
+      }
     }
-    return { sourceVersion, findings, total };
+    return { sourceVersion, findings, warnings, total };
   }
 
   /**
    * 单文件迁移预检：解码（复用 doctor 的帧走查）→ 判代 → 静态规则。
-   * 返回 { verdict: 'fail'|'migratable'|'ok'|'skipped', version, findings, total, reason }。
+   * 返回 { verdict: 'fail'|'migratable'|'ok'|'skipped', version, findings, warnings, total, reason }——
+   * findings 是"判为打不开"的硬伤，warnings 是开放集合上的命中失败（如未知
+   * source.kind），只提示不改变 verdict（#113）。
    */
   async function migrateAnalyzeFile(f) {
     const fileVersion = migrateFilenameVersion(f.abs.split('/').pop());
@@ -2484,8 +2644,8 @@ export function apply(ctx, pluginConfig) {
       if (!lines.length) return { verdict: 'fail', version: fileVersion, findings: [{ rule: 'empty', detail: '解出的逻辑行为空' }], total: 1 };
       const r = migrateAnalyzeLines(lines, fileVersion);
       if (!r) return { verdict: 'skipped', version: fileVersion, findings: [], total: 0, reason: 'header 行不可解析——按损坏处理（doctor 体检覆盖），迁移预检跳过' };
-      if (r.total > 0) return { verdict: 'fail', version: r.sourceVersion, findings: r.findings, total: r.total };
-      return { verdict: r.sourceVersion < MIGRATE_CURRENT_VERSION ? 'migratable' : 'ok', version: r.sourceVersion, findings: [], total: 0 };
+      if (r.total > 0) return { verdict: 'fail', version: r.sourceVersion, findings: r.findings, warnings: r.warnings, total: r.total };
+      return { verdict: r.sourceVersion < MIGRATE_CALIBRATED_VERSION ? 'migratable' : 'ok', version: r.sourceVersion, findings: [], warnings: r.warnings, total: 0 };
     } catch (err) {
       return { verdict: 'skipped', version: fileVersion, findings: [], total: 0, reason: `解码失败（${String(err && err.message ? err.message : err)}）——doctor 体检会按损坏处理` };
     }
@@ -2551,7 +2711,7 @@ export function apply(ctx, pluginConfig) {
     const { dshHome, root } = paths();
     if (signal?.aborted) throw new Error('操作已取消');
     const found = [];
-    await collectSessionLogs(dshHome, '', 0, found, MIGRATE_LOG_SET);
+    await collectSessionLogs(dshHome, '', 0, found);
     const sessions = [];
     for (const f of found) {
       if (signal?.aborted) throw new Error('操作已取消');
@@ -2561,8 +2721,9 @@ export function apply(ctx, pluginConfig) {
     const fails = sessions.filter((s) => s.verdict === 'fail');
     const migratable = sessions.filter((s) => s.verdict === 'migratable');
     const skipped = sessions.filter((s) => s.verdict === 'skipped');
+    const warned = sessions.filter((s) => (s.warnings?.length ?? 0) > 0);
     const lines = [];
-    lines.push(`扫描 ${sessions.length} 个会话日志（含 v1/v2/v3 代）：${fails.length} 个升级后将打不开、${migratable.length} 个旧代待迁移（静态规则全过）、${skipped.length} 个未能判定`);
+    lines.push(`扫描 ${sessions.length} 个会话日志（v0 起各代，按文件名代判定）：${fails.length} 个升级后将打不开、${migratable.length} 个旧代待迁移（静态规则全过）、${skipped.length} 个未能判定${warned.length ? `、${warned.length} 个带提示（不影响打开）` : ''}`);
     if (fails.length) {
       lines.push('');
       for (const s of fails.slice(0, 15)) {
@@ -2574,24 +2735,33 @@ export function apply(ctx, pluginConfig) {
       lines.push('');
       lines.push('升级前建议：先拍一份升级前快照（/backup），坏的会话可从更早归档定点修复（/backup doctor --repair）。');
     }
+    if (warned.length) {
+      lines.push('');
+      lines.push(`ℹ️ ${warned.length} 个日志带提示（**不计入"打不开"**，逐条看原因）：`);
+      for (const s of warned.slice(0, 5)) {
+        for (const w of s.warnings) lines.push(`  · ${s.rel}：${w.detail}`);
+      }
+      if (warned.length > 5) lines.push(`  …另有 ${warned.length - 5} 个文件`);
+    }
     if (!env.hardlink) {
       lines.push('');
-      lines.push(`⚠️ 文件系统不支持硬链接（${env.hardlinkNote}）——宿主发布 v3 新代文件会失败（官方 #6358 场景）：旧会话读得了、写开就报错，且升级无法继续。建议把 ~/.dsh 挪回 APFS/ext4 等本地文件系统。`);
+      lines.push(`⚠️ 文件系统不支持硬链接（${env.hardlinkNote}）——宿主发布新代文件会失败（官方 #6358 场景）：旧会话读得了、写开就报错，且升级无法继续。建议把 ~/.dsh 挪回 APFS/ext4 等本地文件系统。`);
     }
     if (env.credentialsFlat) {
       lines.push('');
       lines.push(`⚠️ .credentials.yaml 还是旧扁平布局——宿主下次读档会把它原子替换成 version:1（不可逆，旧宿主将读不回）。${env.credentialsPreserved ? `已自动存底：${env.credentialsPreserved.replace(`${root}/`, '')}` : '自动存底失败（vault 不可写？），建议立即手动 /backup 一次。'}`);
     }
     lines.push('');
-    lines.push(`覆盖说明：以上为静态规则判定（宿主 ${detectHostTrain() || '未知列车'} 校准）。需要重放迁移过程的检查（chunk 折叠溯源、引用重映射、发布前 worker 复核）不在本版覆盖内——静态全过仍可能在新代发布时被宿主拒载。`);
+    lines.push(`覆盖说明：以上为静态规则判定（宿主 ${detectHostTrain() || '未知列车'} 校准；格式代校准到 v${MIGRATE_CALIBRATED_VERSION}）。需要重放迁移过程的检查（chunk 折叠溯源、引用重映射、发布前 worker 复核）不在本版覆盖内——静态全过仍可能在新代发布时被宿主拒载。`);
     const head = fails.length || !env.hardlink || env.credentialsFlat ? '⚠️' : '✅';
     return {
       scanned: sessions.length,
-      sessions: sessions.map((s) => ({ rel: s.rel, verdict: s.verdict, version: s.version, total: s.total, findings: s.findings, ...(s.reason ? { reason: s.reason } : {}) })),
+      sessions: sessions.map((s) => ({ rel: s.rel, verdict: s.verdict, version: s.version, total: s.total, findings: s.findings, ...(s.warnings?.length ? { warnings: s.warnings } : {}), ...(s.reason ? { reason: s.reason } : {}) })),
       env,
       failCount: fails.length,
       migratableCount: migratable.length,
       skippedCount: skipped.length,
+      warningCount: warned.length,
       summary: `${head} ${lines.join('\n')}`,
     };
   }
@@ -3123,7 +3293,7 @@ export function apply(ctx, pluginConfig) {
   // ---------- backup_dsh 模型工具 ----------
   ctx.tools.register(defineTool({
     name: 'backup_dsh',
-    description: '备份、校验、恢复或体检 DSH 用户数据（~/.dsh 的会话、配置、技能）。凭据文件默认脱敏：不进归档、不进 GitHub 同步，明文只存本机 vault，恢复时自动还原。mode=backup 立即备份（keep 指定保留份数）；mode=list 列出备份；mode=verify 校验完整性（selector=前缀或 all，缺省最新一份）；mode=restore 恢复（selector=前缀或 latest，syncDeps 恢复后重装 profile 依赖；恢复前自动校验并快照当前数据，解压失败自动还原；真实恢复前必须先 dryRun=true 预览并向用户展示确认）；mode=auto 设置定时备份（hours 间隔小时数，0=关闭，缺省查询）；mode=doctor 会话日志体检——检测损坏的会话历史（seq 撞号/坏帧/截断），repair=true 时从 selector 归档定点修复；mode=migrate 迁移预检——静态扫描全部代会话日志（含 v1/v2/v3 代），预测宿主升级后哪些会话会打不开、挂在哪条规则，并探测文件系统硬链接支持与凭据文件旧布局',
+    description: '备份、校验、恢复或体检 DSH 用户数据（~/.dsh 的会话、配置、技能）。凭据文件默认脱敏：不进归档、不进 GitHub 同步，明文只存本机 vault，恢复时自动还原。mode=backup 立即备份（keep 指定保留份数）；mode=list 列出备份；mode=verify 校验完整性（selector=前缀或 all，缺省最新一份）；mode=restore 恢复（selector=前缀或 latest，syncDeps 恢复后重装 profile 依赖；恢复前自动校验并快照当前数据，解压失败自动还原；真实恢复前必须先 dryRun=true 预览并向用户展示确认）；mode=auto 设置定时备份（hours 间隔小时数，0=关闭，缺省查询）；mode=doctor 会话日志体检——检测损坏的会话历史（seq 撞号/坏帧/截断），repair=true 时从 selector 归档定点修复；mode=migrate 迁移预检——静态扫描全部代会话日志（v0 起各代），预测宿主升级后哪些会话会打不开、挂在哪条规则，并探测文件系统硬链接支持与凭据文件旧布局',
     parameters: {
       mode: { type: 'string', required: true, enum: ['backup', 'list', 'verify', 'restore', 'auto', 'doctor', 'migrate'], description: 'backup=执行备份，list=列出备份，verify=校验完整性，restore=恢复，auto=定时备份，doctor=会话日志体检，migrate=升级迁移预检' },
       keep: { type: 'number', description: '保留的备份份数（mode=backup，默认 7）' },
@@ -3188,8 +3358,11 @@ export function apply(ctx, pluginConfig) {
             failCount: r.failCount,
             migratableCount: r.migratableCount,
             skippedCount: r.skippedCount,
+            warningCount: r.warningCount ?? 0,
             summary: r.summary,
-            sessions: r.sessions.filter((s) => s.verdict === 'fail').map((s) => ({ path: s.rel, version: s.version, findings: s.findings })),
+            // fail 项照旧全带；带提示（不判打不开）的条目也带上 warnings——否则
+            // UI 只能看到"没问题"，用户无从知道有哪些开放集合上的命中失败（#113）。
+            sessions: r.sessions.filter((s) => s.verdict === 'fail' || s.warnings?.length).map((s) => ({ path: s.rel, version: s.version, findings: s.findings, ...(s.warnings?.length ? { warnings: s.warnings } : {}) })),
             env: r.env,
           };
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xiaoyuyu6420/dsh-backup",
-  "version": "0.13.2",
-  "description": "一键备份与恢复 DeepSeek Harness（dsh）的全部用户数据（~/.dsh）：定时自动备份、升级快照、会话日志体检修复、迁移预检、宿主起不来也能用的救援通道、凭据脱敏、GitHub 同步跨机迁移，附可视化面板。 One command to back up & restore all of ~/.dsh: /backup, scheduled auto-backup, upgrade snapshots, session doctor & repair, migrate precheck, out-of-process rescue console, credential redaction, GitHub sync.",
+  "version": "0.13.4",
+  "description": "一条命令备份、恢复与迁移 DeepSeek Harness（dsh）的全部数据（~/.dsh：会话、设置、插件、MCP、技能）：定时自动备份、升级前快照、换机迁移、会话日志体检修复、宿主起不来也能用的进程外救援；凭据默认脱敏只存本机。 Backup, restore & migrate all DeepSeek Harness (~/.dsh) data — sessions, settings, plugins, MCP, skills: scheduled backups, pre-upgrade snapshots, cross-machine migration, session-log doctor, out-of-process rescue console; credentials redacted to a local-only vault.",
   "type": "module",
   "packageManager": "pnpm@11.24.0",
   "main": "lib/index.js",
@@ -43,12 +43,24 @@
     "备份",
     "restore",
     "恢复",
+    "migration",
+    "迁移",
+    "换机",
     "schedule",
     "自动备份",
     "cross-platform",
+    "cross-machine",
     "rescue",
     "doctor",
     "upgrade-snapshot",
+    "mcp",
+    "skills",
+    "技能",
+    "sessions",
+    "会话",
+    "workspace",
+    "工作区",
+    "vault",
     "数据安全"
   ],
   "peerDependencies": {