dsh-config-manager 0.1.76 → 0.1.77

package/lib/ui/rollback-view.js

@@ -419,6 +419,54 @@ export function rollbackPreviewScope(files, removals) {
     }
     return { files: files.length, added, removed, removals: removals.length };
 }
+/** 从预览推出可勾选行（只读；绝不改任何判定） */
+export function rollbackSelectionRows(preview) {
+    const files = preview?.workspace?.files;
+    if (!Array.isArray(files))
+        return [];
+    const out = [];
+    for (const file of files) {
+        if (file === null || typeof file !== 'object')
+            continue;
+        const path = typeof file.path === 'string' ? file.path : '';
+        if (path === '')
+            continue;
+        const row = { path, parts: splitRollbackPath(path), foreign: file.foreign === true };
+        if (row.foreign && typeof file.foreignSessionId === 'string' && file.foreignSessionId !== '') {
+            row.foreignSessionId = file.foreignSessionId;
+        }
+        out.push(row);
+    }
+    return out;
+}
+/**
+ * 默认勾选 = **非 foreign** 的行（B 的自动隔离口径）。用户可在弹窗里逐个改回去。
+ *
+ * 为什么要在这里定而不在组件里：同一条默认值要在面板与聊天两个入口一致，
+ * 且「默认排除别的会话的改动」是产品决定，必须可测。
+ */
+export function rollbackDefaultSelection(rows) {
+    return rows.filter((row) => !row.foreign).map((row) => row.path);
+}
+/**
+ * 勾选集 → `onlyPaths`：
+ *  · **全选**（含空清单）⇒ `null`（不传字段 = 走既有全量口径，老宿主也照样工作）；
+ *  · 真的少勾 ⇒ 把选中的清单原样传给宿主（空数组由调用方拦：宿主侧它是 400）。
+ */
+export function rollbackOnlyPaths(rows, selected) {
+    if (rows.length === 0)
+        return null;
+    const chosen = new Set(selected);
+    const picked = rows.filter((row) => chosen.has(row.path)).map((row) => row.path);
+    return picked.length === rows.length ? null : picked;
+}
+/** 该不该拦住提交：清单非空、却一个都没勾（宿主会把空数组当 400） */
+export function rollbackSelectionBlocksSubmit(rows, selected) {
+    if (rows.length === 0)
+        return false;
+    const chosen = new Set(selected);
+    return !rows.some((row) => chosen.has(row.path));
+}
 /**
  * 差异无法逐行展示时的字典键（本层**只回键**，文案在字典里）。
  * 未知 / 缺失原因回落 null —— 调用方按「未知原因」出话，绝不回落成「没有差异」（那是另一件事）。
@@ -682,6 +730,13 @@ export function rollbackRewindRows(result) {
             childSessionId,
             detail: redactLines(segment.detail),
             guidance: rollbackGuidanceRows(segment.guidance),
+            foreignSkipped: numberOrNull(segment.foreignSkipped) ?? 0,
+            selectionSkipped: numberOrNull(segment.selectionSkipped) ?? 0,
+            mergedCount: numberOrNull(segment.mergedCount) ?? 0,
+            conflictCount: numberOrNull(segment.conflictCount) ?? 0,
+            conflictPaths: redactLines(segment.conflictPaths),
+            unavailableCount: numberOrNull(segment.unavailableCount) ?? 0,
+            concurrentCount: numberOrNull(segment.concurrentCount) ?? 0,
         };
     });
 }

package/lib/ui/selection-model.d.ts

@@ -15,7 +15,8 @@
  * 单元 id 由宿主侧 ConfigAdapter.listUnits() 产出，与导入侧 PlanItem.id 同一命名空间。
  */
 import type { SectionId } from '../schema/types.ts';
