dsh-config-manager 0.1.76 → 0.1.78

package/src/ui/rollback-view.ts

@@ -424,6 +424,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 {
@@ -551,6 +568,12 @@ export interface RollbackFileDiffResult {
   identical: boolean
   degraded: boolean
   reason?: RollbackFileDiffReason
+  /** true = 「回退后」一侧显示的是三方合并的结果（不是记录里的原文） */
+  merged?: boolean
+  /** true = 这次回退不会改动它（冲突 / 无法安全合并）——此时两侧相同 */
+  mergeSkipped?: boolean
+  /** 不改动的机器原因（界面映射成字典键） */
+  mergeReason?: string
 }
 
 export interface RollbackSegmentResult {
@@ -577,6 +600,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
@@ -613,6 +652,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 消费，缺失时界面如实说能力缺失）。 */
@@ -986,6 +1032,76 @@ export function rollbackPreviewScope(
   return { files: files.length, added, removed, removals: removals.length }
 }
 
+/**
+ * 预览里「能被单独勾选」的一行 —— `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 function rollbackSelectionRows(preview: RollbackPreviewResult | null): RollbackSelectionRow[] {
+  const files = preview?.workspace?.files
+  if (!Array.isArray(files)) return []
+  const out: RollbackSelectionRow[] = []
+  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: RollbackSelectionRow = { 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: readonly RollbackSelectionRow[]): string[] {
+  return rows.filter((row) => !row.foreign).map((row) => row.path)
+}
+
+/**
+ * 勾选集 → `onlyPaths`：
+ *  · **全选**（含空清单）⇒ `null`（不传字段 = 走既有全量口径，老宿主也照样工作）；
+ *  · 真的少勾 ⇒ 把选中的清单原样传给宿主（空数组由调用方拦：宿主侧它是 400）。
+ */
+export function rollbackOnlyPaths(
+  rows: readonly RollbackSelectionRow[],
+  selected: readonly string[],
+): string[] | null {
+  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: readonly RollbackSelectionRow[],
+  selected: readonly string[],
+): boolean {
+  if (rows.length === 0) return false
+  const chosen = new Set(selected)
+  return !rows.some((row) => chosen.has(row.path))
+}
+
 /**
  * 差异无法逐行展示时的字典键（本层**只回键**，文案在字典里）。
  * 未知 / 缺失原因回落 null —— 调用方按「未知原因」出话，绝不回落成「没有差异」（那是另一件事）。
@@ -1315,6 +1431,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 function rollbackRewindRows(result: RollbackRewindResult | null): RollbackRewindRowView[] {
@@ -1341,6 +1473,13 @@ export function rollbackRewindRows(result: RollbackRewindResult | null): Rollbac
       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/src/ui/selection-model.test.ts

@@ -10,9 +10,14 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 
 import {
-  buildExportRequest, buildSelectedPlan, defaultSelection,
+  applyPluginPendingChecks, buildExportRequest, buildSelectedPlan, defaultSelection,
   defaultSelectionFromPlan, effectiveImportPlan, effectiveImportSelection, filterSections,
-  groupPickState, groupSelectedCount, groupUnits, HIGH_RISK_ADAPTERS, isHighRiskAdapter, isPlanItemExcluded, isUnitSelected,
+  filterPluginTree, groupPickState, groupSelectedCount, groupUnits, HIGH_RISK_ADAPTERS, isHighRiskAdapter,
+  isPlanItemExcluded, isPluginTreeSection, isUnitSelected, PLUGIN_TREE_SECTIONS,
+  pluginEntryLeaves, pluginEntryPickState, pluginEntrySelectedCount, pluginEntryUnreadSections, pluginTree,
+  pluginEntryTotalCount, pluginTreeLeafCount, pluginTreePickState, pluginTreeSelectedCount, pluginTreeTotalCount,
+  pluginTreeUnreadSections,
+  togglePluginEntry, togglePluginTree,
   planWriteSections,
   tailWeightedEllipsis, pickerSummary,
   sectionCountState, sectionExpandable, sectionPickState, sectionsFromPlan, sectionsFromPreview, selectedUnitCount, selectAll,
@@ -836,3 +841,236 @@ test('选择模型：sectionsFromPreview 透传 blank 事实（ContentPicker 据
   assert.equal(nodes[0]?.units[0]?.blank, true);
   assert.equal(nodes[1]?.units[0]?.blank, undefined, '非会话单元不得凭空带 blank');
 });
+
+/* ----------------------------------------------------------------------------------
+   「按插件看」：树模型 / 三态 / 一键勾选（用户需求：勾一个插件 = 带走它四处的东西）
+   ---------------------------------------------------------------------------------- */
+
+function treeNodes(): SelectionSection[] {
+  return [
+    {
+      section: 'plugins', count: 2, sizeBytes: 120, group: 'extensions',
+      units: [
+        {
+          id: 'plugin:alpha', label: 'alpha', detail: '1.0.0', sizeBytes: 10,
+          relatedAreas: [{ section: 'pluginData', relPath: '.alpha/runtime', role: 'config' }],
+        },
+        { id: 'plugin:beta', label: 'beta', sizeBytes: 10 },
+        { id: 'plugins:pnpm-workspace', label: 'pnpm-workspace.yaml', sizeBytes: 5 },
+      ],
+    },
+    {
+      section: 'pluginData', count: 2, sizeBytes: 30,
+
+      units: [
+        { id: 'pluginData:.alpha/runtime', label: '.alpha/runtime', sizeBytes: 20 },
+        { id: 'pluginData:.gone/state', label: '.gone/state', sizeBytes: 10 },
+      ],
+    },
+    // 大文件分区还没读：区域叶子只能是 unread（不可勾），绝不当成「没有内容」
+    { section: 'pluginAssets', count: 0, sizeBytes: 0, units: [], unitsUnread: true },
+    {
+      section: 'pluginFiles', count: 1, sizeBytes: 4,
+      units: [{ id: 'pluginFiles:dsh-ssh.json', label: 'dsh-ssh.json', sizeBytes: 4 }],
+    },
+  ]
+}
+
+const TREE_SECTIONS: SectionId[] = ['plugins']
+
+test('合并进插件树的分区只有那四项（配置管理器设置不是插件，仍按普通分区行渲染）', () => {
+  assert.deepEqual([...PLUGIN_TREE_SECTIONS].sort(), ['pluginAssets', 'pluginData', 'pluginFiles', 'plugins'])
+  for (const id of PLUGIN_TREE_SECTIONS) assert.equal(isPluginTreeSection(id), true)
+  assert.equal(isPluginTreeSection('self'), false, '配置管理器设置不得被吸收进树')
+  assert.equal(isPluginTreeSection('sessions'), false)
+})
+
+test('按插件看：插件清单条目与它声明的数据区域收在同一个节点下（未读分区不可勾）', () => {
+  const tree = pluginTree(treeNodes())
+  assert.equal(tree.pluginsLoaded, true)
+  const alpha = tree.entries.find((e) => e.name === 'alpha')
+  assert.ok(alpha !== undefined)
+  assert.deepEqual(alpha!.leaves.map((l) => l.state), ['present', 'present'])
+  assert.deepEqual(alpha!.leaves.map((l) => l.unitId), ['plugin:alpha', 'pluginData:.alpha/runtime'])
+  // beta 没有任何声明 → 只有清单条目，绝不凭空造出数据区域
+  const beta = tree.entries.find((e) => e.name === 'beta')
+  assert.deepEqual(beta!.areas, [])
+  // 声明了 pluginAssets 的区域？alpha 只声明了 config 区域，故不存在 assets 叶子
+  assert.equal(alpha!.leaves.some((l) => l.section === 'pluginAssets'), false)
+})
+
+test('按插件看：注册表说有、磁盘上没有 = absent；分区没读 = unread（两者都不可勾）', () => {
+  const nodes = treeNodes()
+  // 让 alpha 声明一个大文件区域（该分区还没读）
+  nodes[0]!.units[0] = {
+    ...nodes[0]!.units[0]!,
+    relatedAreas: [
+      { section: 'pluginData', relPath: '.alpha/runtime', role: 'config' },
+      { section: 'pluginAssets', relPath: '.alpha/uploads', role: 'assets' },
+      { section: 'pluginData', relPath: '.alpha/nonexistent', role: 'config' },
+    ],
+  }
+  const tree = pluginTree(nodes)
+  const alpha = tree.entries.find((e) => e.name === 'alpha')!
+  // 顺序 = 清单条目在前，随后按宿主声明顺序：[runtime(已读)、uploads(未读)、nonexistent(已读但没内容)]
+  assert.deepEqual(alpha.leaves.map((l) => l.state), ['present', 'present', 'unread', 'absent'])
+  assert.deepEqual(pluginEntryLeaves(alpha).map((l) => l.unitId), ['plugin:alpha', 'pluginData:.alpha/runtime'])
+  assert.deepEqual(pluginEntryUnreadSections(alpha), ['pluginAssets'])
+})
+
+test('按插件看不猜归属：只有 pluginFiles（无包名信息）与补丁行进桶；遗留数据不单列（用户要求不看）', () => {
+  const tree = pluginTree(treeNodes())
+  const bySection = new Map(tree.buckets.map((b) => [b.section, b]))
+  assert.deepEqual([...bySection.keys()].sort(), ['pluginFiles', 'plugins'],
+    '桶只有两个：pluginFiles 与「插件分区的其他条目」')
+  assert.deepEqual(bySection.get('pluginFiles')?.units.map((u) => u.id), ['pluginFiles:dsh-ssh.json'])
+  assert.deepEqual(bySection.get('plugins')?.units.map((u) => u.id), ['plugins:pnpm-workspace'])
+  assert.equal(bySection.get('pluginData'), undefined, '未被认领的数据单元不再单列「遗留数据」桶')
+  assert.equal(bySection.get('pluginAssets'), undefined)
+})
+
+test('按插件看：插件节点三态与一键勾选（逐个走 toggleUnit，不静默全选整个分区）', () => {
+  const nodes = treeNodes()
+  const alpha = pluginTree(nodes).entries.find((e) => e.name === 'alpha')!
+  let sel = defaultSelection(TREE_SECTIONS)
+  // 只有清单条目被勾上 → 部分选中（数据区域属于未勾选的分区）
+  assert.equal(pluginEntrySelectedCount(sel, alpha), 1)
+  assert.equal(pluginEntryPickState(sel, alpha), 'partial')
+  sel = togglePluginEntry(sel, nodes, alpha, true)
+  assert.deepEqual(sel.sections, ['plugins', 'pluginData'])
+  // 只勾该插件的区域：同分区里未被认领的遗留数据（.gone/state）不得被一起带上
+  assert.deepEqual(buildExportRequest(sel, nodes), {
+    only: ['plugins', 'pluginData'],
+    includeItems: { pluginData: ['pluginData:.alpha/runtime'] },
+  })
+  // 反向：取消该插件 → 它的清单条目与数据区域一起取消，其余插件不动
+  sel = togglePluginEntry(sel, nodes, alpha, false)
+  assert.deepEqual(sel.sections, ['plugins'], '数据区域被取消后，pluginData 随之移出勾选')
+  assert.equal(sel.excluded.includes('plugin:alpha'), true)
+  assert.equal(sel.excluded.includes('pluginData:.alpha/runtime'), true)
+})
+
+test('「插件」一级区块：三态只算插件名下存在的叶子，未归属桶不参与', () => {
+  const nodes = treeNodes()
+  const tree = pluginTree(nodes)
+  let sel = defaultSelection(TREE_SECTIONS)
+  // 叶子 = alpha 的清单条目 + 它的数据区域 + beta 的清单条目（未归属的 .gone/state 与 pluginFiles 不计）
+  assert.equal(pluginTreeLeafCount(tree), 3)
+  assert.equal(pluginTreeSelectedCount(sel, tree), 2, '两个插件的清单条目默认已勾：alpha + beta')
+  assert.equal(pluginTreePickState(sel, tree), 'partial')
+  sel = togglePluginTree(sel, nodes, tree, true)
+  assert.equal(pluginTreePickState(sel, tree), 'all')
+  assert.deepEqual(buildExportRequest(sel, nodes), {
+    only: ['plugins', 'pluginData'],
+    includeItems: { pluginData: ['pluginData:.alpha/runtime'] },
+  })
+  // 未归属 / 遗留数据没有任何文档说过要一起带上：它们的单元不得因一级区块被勾选
+  assert.equal(sel.excluded.includes('pluginData:.gone/state'), true)
+  assert.equal(sel.sections.includes('pluginFiles'), false)
+})
+
+test('「插件」一级区块：取消勾选后所有插件单元都不再导出（桶里的补丁行不受影响）', () => {
+  const nodes = treeNodes()
+  const tree = pluginTree(nodes)
+  const sel = togglePluginTree(defaultSelection(TREE_SECTIONS), nodes, tree, false)
+  assert.equal(pluginTreePickState(sel, tree), 'none')
+  // 插件分区仍被勾着 —— 因为 **桶里** 的 pnpm-workspace.yaml / 补丁行不属于任何插件，
+  // 一级区块的勾选框不碰它们（「全选所有插件」不该顺手动没人认领的东西）
+  assert.deepEqual(sel.sections, ['plugins'])
+  assert.equal(sel.excluded.includes('plugin:alpha'), true)
+  assert.equal(sel.excluded.includes('plugin:beta'), true)
+  assert.equal(sel.excluded.includes('plugins:pnpm-workspace'), false)
+})
+
+test('计数不随清单到货跳动：「已选 n/m」的分母用「已知」叶子（含未读取的区域）', () => {
+  const nodes = treeNodes()
+  nodes[0]!.units[0] = {
+    ...nodes[0]!.units[0]!,
+    relatedAreas: [
+      { section: 'pluginData', relPath: '.alpha/runtime', role: 'config' },
+      { section: 'pluginAssets', relPath: '.alpha/uploads', role: 'assets' },
+    ],
+  }
+  const before = pluginTree(nodes)
+  const alphaBefore = before.entries.find((e) => e.name === 'alpha')!
+  assert.equal(pluginEntryTotalCount(alphaBefore), 3, '清单条目 + 已读到区域 + 未读取区域')
+  assert.equal(pluginTreeTotalCount(before), 4, 'alpha 3 项 + beta 1 项')
+  // 模拟清单到货：同一个声明区域从 unread 变成 present —— 分母必须**不变**
+  nodes[2] = {
+    section: 'pluginAssets', count: 1, sizeBytes: 9,
+    units: [{ id: 'pluginAssets:.alpha/uploads', label: '.alpha/uploads', sizeBytes: 9 }],
+  }
+  const after = pluginTree(nodes)
+  const alphaAfter = after.entries.find((e) => e.name === 'alpha')!
+  assert.equal(pluginEntryTotalCount(alphaAfter), 3)
+  assert.equal(pluginTreeTotalCount(after), 4)
+  assert.deepEqual(alphaAfter.leaves.map((l) => l.state), ['present', 'present', 'present'])
+})
+
+test('待补勾：清单没到齐时留在队列（绝不假装已勾），到货后补齐并出队', () => {
+  const nodes = treeNodes()
+  nodes[0]!.units[0] = {
+    ...nodes[0]!.units[0]!,
+    relatedAreas: [
+      { section: 'pluginData', relPath: '.alpha/runtime', role: 'config' },
+      { section: 'pluginAssets', relPath: '.alpha/uploads', role: 'assets' },
+    ],
+  }
+  const pending = [{ key: 'alpha', kind: 'entry' as const }]
+  const waiting = applyPluginPendingChecks(defaultSelection(TREE_SECTIONS), nodes, pluginTree(nodes), pending)
+  assert.deepEqual(waiting.remaining, pending, '大文件分区还没读 → 继续等')
+  // 到货
+  nodes[2] = {
+    section: 'pluginAssets', count: 1, sizeBytes: 9,
+    units: [{ id: 'pluginAssets:.alpha/uploads', label: '.alpha/uploads', sizeBytes: 9 }],
+  }
+  const tree2 = pluginTree(nodes)
+  const done = applyPluginPendingChecks(defaultSelection(TREE_SECTIONS), nodes, tree2, pending)
+  assert.deepEqual(done.remaining, [])
+  const alpha = tree2.entries.find((e) => e.name === 'alpha')!
+  assert.equal(pluginEntrySelectedCount(done.selection, alpha), 3, '补齐后 = 该插件名下全部叶子')
+  assert.equal(pluginEntryPickState(done.selection, alpha), 'all')
+})
+
+test('「插件」一级区块展开前要读的分区：插件清单自己没读到也要报（否则展开后没有读取入口）', () => {
+  const nodes = treeNodes()
+  // alpha 声明了一个大文件区域（该分区清单还没读）
+  nodes[0]!.units[0] = {
+    ...nodes[0]!.units[0]!,
+    relatedAreas: [
+      { section: 'pluginData', relPath: '.alpha/runtime', role: 'config' },
+      { section: 'pluginAssets', relPath: '.alpha/uploads', role: 'assets' },
+    ],
+  }
+  assert.deepEqual(pluginTreeUnreadSections(pluginTree(nodes)), ['pluginAssets'])
+  const unreadPlugins: SelectionSection[] = [
+    { section: 'plugins', count: 0, sizeBytes: 0, units: [], unitsUnread: true },
+    { section: 'pluginData', count: 0, sizeBytes: 0, units: [], unitsUnread: true },
+  ]
+  assert.deepEqual(pluginTreeUnreadSections(pluginTree(unreadPlugins)), ['plugins'])
+})
+
+test('按插件看：搜索命中插件名保留它全部叶子；只命中叶子时保留该叶子', () => {
+  const tree = pluginTree(treeNodes())
+  const byName = filterPluginTree(tree, 'ALPHA')
+  assert.deepEqual(byName.entries.map((e) => e.name), ['alpha'])
+  assert.equal(byName.entries[0]?.leaves.length, 2, '插件名命中时保留全部叶子')
+  const byLeaf = filterPluginTree(tree, 'dsh-ssh')
+  assert.deepEqual(byLeaf.entries.map((e) => e.name), [])
+  assert.deepEqual(byLeaf.buckets.map((b) => b.section), ['pluginFiles'])
+})
+
+test('选择模型：sectionsFromPreview 透传 group 与 relatedAreas（按插件看的两个输入）', () => {
+  const nodes = sectionsFromPreview([
+    {
+      section: 'plugins', count: 1, sizeBytes: 10,
+      items: [{
+        id: 'plugin:alpha', label: 'alpha', sizeBytes: 10,
+        relatedAreas: [{ section: 'pluginData', relPath: '.alpha/runtime', role: 'config' }],
+      }],
+    },
+    { section: 'skills', count: 1, sizeBytes: 10, items: [{ id: 'skills:x', label: 'x', sizeBytes: 10 }] },
+  ])
+  assert.deepEqual(nodes[0]?.units[0]?.relatedAreas, [{ section: 'pluginData', relPath: '.alpha/runtime', role: 'config' }])
+  assert.equal(nodes[1]?.units[0]?.relatedAreas, undefined, '没有声明的单元不得凭空带 relatedAreas')
+});