dsh-config-manager 0.1.69 → 0.1.70

package/lib/adapters/plugin-files.js

@@ -45,8 +45,12 @@ export class PluginFilesAdapter {
                 files.push({ relativePath: rel, data, contentHash: sha256Hex(data) });
                 seen.add(rel);
             }
-            catch {
-                /* 白名单文件不存在则跳过 */
+            catch (err) {
+                // ui-F2：白名单文件**不存在**是正常形态（按需创建 → 跳过）；**读不到**（权限/竞态/断链）
+                // 绝不能静默丢内容 —— 与文件集合基类同一语义：整分区显式失败，导出报告可见。
+                if (await this.absentOnDisk(ctx, rel))
+                    continue;
+                throw err;
             }
         }
         // 2) 约定配置目录递归收集（相对 ~/.dsh 根的完整路径；与白名单文件去重）
@@ -69,8 +73,11 @@ export class PluginFilesAdapter {
                     const data = await ctx.fs.readFile(rel);
                     files.push({ relativePath: rel, data, contentHash: sha256Hex(data) });
                 }
-                catch {
-                    continue;
+                catch (err) {
+                    // ui-F2：同上 —— 目录遍历刚点到的文件却读不到，是真实的读取失败，不是「不存在」。
+                    if (await this.absentOnDisk(ctx, rel))
+                        continue;
+                    throw err;
                 }
             }
         }
@@ -81,6 +88,21 @@ export class PluginFilesAdapter {
             warnings: linkWarnings(msgOf(ctx), this.displayName, listing),
         };
     }
+    /**
+     * 读失败之后判定「这个路径本来就不存在」还是「存在但读不到」（ui-F2）。
+     *
+     * 为什么不用错误码：门面错误的形状并不统一（内存 mock 与各平台 EACCES 文案不同），
+     * 而 `exists()` 是 FileSystemFacade 契约里唯一稳定的存在性判据。`exists()` 自己也失败时
+     * 按「存在」处理（保守：宁可让这次导出显式失败，也不静默丢一个文件）。
+     */
+    async absentOnDisk(ctx, rel) {
+        try {
+            return (await ctx.fs.exists(rel)) === false;
+        }
+        catch {
+            return false;
+        }
+    }
     /** 单元清单（零 I/O）：逐文件单元，id 与导入侧 `pluginFiles:<relPath>` 一致。 */
     listUnits(section) {
         return unitsFromFiles(this.id, section.data.files, (rel) => rel);
@@ -144,6 +166,16 @@ export class PluginFilesAdapter {
         return validateJsonSection('pluginFiles', data, msg, (section, issues) => {
             if (!Array.isArray(section.files)) {
                 issues.push({ path: 'files', message: msg('adapter.validate.array', { subject: 'files' }), severity: 'error' });
+                return;
+            }
+            // ui-F3：条目级形状校验必须与 analyzeImport 的假设对齐（它直接读 file.relativePath）。
+            // 只校验「是数组」会放过 files:[null] / relativePath:42 这类畸形，analyzeImport 抛内部
+            // TypeError → ImportAnalysis.valid=false → 整包被拦下，用户看到的是内部异常文本。
+            for (const [i, f] of section.files.entries()) {
+                const entry = f;
+                if (entry === null || typeof entry !== 'object' || typeof entry.relativePath !== 'string' || entry.relativePath === '') {
+                    issues.push({ path: `files[${i}]`, message: msg('adapter.validate.fileRelativePath'), severity: 'error' });
+                }
             }
         });
     }

package/lib/adapters/plugins.d.ts

@@ -1,8 +1,13 @@
 import type { PackLocalPluginsResult } from '../core/local-plugin-pack.ts';
 import type { MsgFunc } from '../core/messages.ts';
+import { USER_PATCH_FILE } from '../core/patch-layers.ts';
 import type { PluginEntry, PluginsSection } from '../schema/types.ts';
-import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, ExportUnit, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
-export declare const USER_PATCH_FILE = "cordis.patch.yml";
+import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, ExportUnit, HostContext, ImportContext, PlanItem, SectionPreview, ValidationResult } from '../core/types.ts';
+/**
+ * 用户（home）patch 层路径 —— 定义已移到 `core/patch-layers.ts`（issue #71：patch 有 home /
+ * profile 两层，层身份属于引擎知识，不属于某个 adapter）。此处 re-export 保持既有 import 面。
+ */
+export { USER_PATCH_FILE };
 /**
  * 本地源插件打包钩子（由宿主注入，见 src/index.ts createAdapters）。
  * 返回打包结果（含字节与重写后的 spec）；不注入 = 不做本地源打包（保持旧行为）。
@@ -31,6 +36,27 @@ export declare class PluginsAdapter implements ConfigAdapter<PluginsSection> {
     private readonly localPack;
     constructor(selfName?: string, localPack?: LocalPluginPackHook);
     export(ctx: HostContext, options: ExportOptions): Promise<ExportSection<PluginsSection>>;
+    /**
+     * 只读预览（`/export-preview` 用）：与 `export()` **同口径**，但不做任何本地源打包。
+     *
+     * 为什么必须覆写：基类缺省会让调用方退回 `export()`，而 `export()` 会为每个 `link:`/`file:`
+     * 插件 spawn 一次 `npm pack`（真机 12 个本地源插件 ≈12 s）。「总览」页只想知道条目数与体积，
+     * 却因此每次都要打包一遍全部本地插件 —— 预览是纯只读路径，不该有任何进程副作用。
+     *
+     * 与 `export()` 的**唯一**差异：
+     * - 不注入 `localTarballs`（没有字节），故清单 spec 保持原样（不做 `file:<tarball>` 改写）；
+     * - 插件单元体积改为 `file:` 源的一次 stat（`measureLocalSources`），`link:` 目录按 0；
+     * - 体积用一次 `stringify` 算 UTF-8 字节数（与 /export-preview 对 JSON 分区的口径一致）。
+     * 其余（清单过滤、patch 行、pnpm-workspace、patchFiles、条目级白名单、告警文案、单元分组）逐字相同。
+     */
+    preview(ctx: HostContext, options: ExportOptions): Promise<SectionPreview<PluginsSection>>;
+    /**
+     * 导出与预览的共同内核。
+     *
+     * `pack=false` 时跳过本地源打包（预览路径）—— 除该段外两条路径逐字共用，
+     * 避免「预览说会带什么」与「导出真的带什么」分叉。
+     */
+    private collect;
     /**
      * 单元清单（Phase 1；零 I/O：直接由 export 产物派生）。
      *

package/lib/adapters/plugins.js

@@ -10,17 +10,25 @@
  * 文件条目随分区进入 ZIP（落在 `plugin-files/local-plugins/` 前缀下，复用既有文件类分区通道，
  * **不新增分区 id**）；导入时把 spec 重写为 `file:<解包后的绝对路径>` 再交给官方安装通道。
  */