-import type { ImportPlan, PlanItem, PlanItemKind, Portability } from '../core/types.ts';
+import type { ImportPlan, PlanItem, PlanItemKind, PluginAreaRef, Portability } from '../core/types.ts';
+import type { ExportGroup } from './types.ts';
 /** 一个可单独勾选的最小单元（来自 /export-preview 的 items）。 */
 export interface SelectionUnit {
     id: string;
@@ -63,6 +64,14 @@ export interface SelectionUnit {
      * 而不是把 `session-<uuid>` 当标题（用户要求「始终用对话标题」）。文案由界面按当前语言解析。
      */
     blank?: boolean;
+    /**
+     * 该插件**声明的**第三方数据区域（宿主下发；只有 `plugin:<包名>` 单元可能有值）。
+     *
+     * 用途：「按插件看」视图的树骨架 —— 静态知识（内置来源表 + 插件自述 dsh.dataDirs），
+     * **零数据目录 I/O**；体积与「磁盘上到底有没有」等该分区清单到货后再填。
+     * 纯展示字段，不参与勾选/导出契约（契约只认 id）。缺省 = 该插件没有已知关联（不猜）。
+     */
+    relatedAreas?: readonly PluginAreaRef[];
 }
 /** 一个分区及其可勾选单元；units 为空 = 本分区不可细分（UI 只给整体开关）。 */
 export interface SelectionSection {
@@ -91,6 +100,14 @@ export interface SelectionSection {
     portability?: Portability;
     /** 涉及秘密状态（如 credentialsStatus）：安全提示用，绝不显示值。 */
     sensitive?: boolean;
+    /**
+     * 分区所属的**导出分组**（`ui/types.ts` 的 EXPORT_GROUPS）。
+     *
+     * 用途：选择器在分组切换处插入标题行（General / 插件与扩展 / …）。渲染顺序**由调用方给的顺序
+     * 决定**（宿主目录本来已按分组排好，UI 不重排）。缺省 = 不渲染分组标题 ——
+     * 导入向导与市场通道的节点没有这个概念，行为逐像素不变。
+     */
+    group?: ExportGroup;
 }
 /** 唯一的导出选择状态。 */
 export interface Selection {
@@ -382,3 +399,125 @@ export interface ImportSelectionState {
 export declare function effectiveImportSelection(plan: ImportPlan | null, zipPath: string | null, state: ImportSelectionState | null): Selection | null;
 /** 生效的导入计划（选择裁剪后的子计划）；plan 为空时返回 null。 */
 export declare function effectiveImportPlan(plan: ImportPlan | null, zipPath: string | null, state: ImportSelectionState | null): ImportPlan | null;
+/** 树上一个叶子的种类：插件清单条目 / 配置类数据区域 / 大文件区域 */
+export type PluginLeafKind = 'plugin' | 'config' | 'assets';
+export interface PluginTreeLeaf {
+    kind: PluginLeafKind;
+    section: SectionId;
+    /** 单元 id（present 时可勾；unread / absent 时只是占位，不可勾） */
+    unitId: string;
+    /** 宿主直出文本：插件包名 / 区域 home 相对路径 */
+    label: string;
+    /** 单元副标题（版本等；只有已读到清单时才有） */
+    detail?: string;
+    sizeBytes: number;
+    /** present=清单里确有该单元（可勾）；unread=该分区清单还没读；absent=已读但没有这个单元 */
+    state: 'present' | 'unread' | 'absent';
+}
+export interface PluginTreeEntry {
+    /** 插件包名（= plugins 单元 id 的 `plugin:` 后缀） */
+    name: string;
+    /** 插件清单条目（该分区还没读到清单时为 undefined） */
+    main?: PluginTreeLeaf;
+    /** 该插件声明的数据区域（宿主静态表；可能为空数组） */
+    areas: PluginTreeLeaf[];
+    /** main + areas（渲染顺序：清单条目在前，区域按宿主声明顺序） */
+    leaves: PluginTreeLeaf[];
+}
+/** 「无法归属到具体插件」的桶：整块来自某个分区（不猜归属）。 */
+export interface PluginTreeBucket {
+    section: SectionId;
+    /** 该分区的清单是否已读到（false = 还没读 / 读取失败，界面给「读取该分区」入口） */
+    loaded: boolean;
+    units: SelectionUnit[];
+}
+export interface PluginTree {
+    /** 插件清单是否已读到；未读到时 entries 为空（界面提示先读取插件分区） */
+    pluginsLoaded: boolean;
+    entries: PluginTreeEntry[];
+    /** 桶：无归属的分区单元（插件的补丁行 / pnpm-workspace.yaml；pluginFiles 整块） */
+    buckets: PluginTreeBucket[];
+}
+/**
+ * 合并进「按插件看」那棵树的分区（导出选择器里「插件与扩展」组的成员）。
+ *
+ * 这四项的归属键只有 npm 包名（plugin:<包名> ↔ 来源注册表的 packages）；self（配置管理器设置）
+ * **不在**这里 —— 它不是插件，仍按普通分区行渲染。清单顺序仍由调用方给的节点顺序决定
+ * （宿主目录已按 EXPORT_GROUPS 排好，树只在第一个成员处渲染一次）。
+ */
+export declare const PLUGIN_TREE_SECTIONS: readonly SectionId[];
+/** 该分区是否合并进「按插件看」的树（见 PLUGIN_TREE_SECTIONS）。 */
+export declare function isPluginTreeSection(section: SectionId): boolean;
+/** 把选择器分区模型投影成「按插件看」的树（纯函数）。 */
+export declare function pluginTree(nodes: readonly SelectionSection[]): PluginTree;
+/** 树上的搜索过滤：插件名命中 → 保留它全部叶子；否则只保留标签命中的叶子；桶按单元标签过滤。 */
+export declare function filterPluginTree(tree: PluginTree, query: string): PluginTree;
+/** 该插件节点下**真实可勾选**的叶子（unread / absent 不参与勾选）。 */
+export declare function pluginEntryLeaves(entry: PluginTreeEntry): PluginTreeLeaf[];
+/**
+ * 该插件名下**已知**的叶子（存在 + 还没读到清单的区域声明）。
+ *
+ * 计数与三态用它，**不用 pluginEntryLeaves（只含 present）**：否则「已选 n/m」会随清单到货跳动 ——
+ * 折叠时显示 1/1、展开（触发了读取）后变成 1/3，用户看到的是「数字自己变了」（2026-10-17 实测反馈）。
+ * absent（注册表说有、盘上确实没有）不计入：它永远不可勾，算进去只会让分母虚高。
+ */
+export declare function pluginEntryKnownLeaves(entry: PluginTreeEntry): PluginTreeLeaf[];
+export declare function pluginEntryTotalCount(entry: PluginTreeEntry): number;
+export declare function pluginEntrySelectedCount(sel: Selection, entry: PluginTreeEntry): number;
+/**
+ * 插件节点三态（与分区/分组同一套口径，但分母用**已知**叶子）。
+ *
+ * 还有区域没读到（unread）时最多只能是 `partial`：那些单元此刻勾不上，
+ * 报「全选」会让用户以为已经全带上（真正补齐见 ContentPicker 的待补勾队列）。
+ */
+export declare function pluginEntryPickState(sel: Selection, entry: PluginTreeEntry): SectionPickState;
+/**
+ * 插件节点级勾选：把它名下**存在的**单元一起勾 / 取消。
+ *
+ * 逐个走 toggleUnit：分区未勾时「勾一个单元 = 只勾这一个」的既有语义因此自动生效，
+ * 不会因为一键操作就把整个 pluginData / pluginAssets 分区静默全选。
+ */
+export declare function togglePluginEntry(sel: Selection, nodes: SelectionSection[], entry: PluginTreeEntry, checked: boolean): Selection;
+/** 树上所有**真实可勾选**的叶子（各插件名下存在单元的合计；不含未归属 / 遗留数据桶）。 */
+export declare function pluginTreeLeaves(tree: PluginTree): PluginTreeLeaf[];
+export declare function pluginTreeLeafCount(tree: PluginTree): number;
+/** 树上**已知**的叶子（存在 + 未读取；不含 absent）—— 一级区块的计数与三态用它，口径同插件节点。 */
+export declare function pluginTreeKnownLeaves(tree: PluginTree): PluginTreeLeaf[];
+export declare function pluginTreeTotalCount(tree: PluginTree): number;
+export declare function pluginTreeSelectedCount(sel: Selection, tree: PluginTree): number;
+/**
+ * 「插件」一级区块（把全部插件收在一个可折叠区块里）的三态。
+ *
+ * 只算**插件名下真实存在的叶子**：未归属 / 遗留数据是「无法归属的东西」，不参与这个勾选框 ——
+ * 否则「全选所有插件」会顺手把没人认领的散落配置一起带上。
+ */
+export declare function pluginTreePickState(sel: Selection, tree: PluginTree): SectionPickState;
+/** 一级区块勾选：把所有插件名下存在的单元一起勾 / 取消（逐个走 toggleUnit；含未归属桶吗？不含）。 */
+export declare function togglePluginTree(sel: Selection, nodes: SelectionSection[], tree: PluginTree, checked: boolean): Selection;
+/**
+ * 展开「插件」一级区块前还需要读取哪些分区的清单（惰性）。
+ *
+ * **插件清单自己没读到也要报**（否则一级区块展开后只有一句「先读取插件分区」却没有入口）。
+ */
+export declare function pluginTreeUnreadSections(tree: PluginTree): SectionId[];
+/** 一条待补勾请求（键 = 「插件」一级区块，或某个插件名）。 */
+export interface PluginPendingCheck {
+    key: string;
+    kind: 'root' | 'entry';
+}
+/**
+ * 待补勾的出队判定（纯函数，node 可测）。
+ *
+ * 背景：清单是**惰性**读取的 —— 用户勾「插件」一级区块或某个插件时，它名下可能还有区域没读到
+ * （unread），那些单元此刻勾不上。若就此结束，用户会以为「全带上了」，实际包里少了数据目录/大文件。
+ * 调用方在点击时先勾已知的、把没到齐的键入队；清单到货（nodes 变化）后再调本函数补齐。
+ *
+ * 判据 = 该节点名下**已无 unread 叶子**（`pluginEntryUnreadSections` / `pluginsLoaded`）：
+ * 到齐 → 出队并补齐；没到齐 → 留在队列里继续等（绝不猜成「已勾」）。
+ */
+export declare function applyPluginPendingChecks(sel: Selection, nodes: SelectionSection[], tree: PluginTree, pending: readonly PluginPendingCheck[]): {
+    selection: Selection;
+    remaining: PluginPendingCheck[];
+};
+/** 勾上该插件前还需要读取哪些分区的清单（展开/点击时触发惰性读取）。 */
+export declare function pluginEntryUnreadSections(entry: PluginTreeEntry): SectionId[];

package/lib/ui/selection-model.js

@@ -59,6 +59,8 @@ export function sectionsFromPreview(preview) {
             ...(u.projectKey !== undefined ? { projectKey: u.projectKey } : {}),
             ...(u.parentSessionId !== undefined ? { parentSessionId: u.parentSessionId } : {}),
             ...(u.blank === true ? { blank: true } : {}),
+            // 「按插件看」的树骨架（宿主下发的静态区域清单；缺省 = 该插件没有已知关联）
+            ...(u.relatedAreas !== undefined && u.relatedAreas.length > 0 ? { relatedAreas: u.relatedAreas } : {}),
         })),
     }));
 }
