dsh-config-manager 0.1.76 → 0.1.78

package/lib/ui/rollback-view.d.ts

@@ -243,6 +243,23 @@ export interface RollbackPreviewFile {
     removed: number | null;
     /** true = 本次没有可信行数（added/removed 均为 null）。**宁可说「不知道」，也绝不谎报行数。** */
     truncated: boolean;
+    /**
+     * true = 该文件在留点**之后**是**别的会话**写的（写入归属台账证明；见 core/rollback-attribution.ts）。
+     * 界面据此默认不勾选它（用户仍可勾上）。缺字段 / false = **没有归属证据**，
+     * 而不是「本会话写的」——「未判定」与「确知是本会话」必须分开。
+     */
+    foreign?: boolean;
+    /** 那些「别的会话」的会话 id（仅当 foreign 为 true） */
+    foreignSessionId?: string;
+    /** 那次写入的时间（毫秒；仅当 foreign 为 true） */
+    foreignAt?: number;
+    /**
+     * true = 这次回退**不会改动它**（与其它对话的改动冲突 / 无法安全合并）。行级统计为 null ——
+     * 「不改动」不是「0 行变化」，界面必须分开说。
+     */
+    skipped?: boolean;
+    /** 不改动的机器原因（界面映射成字典键，绝不裸渲染） */
+    mergeReason?: string;
 }
 export interface RollbackWorkspacePreview {
     /** 将被写回（覆盖）的条目数 */
@@ -364,6 +381,12 @@ export interface RollbackFileDiffResult {
     identical: boolean;
     degraded: boolean;
     reason?: RollbackFileDiffReason;
+    /** true = 「回退后」一侧显示的是三方合并的结果（不是记录里的原文） */
+    merged?: boolean;
+    /** true = 这次回退不会改动它（冲突 / 无法安全合并）——此时两侧相同 */
+    mergeSkipped?: boolean;
+    /** 不改动的机器原因（界面映射成字典键） */
+    mergeReason?: string;
 }
 export interface RollbackSegmentResult {
     state: string;
@@ -389,6 +412,22 @@ export interface RollbackSegmentResult {
     createdRefusedReason?: string | null;
     /** 工作区段：实际写回的字节数（宿主回传才有） */
     writtenBytes?: number;
+    /** 因归属隔离（B）跳过的记录条目数：该文件在留点后被**别的会话**写过（宿主回传才有） */
+    foreignSkipped?: number;
+    /** 因路径选择（A）跳过的记录条目数（宿主回传才有） */
+    selectionSkipped?: number;
+    /** 三方合并成功、写回「撤销本会话 + 保留对方改动」的条目数（宿主回传才有） */
+    mergedCount?: number;
+    mergedPaths?: string[];
+    /** 冲突：两侧改到同一处 ⇒ 未写（宿主回传才有） */
+    conflictCount?: number;
+    conflictPaths?: string[];
+    /** 无法安全撤销 ⇒ 未写（宿主回传才有） */
+    unavailableCount?: number;
+    unavailablePaths?: string[];
+    /** 写入前发现又被改过（并发）⇒ 未写（宿主回传才有） */
+    concurrentCount?: number;
+    concurrentPaths?: string[];
     /** 兼容形态：宿主只回传计数时也算得出来 */
     createdAfter?: RollbackCount;
     createdAfterTruncated?: boolean;
@@ -427,6 +466,13 @@ export interface RollbackRewindOptions {
     segments?: readonly RollbackState[];
     allowPartial?: boolean;
     preRewindGuard?: RollbackGuardPolicy;
+    /**
+     * 路径级选择性恢复（2026-10-17 定案 A）：只恢复这些路径。
+     *
+     * 缺省 = 全量口径（一字不变）。**空数组是无效输入**（宿主 400）—— 「一个都没勾」由界面拦住，
+     * 绝不让它变成「整次回退静默 noop」。
+     */
+    onlyPaths?: readonly string[];
 }
 /** 端口：由 src/client/recovery/recovery-api.ts 实现（Partial 消费，缺失时界面如实说能力缺失）。 */
 export interface RollbackPointPort {
@@ -660,6 +706,39 @@ export declare function rollbackPreviewScope(files: readonly {
     added: number | null;
     removed: number | null;
 }[], removals: readonly unknown[]): RollbackPreviewScope;
+/**
+ * 预览里「能被单独勾选」的一行 —— `workspace.files` 的逐条映射（**只含会被改动的文件**）。
+ *
+ * 为什么要有这一层（2026-10-17 定案 A+B）：A 要求用户能**逐文件**决定这次动哪些；
+ * B（写入归属）给出「哪几个文件在留点之后是别的会话写的」，用来决定**默认**勾不勾。
+ * 两件事都收敛在这里、只在这一处（框架无关、node 可测），组件只负责渲染与点击。
+ */
+export interface RollbackSelectionRow {
+    path: string;
+    /** 目录前缀 + 基名（与文件行同口径；展示用） */
+    parts: RollbackPathParts;
+    /** true = 该文件在留点**之后**是别的会话写的（引擎 foreign 标记；缺字段 = 没有归属证据） */
+    foreign: boolean;
+    /** 那些会话的 id（仅 foreign 时给得出） */
+    foreignSessionId?: string;
+}
+/** 从预览推出可勾选行（只读；绝不改任何判定） */
+export declare function rollbackSelectionRows(preview: RollbackPreviewResult | null): RollbackSelectionRow[];
+/**
+ * 默认勾选 = **非 foreign** 的行（B 的自动隔离口径）。用户可在弹窗里逐个改回去。
+ *
+ * 为什么要在这里定而不在组件里：同一条默认值要在面板与聊天两个入口一致，
+ * 且「默认排除别的会话的改动」是产品决定，必须可测。
+ */
+export declare function rollbackDefaultSelection(rows: readonly RollbackSelectionRow[]): string[];
+/**
+ * 勾选集 → `onlyPaths`：
+ *  · **全选**（含空清单）⇒ `null`（不传字段 = 走既有全量口径，老宿主也照样工作）；
+ *  · 真的少勾 ⇒ 把选中的清单原样传给宿主（空数组由调用方拦：宿主侧它是 400）。
+ */
+export declare function rollbackOnlyPaths(rows: readonly RollbackSelectionRow[], selected: readonly string[]): string[] | null;
+/** 该不该拦住提交：清单非空、却一个都没勾（宿主会把空数组当 400） */
+export declare function rollbackSelectionBlocksSubmit(rows: readonly RollbackSelectionRow[], selected: readonly string[]): boolean;
 /**
  * 差异无法逐行展示时的字典键（本层**只回键**，文案在字典里）。
  * 未知 / 缺失原因回落 null —— 调用方按「未知原因」出话，绝不回落成「没有差异」（那是另一件事）。
@@ -780,6 +859,22 @@ export interface RollbackRewindRowView {
     /** 逐条事实：**渲染前已逐条过 redact** */
     detail: string[];
     guidance: RollbackGuidanceRowView[];
+    /**
+     * 归属隔离（B）跳过的文件数：这些文件在留点之后是**别的会话**写的，回退没动它们。
+     * 0 = 没有（或宿主没回传）—— 界面只在 > 0 时说这句话（绝不编造 0 的成就）。
+     */
+    foreignSkipped: number;
+    /** 路径选择（A）跳过的文件数（用户自己没勾） */
+    selectionSkipped: number;
+    /** 三方合并成功、写回「撤销本会话 + 保留对方改动」的文件数 */
+    mergedCount: number;
+    /** 冲突（两侧改到同一处）未写的文件数 + 有界清单 */
+    conflictCount: number;
+    conflictPaths: string[];
+    /** 无法安全撤销（无中间版本 / 二进制 / 降级 / 对方删了它）未写的文件数 */
+    unavailableCount: number;
+    /** 写入前发现又被改过（并发）未写的文件数 */
+    concurrentCount: number;
 }
 export declare function rollbackRewindRows(result: RollbackRewindResult | null): RollbackRewindRowView[];
 /** 回退总体结论 → 字典键 + 徽章语义（未知回落 unknown，绝不裸渲染 outcome）。 */

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.78",
   "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",