+import { join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { sha256Hex } from '../utils/hashing.js';
 import { installSpecFor, resolveProcessProfileName } from '../core/plugin-cli.js';
-import { LOCAL_PLUGIN_DIR } from '../core/local-plugin-pack.js';
+import { classifyPluginSpec, LOCAL_PLUGIN_DIR, resolveLocalPluginPath } from '../core/local-plugin-pack.js';
 import { msgOf, zhMsg } from '../core/messages.js';
+import { stringifyJsonSafe } from '../utils/json.js';
 import { isPathSafe, normalizePath } from '../utils/paths.js';
+import { isENOENT } from '../utils/guards.js';
 import { PLUGIN_PATCH_REF_PREFIX } from '../core/backup.js';
+import { readEffectivePatchLines, resolveWriteLayer, USER_PATCH_FILE } from '../core/patch-layers.js';
 import { parsePnpmPatchedDependencies, sanitizePnpmWorkspacePatches } from './pnpm-workspace.js';
 import { sectionMeta } from '../schema/section-registry.js';
 import { validateJsonSection } from './json-section.js';
-export const USER_PATCH_FILE = 'cordis.patch.yml';
+/**
+ * 用户（home）patch 层路径 —— 定义已移到 `core/patch-layers.ts`（issue #71：patch 有 home /
+ * profile 两层，层身份属于引擎知识，不属于某个 adapter）。此处 re-export 保持既有 import 面。
+ */
+export { USER_PATCH_FILE };
 /** tarball 字节 → base64（零依赖，避免 Buffer 在浏览器侧类型问题） */
 function bytesToBase64(data) {
     if (typeof Buffer !== 'undefined')
@@ -108,6 +116,109 @@ function entriesOfRaw(raw) {
     }
     return [];
 }
+/**
+ * 预览路径测到的本地源插件体积（`preview()` 写入，`listUnits()` 读取）。
+ *
+ * 为什么用 WeakMap 而不是给 `PluginsSection` 加字段：`localTarballs` 是备份格式的一部分
+ * （schema 校验、市场安全防线都在看它），而预览产物里本就没有 tarball 字节；把「只读预览测到的
+ * 体积」混进载荷只会让「预览说的」与「导出做的」更难分辨。挂在载荷对象上则随对象一起回收，
+ * 导出产物（真实 base64）走另一条分支，行为逐字不变。
+ */
+const previewTarballBytes = new WeakMap();
+/**
+ * 零 spawn 推导本地源插件的体积（预览专用）。
+ *
+ * 两条路径，都是**只读度量**、都不 spawn 打包进程：
+ *  - `file:` 源 → 一次 stat：源 tarball 本身就是 gzip 容器，字节数与 `npm pack` 产物同量级；
+ *  - `link:` 源 → 目录体积上界（`fs.dirSizeBytes`）：这是 `npm pack` 的输入目录，体积比
+ *    pack 产物大（真机约 3.4 倍，pack 产物是 gzip），用来展示「量级」足够。
+ *    绝不在这里手写递归（见 local-plugin-pack.ts 安全约束：node_modules 由 npm pack 自己排除，
+ *    手写递归会把它整个算进来）——度量交给宿主门面，由它负责跳过 node_modules 与链接目录。
+ *
+ * 登记本身就是语义：Map 里有该插件 = 「该单元随备份携带一个文件」，与导出产物里
+ * `npm pack` 打出的 tarball（`fileCount: 1`）对齐；宿主未实现相应度量、越界路径
+ * （fs 门面对 home 外绝对路径抛 `host.fsPathEscape`）、目录读不到一律按 0 ——
+ * 预览绝不能因为一个体积数字而失败。
+ */
+async function measureLocalSources(plugins, ctx) {
+    const sizes = new Map();
+    const statSize = ctx.fs.statSize;
+    const dirSize = ctx.fs.dirSizeBytes;
+    // profile 目录与打包钩子同源（local-plugin-host.ts：优先 profileDir，回退按 profile 名拼接）
+    const profileDir = ctx.profileDir !== undefined && ctx.profileDir !== ''
+        ? ctx.profileDir
+        : join(ctx.homeDir, PNPM_PROFILE_DIR(ctx.profile));
+    for (const pl of plugins) {
+        const kind = classifyPluginSpec(pl.spec);
+        if (kind !== 'file' && kind !== 'link')
+            continue;
+        try {
+            const abs = resolveLocalPluginPath(pl.spec ?? '', { homeDir: ctx.homeDir, profileDir });
+            // 宿主未实现对应度量 → null → 按 0（旧行为，只少一个数字）
+            const size = kind === 'link'
+                ? (dirSize !== undefined ? await dirSize.call(ctx.fs, abs) : null)
+                : (statSize !== undefined ? await statSize.call(ctx.fs, abs) : null);
+            sizes.set(pl.name, size !== null && size > 0 ? size : 0);
+        }
+        catch {
+            // 越界 / 读不到：按 0 处理（预览不因此失败），但仍算「随包携带一个文件」
+            sizes.set(pl.name, 0);
+        }
+    }
+    return sizes;
+}
+/**
+ * 由分区载荷派生单元清单（纯函数、零 I/O）。
+ *
+ * 单元 = 插件包 / cordis 补丁行 / pnpm-workspace.yaml / 单个 patch 文件。
+ * 后两者构成**原子组**：patchedDependencies 的声明与 patches/** 文件必须同进同出
+ * （issue #35 —— 只搬声明会让目标机 pnpm 拒绝一切 add），故互相写进 lockedWith，
+ * 由选择模型保证勾选/取消同步。
+ *
+ * `tarballBytes` = 预览路径登记到的本地源体积（见 measureLocalSources，0 = 体积未知但仍随包携带）；
+ * 缺省时体积与文件数完全按导出产物里的 base64 计算 —— 与改造前逐字一致。
+ */
+function unitsOf(data, tarballBytes) {
+    const wsId = 'plugins:pnpm-workspace';
+    const patchFileIds = (data.patchFiles ?? []).map((pf) => `plugins:patch:${normalizePath(pf.relativePath)}`);
+    const group = [wsId, ...patchFileIds];
+    const units = [];
+    for (const pl of data.plugins) {
+        const tarball = tarballOf(data, pl.name);
+        const measured = tarballBytes?.get(pl.name);
+        units.push({
+            id: `plugin:${pl.name}`,
+            label: pl.name,
+            detail: pl.version,
+            // base64 长度 → 原始字节数（仅用于展示体积，不求精确）；预览路径没有字节，用 stat 量到的源体积
+            sizeBytes: tarball !== undefined ? Math.floor((tarball.base64.length * 3) / 4) : measured ?? 0,
+            ...(tarball !== undefined || measured !== undefined ? { fileCount: 1 } : {}),
+        });
+    }
+    for (const line of data.patch) {
+        // 由 mcp / prompts adapter 管理的行不属本分区（applyItem 同样跳过），列出来只会误导用户
+        if (isManagedElsewhere(line.raw))
+            continue;
+        units.push({ id: `patch:${line.lineId}`, label: line.lineId, sizeBytes: 0 });
+    }
+    if (data.pnpmWorkspace !== undefined && data.pnpmWorkspace !== null && data.pnpmWorkspace !== '') {
+        units.push({
+            id: wsId,
+            label: 'pnpm-workspace.yaml',
+            sizeBytes: data.pnpmWorkspace.length,
+            ...(group.length > 1 ? { lockedWith: group } : {}),
+        });
+    }
+    for (const pf of data.patchFiles ?? []) {
+        units.push({
+            id: `plugins:patch:${normalizePath(pf.relativePath)}`,
+            label: pf.relativePath,
+            sizeBytes: Math.floor((pf.base64.length * 3) / 4),
+            ...(group.length > 1 ? { lockedWith: group } : {}),
+        });
+    }
+    return units;
+}
 export class PluginsAdapter {
     id = 'plugins';
     // 元数据唯一来源 = 注册表（t31）：不再与 ui/export-flow.ts 的导出目录各写一份
@@ -123,6 +234,41 @@ export class PluginsAdapter {
         this.localPack = localPack;
     }
     async export(ctx, options) {
+        return this.collect(ctx, options, true);
+    }
+    /**
+     * 只读预览（`/export-preview` 用）：与 `export()` **同口径**，但不做任何本地源打包。
+     *
+     * 为什么必须覆写：基类缺省会让调用方退回 `export()`，而 `export()` 会为每个 `link:`/`file:`
+     * 插件 spawn 一次 `npm pack`（真机 12 个本地源插件 ≈12 s）。「总览」页只想知道条目数与体积，
+     * 却因此每次都要打包一遍全部本地插件 —— 预览是纯只读路径，不该有任何进程副作用。
+     *
+     * 与 `export()` 的**唯一**差异：
+     * - 不注入 `localTarballs`（没有字节），故清单 spec 保持原样（不做 `file:<tarball>` 改写）；
+     * - 插件单元体积改为 `file:` 源的一次 stat（`measureLocalSources`），`link:` 目录按 0；
+     * - 体积用一次 `stringify` 算 UTF-8 字节数（与 /export-preview 对 JSON 分区的口径一致）。
+     * 其余（清单过滤、patch 行、pnpm-workspace、patchFiles、条目级白名单、告警文案、单元分组）逐字相同。
+     */
+    async preview(ctx, options) {
+        const collected = await this.collect(ctx, options, false);
+        const data = collected.data;
+        const tarballBytes = await measureLocalSources(data.plugins, ctx);
+        if (tarballBytes.size > 0)
+            previewTarballBytes.set(data, tarballBytes);
+        return {
+            section: collected,
+            // 与 src/index.ts 对 JSON 分区现算体积的口径一致（utf8 字节数）
+            sizeBytes: new TextEncoder().encode(stringifyJsonSafe(data)).length,
+            items: unitsOf(data, tarballBytes),
+        };
+    }
+    /**
+     * 导出与预览的共同内核。
+     *
+     * `pack=false` 时跳过本地源打包（预览路径）—— 除该段外两条路径逐字共用，
+     * 避免「预览说会带什么」与「导出真的带什么」分叉。
+     */
+    async collect(ctx, options, pack) {
         const plugins = [];
         const warnings = [];
         try {
@@ -146,13 +292,13 @@ export class PluginsAdapter {
             warnings.push(msgOf(ctx)('adapter.pluginListReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
         }
         const patch = [];
-        try {
-            const lines = await ctx.patchFile.readPatchLines(USER_PATCH_FILE);
-            for (const l of lines)
-                patch.push({ file: USER_PATCH_FILE, lineId: l.lineId, raw: l.raw });
-        }
-        catch (err) {
-            warnings.push(msgOf(ctx)('adapter.patchReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
+        // issue #71：patch 有两层（home 层 + profile 层），只读 home 层会漏掉 DSH 工具与 marketplace
+        // 写入 profile 层的激活行 —— 导出少了它们，导入到新机就少一批插件加载项。
+        const patchRead = await readEffectivePatchLines(ctx.patchFile, ctx.profile);
+        for (const l of patchRead.lines)
+            patch.push({ file: l.file, lineId: l.lineId, raw: l.raw });
+        for (const f of patchRead.failures) {
+            warnings.push(msgOf(ctx)('adapter.patchReadFailed', { reason: `${f.file}: ${f.reason}` }));
         }
         // pnpm-workspace.yaml（allowBuilds / minimumReleaseAgeExclude 等）：随插件分区迁移，
         // 否则目标 profile 的 pnpm 可能因构建白名单/冷静期拒绝安装插件（§34.17 同款语义）。
@@ -210,7 +356,7 @@ export class PluginsAdapter {
         // （曾导致插件被静默丢失）。钩子由宿主注入；未注入 / 无本地源 / 单个失败一律不中断导出。
         let localTarballs;
         let effectivePlugins = plugins;
-        if (this.localPack !== undefined) {
+        if (pack && this.localPack !== undefined) {
             try {
                 const packed = await this.localPack(plugins, ctx);
                 warnings.push(...packed.warnings);
@@ -282,45 +428,8 @@ export class PluginsAdapter {
      * 由选择模型保证勾选/取消同步。
      */
     listUnits(section) {
-        const data = section.data;
-        const wsId = 'plugins:pnpm-workspace';
-        const patchFileIds = (data.patchFiles ?? []).map((pf) => `plugins:patch:${normalizePath(pf.relativePath)}`);
-        const group = [wsId, ...patchFileIds];
-        const units = [];
-        for (const pl of data.plugins) {
-            const tarball = (data.localTarballs ?? []).find((t) => t.packageName === pl.name);
-            units.push({
-                id: `plugin:${pl.name}`,
-                label: pl.name,
-                detail: pl.version,
-                // base64 长度 → 原始字节数（仅用于展示体积，不求精确）
-                sizeBytes: tarball !== undefined ? Math.floor((tarball.base64.length * 3) / 4) : 0,
-                ...(tarball !== undefined ? { fileCount: 1 } : {}),
-            });
-        }
-        for (const line of data.patch) {
-            // 由 mcp / prompts adapter 管理的行不属本分区（applyItem 同样跳过），列出来只会误导用户
-            if (isManagedElsewhere(line.raw))
-                continue;
-            units.push({ id: `patch:${line.lineId}`, label: line.lineId, sizeBytes: 0 });
-        }
-        if (data.pnpmWorkspace !== undefined && data.pnpmWorkspace !== null && data.pnpmWorkspace !== '') {
-            units.push({
-                id: wsId,
-                label: 'pnpm-workspace.yaml',
-                sizeBytes: data.pnpmWorkspace.length,
-                ...(group.length > 1 ? { lockedWith: group } : {}),
-            });
-        }
-        for (const pf of data.patchFiles ?? []) {
-            units.push({
-                id: `plugins:patch:${normalizePath(pf.relativePath)}`,
-                label: pf.relativePath,
-                sizeBytes: Math.floor((pf.base64.length * 3) / 4),
-                ...(group.length > 1 ? { lockedWith: group } : {}),
-            });
-        }
-        return units;
+        // 预览产物没有 tarball 字节，体积来自 measureLocalSources 挂上的统计（导出产物走 base64 分支）
+        return unitsOf(section.data, previewTarballBytes.get(section.data));
     }
     /**
      * 导入后目标机**可能**存在的 patch 文件集合（相对 profile 目录）——issue #35。
@@ -343,7 +452,13 @@ export class PluginsAdapter {
                 if (await ctx.target.fs.exists(`${profileDir}/${rel}`))
                     set.add(rel);
             }
-            catch { /* 读不到 = 视为不存在 */ }
+            catch (err) {
+                // t81 / t23 口径：**读不到 ≠ 没有**。只有 ENOENT 才是「本来就没有」；EACCES/EBUSY/IO 一律上抛，
+                // 否则会把「声明在、文件也在」的 patch 当作不存在 → 从将要写入的 pnpm-workspace.yaml 里剔除
+                // （issue #35 的症状：目标机 pnpm 从此拒绝一切 add）。存在性探测自身失败不得降级成「不存在」。
+                if (!isENOENT(err))
+                    throw err;
+            }
         }
         return set;
     }
@@ -466,17 +581,21 @@ export class PluginsAdapter {
         }
         // 用户 patch 行：lineId 唯一键；存在且同 → Skip；存在不同 → Conflict；不存在 → Create。
         // mcp-client 行与 systemPrompt/planMode 行由 mcp/prompts adapter 管理，此处跳过（避免重复写入覆盖）。
-        const targetLines = await ctx.target.patchFile.readPatchLines(USER_PATCH_FILE);
+        // issue #71：目标行同样跨两层（否则 profile 层已有的行会被误判成 Create → 导入后出现重复行）
+        const targetLines = (await readEffectivePatchLines(ctx.target.patchFile, ctx.target.profile)).lines;
         for (const pl of data.patch) {
             if (isManagedElsewhere(pl.raw))
                 continue;
             const id = `patch:${pl.lineId}`;
             const tl = targetLines.find((l) => l.lineId === pl.lineId);
+            // 层身份随计划项走：applyItem 按 pl.file 写回，导入前快照按 target.file 记原行，
+            // 两者必须是同一层，否则回滚会把另一层改坏（issue #71）。
+            const layer = resolveWriteLayer(pl.file, ctx.target.profile);
             if (!tl) {
                 items.push({
                     id, kind: 'Create', adapter: 'plugins',
                     description: msg('adapter.patchLineCreate', { lineId: pl.lineId }), severity: 'info',
-                    target: { adapter: 'plugins', ref: pl.lineId },
+                    target: { adapter: 'plugins', ref: pl.lineId, file: layer },
                 });
             }
             else if (isDeepStrictEqual(tl.raw, pl.raw)) {
@@ -486,7 +605,7 @@ export class PluginsAdapter {
                 items.push({
                     id, kind: 'Conflict', adapter: 'plugins',
                     description: msg('adapter.patchLineDiff', { lineId: pl.lineId }), severity: 'warning',
-                    target: { adapter: 'plugins', ref: pl.lineId },
+                    target: { adapter: 'plugins', ref: pl.lineId, file: layer },
                 });
             }
         }
@@ -542,7 +661,11 @@ export class PluginsAdapter {
                     if (await ctx.target.fs.exists(`${profileDir}/${rel}`))
                         available.add(rel);
                 }
-                catch { /* 读不到 = 视为不存在 */ }
+                catch (err) {
+                    // 同上（t81 / t23）：探测失败必须上抛，绝不把它降级成「声明不可满足」而写瘦 pnpm-workspace.yaml。
+                    if (!isENOENT(err))
+                        throw err;
+                }
             }
             const clean = sanitizePnpmWorkspacePatches(text, (rel) => available.has(rel));
             try {
@@ -631,7 +754,9 @@ export class PluginsAdapter {
         const pl = data?.patch.find((p) => p.lineId === ref);
         if (!pl)
             return { ok: false, message: msg('adapter.patchMissing', { ref }) };
-        await ctx.target.patchFile.applyPatchChanges(pl.file, [
+        // 层身份按**语义**映射到目标机：来源是别的 profile 层时不能照抄名字（目标机未必有那个
+        // profile，宿主门面会拒绝），一律落到目标机当前 profile 层（与计划项 target.file 同口径）。
+        await ctx.target.patchFile.applyPatchChanges(resolveWriteLayer(pl.file, ctx.target.profile), [
             { lineId: ref, raw: pl.raw, action: item.kind === 'Create' ? 'insert' : 'update' },
         ]);
         return { ok: true, needsRestart: true, message: msg('adapter.patchWritten', { ref }) };
@@ -641,9 +766,33 @@ export class PluginsAdapter {
             if (!Array.isArray(section.plugins)) {
                 issues.push({ path: 'plugins', message: msg('adapter.validate.array', { subject: 'plugins' }), severity: 'error' });
             }
+            else {
+                // ui-F3：条目级形状必须与 analyzeImport 的假设对齐（它直接读 p.name / p.version）。
+                // 只校验「是数组」会放过 plugins:[null]，analyzeImport 抛内部 TypeError → 整包被拦下。
+                for (const [i, raw] of section.plugins.entries()) {
+                    const p = raw;
+                    if (p === null || typeof p !== 'object') {
+                        issues.push({ path: `plugins[${i}]`, message: msg('adapter.validate.recordObject', { subject: 'plugin' }), severity: 'error' });
+                        continue;
+                    }
+                    const name = p.name;
+                    if (typeof name !== 'string' || name === '') {
+                        issues.push({ path: `plugins[${i}].name`, message: msg('adapter.validate.requiredField', { subject: 'plugins[].name' }), severity: 'error' });
+                    }
+                }
+            }
             if (section.patch !== undefined && !Array.isArray(section.patch)) {
                 issues.push({ path: 'patch', message: msg('adapter.validate.array', { subject: 'patch' }), severity: 'error' });
             }
+            else if (Array.isArray(section.patch)) {
+                // ui-F3：patch 条目在 analyzeImport 里被读 pl.raw / pl.lineId（isManagedElsewhere(pl.raw)）。
+                for (const [i, raw] of section.patch.entries()) {
+                    const pl = raw;
+                    if (pl === null || typeof pl !== 'object') {
+                        issues.push({ path: `patch[${i}]`, message: msg('adapter.validate.recordObject', { subject: 'patch line' }), severity: 'error' });
+                    }
+                }
+            }
             if (section.pnpmWorkspace !== undefined && section.pnpmWorkspace !== null && typeof section.pnpmWorkspace !== 'string') {
                 issues.push({ path: 'pnpmWorkspace', message: msg('adapter.validate.string', { subject: 'pnpmWorkspace' }), severity: 'error' });
             }

package/lib/adapters/prompts.d.ts

@@ -1,18 +1,28 @@
 import type { MsgFunc } from '../core/messages.ts';
 import type { PromptEntry } from '../schema/types.ts';
 import type { ApplyResult, ConfigAdapter, ExportOptions, ExportSection, HostContext, ImportContext, PlanItem, ValidationResult } from '../core/types.ts';
-/** 导出记录：PromptEntry 之外记录来源行名（导入需要重建行时使用） */
+/** 导出记录：PromptEntry 之外记录来源行名与所在层（导入重建 / 写回定位用） */
 export interface PromptExportEntry extends PromptEntry {
     sourceLineName?: string;
+    /**
+     * 来源 patch 层（相对 homeDir 的 POSIX 路径；见 core/patch-layers.ts）。
+     * 缺省 = 用户层（旧备份包没有该字段 → 按旧行为写回 home 层）。
+     */
+    sourceFile?: string;
 }
 export interface PromptsExportSection {
     version: 1;
     prompts: PromptExportEntry[];
 }
-/** 从 patch 行 config 中提取 prompt 条目（systemPrompt.persona / planMode.sections[].text） */
+/**
+ * 从 patch 行 config 中提取 prompt 条目（systemPrompt.persona / planMode.sections[].text）。
+ *
+ * 行对象可带 `file`（层身份）：带上时逐条目记录 `sourceFile`，导入写回落回原层。
+ */
 export declare function extractPrompts(lines: {
     lineId: string;
     raw: unknown;
+    file?: string;
 }[]): PromptExportEntry[];
 /** 把 prompt 文本合并进目标行 config（systemPrompt.persona 或 planMode.sections） */
 export declare function mergePromptIntoLine(raw: unknown, prompt: PromptExportEntry): Record<string, unknown>;

package/lib/adapters/prompts.js

@@ -8,12 +8,19 @@
  *  - 目标无该行但存在同名 prompt → Conflict（更新其所在行）；
  *  - 均不存在 → Warning（不编造行名自动创建，提示手动配置）。
  * rules/commands 无独立存储（研究报告 §2.2），不实现。
+ *
+ * issue #71：数据源与 mcp 分区同因 —— patch 有 home 层与 profile 层两层，此前只读 home 层，
+ * 于是写进 profile 层的 systemPrompt / planMode 在备份里全部丢失。现在两层都读、写回原层。
  */
 import { msgOf, zhMsg } from '../core/messages.js';
-import { USER_PATCH_FILE } from './plugins.js';
+import { locatePatchLineLayer, readEffectivePatchLines, resolveWriteLayer } from '../core/patch-layers.js';
 import { sectionMeta } from '../schema/section-registry.js';
 import { validateJsonSection } from './json-section.js';
-/** 从 patch 行 config 中提取 prompt 条目（systemPrompt.persona / planMode.sections[].text） */
+/**
+ * 从 patch 行 config 中提取 prompt 条目（systemPrompt.persona / planMode.sections[].text）。
+ *
+ * 行对象可带 `file`（层身份）：带上时逐条目记录 `sourceFile`，导入写回落回原层。
+ */
 export function extractPrompts(lines) {
     const prompts = [];
     for (const line of lines) {
@@ -25,12 +32,12 @@ export function extractPrompts(lines) {
             const sourceLineName = typeof entry.name === 'string' ? entry.name : undefined;
             const sp = c['systemPrompt'];
             if (typeof sp === 'string' && sp.trim() !== '') {
-                prompts.push({ id: `prompt:${line.lineId}:persona`, name: `${line.lineId}:persona`, kind: 'systemPrompt', text: sp, sourceLineId: line.lineId, sourceLineName });
+                prompts.push({ id: `prompt:${line.lineId}:persona`, name: `${line.lineId}:persona`, kind: 'systemPrompt', text: sp, sourceLineId: line.lineId, sourceLineName, ...(line.file !== undefined ? { sourceFile: line.file } : {}) });
             }
             else if (sp !== null && typeof sp === 'object' && typeof sp['persona'] === 'string') {
                 const persona = sp['persona'];
                 if (persona.trim() !== '') {
-                    prompts.push({ id: `prompt:${line.lineId}:persona`, name: `${line.lineId}:persona`, kind: 'systemPrompt', text: persona, sourceLineId: line.lineId, sourceLineName });
+                    prompts.push({ id: `prompt:${line.lineId}:persona`, name: `${line.lineId}:persona`, kind: 'systemPrompt', text: persona, sourceLineId: line.lineId, sourceLineName, ...(line.file !== undefined ? { sourceFile: line.file } : {}) });
                 }
             }
             const pm = c['planMode'];
@@ -40,7 +47,7 @@ export function extractPrompts(lines) {
                     if (s === null || typeof s !== 'object' || typeof s['text'] !== 'string' || s['text'].trim() === '')
                         continue;
                     const name = typeof s['name'] === 'string' && s['name'] !== '' ? s['name'] : `${line.lineId}:section${i}`;
-                    prompts.push({ id: `prompt:${line.lineId}:${name}`, name, kind: 'planMode', text: s['text'], sourceLineId: line.lineId, sourceLineName });
+                    prompts.push({ id: `prompt:${line.lineId}:${name}`, name, kind: 'planMode', text: s['text'], sourceLineId: line.lineId, sourceLineName, ...(line.file !== undefined ? { sourceFile: line.file } : {}) });
                 }
             }
         }
@@ -108,14 +115,12 @@ export class PromptsAdapter {
     portability = sectionMeta('prompts').portability;
     async export(ctx, _options) {
         const warnings = [];
-        let lines = [];
-        try {
-            lines = await ctx.patchFile.readPatchLines(USER_PATCH_FILE);
-        }
-        catch (err) {
-            warnings.push(msgOf(ctx)('adapter.patchReadFailedPrompts', { reason: err instanceof Error ? err.message : String(err) }));
+        // issue #71：两层都读（home 层优先），否则 profile 层里的 persona / planMode 全部丢失
+        const read = await readEffectivePatchLines(ctx.patchFile, ctx.profile);
+        for (const f of read.failures) {
+            warnings.push(msgOf(ctx)('adapter.patchReadFailedPrompts', { reason: `${f.file}: ${f.reason}` }));
         }
-        const prompts = extractPrompts(lines);
+        const prompts = extractPrompts(read.lines);
         return {
             sectionId: 'prompts',
             data: { version: 1, prompts },
@@ -126,7 +131,8 @@ export class PromptsAdapter {
     async analyzeImport(data, ctx) {
         const msg = ctx.msg;
         const items = [];
-        const targetLines = await ctx.target.patchFile.readPatchLines(USER_PATCH_FILE);
+        // issue #71：目标行跨两层；同一 lineId 只保留优先级最高的一层（与 DSH 合并序一致）
+        const targetLines = (await readEffectivePatchLines(ctx.target.patchFile, ctx.target.profile)).lines;
         const targetPrompts = extractPrompts(targetLines);
         for (const p of data.prompts) {
             const id = p.id;
@@ -142,7 +148,8 @@ export class PromptsAdapter {
                         description: msg('adapter.promptDiff', { name: p.name }),
                         detail: `行 ${p.sourceLineId} current=${JSON.stringify(sameName.text).slice(0, 80)} imported=${JSON.stringify(p.text).slice(0, 80)}`,
                         severity: 'warning',
-                        target: { adapter: 'prompts', ref: p.sourceLineId ?? '' },
+                        // 层身份随计划项走：快照按这一层记原行、回滚才能写回原文件（issue #71）
+                        target: { adapter: 'prompts', ref: p.sourceLineId ?? '', file: targetLine.file },
                     });
                 }
             }
@@ -156,7 +163,10 @@ export class PromptsAdapter {
                         id, kind: 'Conflict', adapter: 'prompts',
                         description: msg('adapter.promptDiffWithLine', { name: p.name, line: sameName.sourceLineId ?? '' }),
                         severity: 'warning',
-                        target: { adapter: 'prompts', ref: sameName.sourceLineId ?? '' },
+                        target: {
+                            adapter: 'prompts', ref: sameName.sourceLineId ?? '',
+                            file: targetLines.find((l) => l.lineId === sameName.sourceLineId)?.file,
+                        },
                     });
                 }
             }
@@ -166,7 +176,7 @@ export class PromptsAdapter {
                 items.push({
                     id, kind: 'Create', adapter: 'prompts',
                     description: msg('adapter.promptCreate', { name: p.name, line: lineId }), severity: 'info',
-                    target: { adapter: 'prompts', ref: lineId },
+                    target: { adapter: 'prompts', ref: lineId, file: resolveWriteLayer(p.sourceFile, ctx.target.profile) },
                 });
             }
             else {
@@ -193,18 +203,23 @@ export class PromptsAdapter {
         // Create：目标无来源行 → 用记录的行名重建 patch 行（insert）
         if (item.kind === 'Create') {
             const raw = buildPromptLine(ref, prompt);
-            await ctx.target.patchFile.applyPatchChanges(USER_PATCH_FILE, [
+            // issue #71：备份里记了来源层就落「同语义层」（来源 profile 层 → 目标机当前 profile 层，
+            // 跨机器照抄 profile 名会被宿主门面拒绝）；旧备份包无该字段 → 落 home 层（与改造前一致）
+            await ctx.target.patchFile.applyPatchChanges(resolveWriteLayer(prompt.sourceFile, ctx.target.profile), [
                 { lineId: ref, raw, action: 'insert' },
             ]);
             return { ok: true, needsRestart: true, message: msg('adapter.promptCreated', { name: prompt.name, ref }) };
         }
         // Update / Conflict(useImported)：合并进目标行 config
-        const lines = await ctx.target.patchFile.readPatchLines(USER_PATCH_FILE);
+        // issue #71：先定位原行所在层（两层都没有 → home 层），再读该层的原行合并 —— 绝不把
+        // profile 层的行搬到 home 层（同一 lineId 两层各一份会让 DSH 的合并语义变得不可预期）
+        const file = await locatePatchLineLayer(ctx.target.patchFile, ctx.target.profile, ref);
+        const lines = await ctx.target.patchFile.readPatchLines(file);
         const line = lines.find((l) => l.lineId === ref);
         if (!line)
             return { ok: false, message: msg('adapter.patchLineMissing', { ref }) };
         const newRaw = mergePromptIntoLine(line.raw, prompt);
-        await ctx.target.patchFile.applyPatchChanges(USER_PATCH_FILE, [
+        await ctx.target.patchFile.applyPatchChanges(file, [
             { lineId: ref, raw: newRaw, action: 'update' },
         ]);
         return { ok: true, needsRestart: true, message: msg('adapter.promptWritten', { name: prompt.name, ref }) };