@@ -776,13 +778,243 @@ export function effectiveImportPlan(plan, zipPath, state) {
     const selection = effectiveImportSelection(plan, zipPath, state);
     return plan === null || selection === null ? null : buildSelectedPlan(plan, selection);
 }
-/* ----------------------------------------------------------------------------------
-   市场通道（Phase 3）：与本地导入**完全同一套** Selection 语义
-   ----------------------------------------------------------------------------------
-   市场装回（浏览条目详情 / 我的配置→装回本地）曾在 market-view.ts 里自带一套「分区级布尔批准表」
-   （MarketApprovals / defaultApprovals / buildApprovedPlan / approvalRows），并让高风险分区默认不勾。
-   该表已删除：市场通道现在与导入页共用本模块的 Selection（默认全选、「全选」含高风险分区），
-   差异只剩「从 market/download 的 plan 派生节点」与「逐项摘要」两个纯展示关切 ——
-   它们住在 src/ui/market-import.ts，不在这里再长第二套选择逻辑。
-   ---------------------------------------------------------------------------------- */
+/**
+ * 合并进「按插件看」那棵树的分区（导出选择器里「插件与扩展」组的成员）。
+ *
+ * 这四项的归属键只有 npm 包名（plugin:<包名> ↔ 来源注册表的 packages）；self（配置管理器设置）
+ * **不在**这里 —— 它不是插件，仍按普通分区行渲染。清单顺序仍由调用方给的节点顺序决定
+ * （宿主目录已按 EXPORT_GROUPS 排好，树只在第一个成员处渲染一次）。
+ */
+export const PLUGIN_TREE_SECTIONS = ['plugins', 'pluginFiles', 'pluginData', 'pluginAssets'];
+/** 该分区是否合并进「按插件看」的树（见 PLUGIN_TREE_SECTIONS）。 */
+export function isPluginTreeSection(section) {
+    return PLUGIN_TREE_SECTIONS.includes(section);
+}
+/** 插件单元 id 前缀（与 adapters/units.ts 的 `plugin:<包名>` 同一命名空间） */
+const PLUGIN_UNIT_PREFIX = 'plugin:';
+/** 把一条区域引用投影成叶子（按该分区清单是否到货决定 present / unread / absent）。 */
+function areaLeaf(node, ref) {
+    const unitId = ref.section + ':' + ref.relPath;
+    const kind = ref.role === 'assets' ? 'assets' : 'config';
+    const unit = node?.units.find((u) => u.id === unitId);
+    if (unit === undefined) {
+        // 分区清单没读到 → unread（展开时才去读）；读到了却没有这个单元 → absent（注册表说有、盘上没有）
+        return {
+            kind, section: ref.section, unitId, label: ref.relPath, sizeBytes: 0,
+            state: node === undefined || node.unitsUnread === true ? 'unread' : 'absent',
+        };
+    }
+    return {
+        kind, section: ref.section, unitId, label: ref.relPath,
+        ...(unit.detail !== undefined ? { detail: unit.detail } : {}),
+        sizeBytes: unit.sizeBytes,
+        state: 'present',
+    };
+}
+/** 把选择器分区模型投影成「按插件看」的树（纯函数）。 */
+export function pluginTree(nodes) {
+    const bySection = new Map();
+    for (const n of nodes)
+        bySection.set(n.section, n);
+    const pluginsNode = bySection.get('plugins');
+    const entries = [];
+    const extras = [];
+    for (const unit of pluginsNode?.units ?? []) {
+        if (!unit.id.startsWith(PLUGIN_UNIT_PREFIX)) {
+            // 补丁行 / pnpm-workspace.yaml：与插件无归属关系，进桶（在插件视图里也必须可见可选）
+            extras.push(unit);
+            continue;
+        }
+        const name = unit.id.slice(PLUGIN_UNIT_PREFIX.length);
+        const main = {
+            kind: 'plugin', section: 'plugins', unitId: unit.id, label: unit.label,
+            ...(unit.detail !== undefined ? { detail: unit.detail } : {}),
+            sizeBytes: unit.sizeBytes,
+            state: 'present',
+        };
+        const areas = (unit.relatedAreas ?? []).map((ref) => areaLeaf(bySection.get(ref.section), ref));
+        entries.push({ name, main, areas, leaves: [main, ...areas] });
+    }
+    const buckets = [];
+    const pluginExtras = bySection.get('plugins');
+    if (pluginExtras !== undefined) {
+        buckets.push({ section: 'plugins', loaded: pluginExtras.unitsUnread !== true, units: extras });
+    }
+    /**
+     * 只留一个桶：pluginFiles。
+     *
+     * 它没有任何包名信息（白名单文件 + `plugin-config/<任意目录名>/`），按目录名猜包名 = 猜错就在树里
+     * 勾错东西 ⇒ 整块归「未归属」。**pluginData / pluginAssets 里没被插件声明认领的单元不再单列
+     * 「遗留数据」桶**（用户 2026-10-17 明确要求：不需要看到这些）—— 它们仍会随该分区整体勾选导出，
+     * 只是不在插件树里单开一行。
+     */
+    for (const id of ['pluginFiles']) {
+        const node = bySection.get(id);
+        if (node === undefined)
+            continue;
+        buckets.push({ section: id, loaded: node.unitsUnread !== true, units: node.units });
+    }
+    return { pluginsLoaded: pluginsNode !== undefined && pluginsNode.unitsUnread !== true, entries, buckets };
+}
+/** 树上的搜索过滤：插件名命中 → 保留它全部叶子；否则只保留标签命中的叶子；桶按单元标签过滤。 */
+export function filterPluginTree(tree, query) {
+    const q = query.trim().toLowerCase();
+    if (q === '')
+        return tree;
+    const hit = (text) => text.toLowerCase().includes(q);
+    const entries = tree.entries
+        .map((e) => (hit(e.name) ? e : { ...e, leaves: e.leaves.filter((l) => hit(l.label) || hit(l.detail ?? '')) }))
+        .filter((e) => hit(e.name) || e.leaves.length > 0);
+    const buckets = tree.buckets
+        .map((b) => ({ ...b, units: b.units.filter((u) => hit(u.label) || hit(u.detail ?? '')) }))
+        .filter((b) => b.units.length > 0);
+    return { ...tree, entries, buckets };
+}
+/** 该插件节点下**真实可勾选**的叶子（unread / absent 不参与勾选）。 */
+export function pluginEntryLeaves(entry) {
+    return entry.leaves.filter((l) => l.state === 'present');
+}
+/**
+ * 该插件名下**已知**的叶子（存在 + 还没读到清单的区域声明）。
+ *
+ * 计数与三态用它，**不用 pluginEntryLeaves（只含 present）**：否则「已选 n/m」会随清单到货跳动 ——
+ * 折叠时显示 1/1、展开（触发了读取）后变成 1/3，用户看到的是「数字自己变了」（2026-10-17 实测反馈）。
+ * absent（注册表说有、盘上确实没有）不计入：它永远不可勾，算进去只会让分母虚高。
+ */
+export function pluginEntryKnownLeaves(entry) {
+    return entry.leaves.filter((l) => l.state !== 'absent');
+}
+export function pluginEntryTotalCount(entry) {
+    return pluginEntryKnownLeaves(entry).length;
+}
+export function pluginEntrySelectedCount(sel, entry) {
+    return pluginEntryLeaves(entry).reduce((n, l) => n + (unitChecked(sel, l.section, l.unitId) ? 1 : 0), 0);
+}
+/**
+ * 插件节点三态（与分区/分组同一套口径，但分母用**已知**叶子）。
+ *
+ * 还有区域没读到（unread）时最多只能是 `partial`：那些单元此刻勾不上，
+ * 报「全选」会让用户以为已经全带上（真正补齐见 ContentPicker 的待补勾队列）。
+ */
+export function pluginEntryPickState(sel, entry) {
+    const known = pluginEntryKnownLeaves(entry);
+    if (known.length === 0)
+        return 'none';
+    const picked = pluginEntrySelectedCount(sel, entry);
+    if (picked === 0)
+        return 'none';
+    return picked === known.length ? 'all' : 'partial';
+}
+/**
+ * 插件节点级勾选：把它名下**存在的**单元一起勾 / 取消。
+ *
+ * 逐个走 toggleUnit：分区未勾时「勾一个单元 = 只勾这一个」的既有语义因此自动生效，
+ * 不会因为一键操作就把整个 pluginData / pluginAssets 分区静默全选。
+ */
+export function togglePluginEntry(sel, nodes, entry, checked) {
+    let out = sel;
+    for (const leaf of pluginEntryLeaves(entry))
+        out = toggleUnit(out, nodes, leaf.unitId, checked);
+    return out;
+}
+/** 树上所有**真实可勾选**的叶子（各插件名下存在单元的合计；不含未归属 / 遗留数据桶）。 */
+export function pluginTreeLeaves(tree) {
+    return tree.entries.flatMap((e) => pluginEntryLeaves(e));
+}
+export function pluginTreeLeafCount(tree) {
+    return pluginTreeLeaves(tree).length;
+}
+/** 树上**已知**的叶子（存在 + 未读取；不含 absent）—— 一级区块的计数与三态用它，口径同插件节点。 */
+export function pluginTreeKnownLeaves(tree) {
+    return tree.entries.flatMap((e) => pluginEntryKnownLeaves(e));
+}
+export function pluginTreeTotalCount(tree) {
+    return pluginTreeKnownLeaves(tree).length;
+}
+export function pluginTreeSelectedCount(sel, tree) {
+    return pluginTreeLeaves(tree).reduce((n, l) => n + (unitChecked(sel, l.section, l.unitId) ? 1 : 0), 0);
+}
+/**
+ * 「插件」一级区块（把全部插件收在一个可折叠区块里）的三态。
+ *
+ * 只算**插件名下真实存在的叶子**：未归属 / 遗留数据是「无法归属的东西」，不参与这个勾选框 ——
+ * 否则「全选所有插件」会顺手把没人认领的散落配置一起带上。
+ */
+export function pluginTreePickState(sel, tree) {
+    const known = pluginTreeKnownLeaves(tree);
+    if (known.length === 0)
+        return 'none';
+    const picked = pluginTreeSelectedCount(sel, tree);
+    if (picked === 0)
+        return 'none';
+    return picked === known.length ? 'all' : 'partial';
+}
+/** 一级区块勾选：把所有插件名下存在的单元一起勾 / 取消（逐个走 toggleUnit；含未归属桶吗？不含）。 */
+export function togglePluginTree(sel, nodes, tree, checked) {
+    let out = sel;
+    for (const leaf of pluginTreeLeaves(tree))
+        out = toggleUnit(out, nodes, leaf.unitId, checked);
+    return out;
+}
+/**
+ * 展开「插件」一级区块前还需要读取哪些分区的清单（惰性）。
+ *
+ * **插件清单自己没读到也要报**（否则一级区块展开后只有一句「先读取插件分区」却没有入口）。
+ */
+export function pluginTreeUnreadSections(tree) {
+    const out = tree.pluginsLoaded ? [] : ['plugins'];
+    for (const entry of tree.entries) {
+        for (const s of pluginEntryUnreadSections(entry))
+            if (!out.includes(s))
+                out.push(s);
+    }
+    // pluginFiles（未归属桶）没读到也要报：它的读取入口挂在「展开这一行」上
+    for (const bucket of tree.buckets) {
+        if (!bucket.loaded && !out.includes(bucket.section))
+            out.push(bucket.section);
+    }
+    return out;
+}
+/**
+ * 待补勾的出队判定（纯函数，node 可测）。
+ *
+ * 背景：清单是**惰性**读取的 —— 用户勾「插件」一级区块或某个插件时，它名下可能还有区域没读到
+ * （unread），那些单元此刻勾不上。若就此结束，用户会以为「全带上了」，实际包里少了数据目录/大文件。
+ * 调用方在点击时先勾已知的、把没到齐的键入队；清单到货（nodes 变化）后再调本函数补齐。
+ *
+ * 判据 = 该节点名下**已无 unread 叶子**（`pluginEntryUnreadSections` / `pluginsLoaded`）：
+ * 到齐 → 出队并补齐；没到齐 → 留在队列里继续等（绝不猜成「已勾」）。
+ */
+export function applyPluginPendingChecks(sel, nodes, tree, pending) {
+    const remaining = [];
+    let out = sel;
+    for (const p of pending) {
+        if (p.kind === 'root') {
+            if (!tree.pluginsLoaded || tree.entries.some((e) => pluginEntryUnreadSections(e).length > 0)) {
+                remaining.push(p);
+                continue;
+            }
+            out = togglePluginTree(out, nodes, tree, true);
+            continue;
+        }
+        const entry = tree.entries.find((e) => e.name === p.key);
+        if (entry === undefined)
+            continue;
+        if (pluginEntryUnreadSections(entry).length > 0) {
+            remaining.push(p);
+            continue;
+        }
+        out = togglePluginEntry(out, nodes, entry, true);
+    }
+    return { selection: out, remaining };
+}
+/** 勾上该插件前还需要读取哪些分区的清单（展开/点击时触发惰性读取）。 */
+export function pluginEntryUnreadSections(entry) {
+    const out = [];
+    for (const leaf of entry.leaves) {
+        if (leaf.state === 'unread' && !out.includes(leaf.section))
+            out.push(leaf.section);
+    }
+    return out;
+}
 //# sourceMappingURL=selection-model.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-config-manager",
-  "version": "0.1.76",
+  "version": "0.1.77",
   "license": "MIT",
   "description": "Backup, restore, export, import, migrate and sync your DeepSeek Harness (DSH) configuration: settings, plugins, MCP servers, skills, agent presets and workspaces. One-click migration to another machine. DSH 配置一键备份、恢复、导出、导入、迁移与同步插件。",
   "icon": "./icon.svg",

package/src/adapters/plugin-data-declared.ts

@@ -0,0 +1,60 @@
+/**
+ * 「已安装插件自述数据目录（dsh.dataDirs）」的**单一扫描实现**。
+ *
+ * 为什么单独一个模块：这份扫描有两个消费者 ——
+ *  - \`pluginData\` / \`pluginAssets\` adapter（决定要收集哪些区域）；
+ *  - \`plugins\` adapter（导出选择器「按插件看」需要知道**每个插件自己声明的数据区域**，
+ *    才能在不读任何数据目录的前提下画出树骨架）。
+ * 两处各写一份必然漂移（同一条铁律：同一事实只有一份实现）。
+ *
+ * 语义（与改造前 plugin-data.ts 的私有实现逐字一致）：
+ *  - 读的是 **profile 实际安装**的那份 manifest（\`profiles/<profile>/node_modules/<pkg>/package.json\`），
+ *    不是全局目录 —— 同一个包在不同 profile 可以是不同版本，声明必须取本 profile 装的；
+ *  - 读不到（未安装 / 无声明 / 形状非法）一律跳过：本机制是**附加**信息，绝不因为一个包读不出来
+ *    就影响内置来源或整次导出；
+ *  - 本函数**不缓存**（缓存策略由调用方决定：pluginData 有实例级 TTL 缓存，plugins 有模块级缓存）。
+ */
+import { parseDeclaredDataDirs } from '../core/plugin-data-registry.ts';
+import type { PluginDataSource } from '../core/plugin-data-registry.ts';
+import type { HostContext } from '../core/types.ts';
+
+/** 单次扫描最多读取多少个已安装插件的 manifest（防御性上限：profile 依赖数量异常时不无限读） */
+export const MAX_DECLARED_PACKAGES = 300;
+
+/**
+ * 解析声明时用的 profile 目录名。
+ *
+ * 与 DSH 的 profile 解析同口径：空 / undefined = \`web\`（与改造前的私有实现一致）。
+ */
+export function declaredProfileName(profile: string | undefined): string {
+  return profile !== undefined && profile !== '' ? profile : 'web';
+}
+
+/** 扫描本机已安装插件自述的数据目录声明（零副作用；读不到的一律跳过）。 */
+export async function scanDeclaredDataSources(
+  ctx: HostContext,
+  maxPackages: number = MAX_DECLARED_PACKAGES,
+): Promise<PluginDataSource[]> {
+  const base = 'profiles/' + declaredProfileName(ctx.profile);
+  const out: PluginDataSource[] = [];
+  let deps: string[] = [];
+  try {
+    const raw = await ctx.fs.readFile(base + '/package.json');
+    const parsed: unknown = JSON.parse(new TextDecoder().decode(raw));
+    const dep = (parsed as { dependencies?: unknown } | null)?.dependencies;
+    if (dep !== null && typeof dep === 'object') deps = Object.keys(dep).slice(0, maxPackages);
+  } catch {
+    deps = [];
+  }
+  for (const name of deps) {
+    try {
+      const raw = await ctx.fs.readFile(base + '/node_modules/' + name + '/package.json');
+      const manifest: unknown = JSON.parse(new TextDecoder().decode(raw));
+      const source = parseDeclaredDataDirs(name, manifest);
+      if (source !== null) out.push(source);
+    } catch {
+      // 未安装 / 无 manifest → 无声明，跳过
+    }
+  }
+  return out;
+}

package/src/adapters/plugin-data.ts

@@ -33,8 +33,8 @@ import type { RecursiveListing } from '../utils/recursive-walk.ts';
 import { sectionMeta } from '../schema/section-registry.ts';
 import {
   BUILTIN_PLUGIN_DATA_SOURCES, areaOfPath, areasForSection, isExcludedRel, normalizeHomeRel,
-  parseDeclaredDataDirs,
 } from '../core/plugin-data-registry.ts';
+import { declaredProfileName, scanDeclaredDataSources } from './plugin-data-declared.ts';
 import type { PluginDataArea, PluginDataSource, PluginDataSection } from '../core/plugin-data-registry.ts';
 import { osHomeDirOf } from '../core/backup.ts';
 import { FileCollectionAdapter } from './file-collection.ts';
@@ -50,9 +50,6 @@ export type PluginDataEntry = { source: PluginDataSource; area: PluginDataArea }
 /** 声明来源缓存的 TTL（毫秒）：一次导出/导入/执行里会多次解析，逐次读 15+ 个 package.json 是净开销 */
 const DECLARED_TTL_MS = 5_000;
 
-/** 单次解析里最多读取多少个已安装插件的 manifest（防御性上限：profile 依赖数量异常时不无限读） */
-const MAX_DECLARED_PACKAGES = 300;
-
 export interface PluginDataAdapterOptions {
   /** 内置来源（缺省 = BUILTIN_PLUGIN_DATA_SOURCES；测试注入假来源） */
   readonly sources?: readonly PluginDataSource[];
@@ -111,18 +108,15 @@ export class PluginDataAdapter extends FileCollectionAdapter {
   }
 
   /**
-   * 已安装插件的自述声明（dsh.dataDirs）。
-   *
-   * 为什么读 profile 的 node_modules 而不是全局目录：DSH 的插件装在 \`profiles/<profile>/node_modules\`
-   * 下（pnpm 隔离布局），且同一个包在不同 profile 可以是不同版本 —— 声明必须取**本 profile 实际装的**那份。
+   * 已安装插件的自述声明（dsh.dataDirs）—— 本方法只做**缓存**，扫描实现见 plugin-data-declared.ts。
    *
-   * 读不到（未安装 / 无声明 / 形状非法）一律跳过：本机制是**附加**信息，绝不因为一个包读不出来
-   * 就影响内置来源或整次导出。
+   * 为什么缓存必须带 ctx 键（homeDir + profile）：DSH 的插件装在 \`profiles/<profile>/node_modules\`
+   * 下（pnpm 隔离布局），而「这台机器装了某插件」不代表另一台装了 —— 缓存若按实例共享，
+   * 导入到「没装该插件」的目标机时会拿源机的声明去放行写入，白名单就变成「谁先导入谁说了算」。
    */
   private async declaredSources(ctx: HostContext): Promise<PluginDataSource[]> {
     const now = Date.now();
-    const profile = ctx.profile !== undefined && ctx.profile !== '' ? ctx.profile : 'web';
-    const memoKey = ctx.homeDir + '|' + profile;
+    const memoKey = ctx.homeDir + '|' + declaredProfileName(ctx.profile);
     if (
       this.declaredMemo !== undefined
       && this.declaredMemo.key === memoKey
@@ -130,27 +124,7 @@ export class PluginDataAdapter extends FileCollectionAdapter {
     ) {
       return this.declaredMemo.sources;
     }
-    const base = 'profiles/' + profile;
-    const out: PluginDataSource[] = [];
-    let deps: string[] = [];
-    try {
-      const raw = await ctx.fs.readFile(base + '/package.json');
-      const parsed: unknown = JSON.parse(new TextDecoder().decode(raw));
-      const dep = (parsed as { dependencies?: unknown } | null)?.dependencies;
-      if (dep !== null && typeof dep === 'object') deps = Object.keys(dep).slice(0, MAX_DECLARED_PACKAGES);
-    } catch {
-      deps = [];
-    }
-    for (const name of deps) {
-      try {
-        const raw = await ctx.fs.readFile(base + '/node_modules/' + name + '/package.json');
-        const manifest: unknown = JSON.parse(new TextDecoder().decode(raw));
-        const source = parseDeclaredDataDirs(name, manifest);
-        if (source !== null) out.push(source);
-      } catch {
-        // 未安装 / 无 manifest → 无声明，跳过
-      }
-    }
+    const out = await scanDeclaredDataSources(ctx);
     this.declaredMemo = { key: memoKey, at: now, sources: out };
     return out;
   }