@logictan/dsh-config-manager 0.1.60 → 0.1.62

package/src/adapters/patch-layers.test.ts

@@ -0,0 +1,201 @@
+/**
+ * cordis patch 的**层寻址**契约测试（S1–S5）：
+ *  - 导出同时覆盖 home 层与 profile 层，`file` 字段如实标注来源层；
+ *  - diff 阶段按行自带的层读目标端（profile 层已有同值 → Skip，不是 Create）；
+ *  - 计划项 id / target.ref 是层限定复合键，跨层同名 lineId 各自落各自层；
+ *  - 快照与回滚按层落位（回滚 profile 层的行不得污染 home 层）。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { PluginsAdapter } from './plugins.ts';
+import { makeContext, makeImportContext, MemSnapshotStore } from './test-helpers.ts';
+import { createSnapshot } from '../core/backup.ts';
+import { rollback } from '../core/rollback.ts';
+import { HOME_PATCH_FILE, PROFILE_PATCH_FILE, patchLayerKey } from '../core/patch-layers.ts';
+import { SECTION_IDS } from '../schema/config.ts';
+import type { ImportPlan, PlanItem } from '../core/types.ts';
+
+/** 只含一项的导入计划（estimatedActions 需覆盖全部分区，故按 SECTION_IDS 补零）。 */
+function importPlan(item: PlanItem): ImportPlan {
+  return {
+    items: [item],
+    globalStrategy: 'merge',
+    pathMappings: [],
+    missingSecrets: [],
+    needsRestart: false,
+    estimatedActions: Object.fromEntries(SECTION_IDS.map((id) => [id, 0])) as ImportPlan['estimatedActions'],
+  };
+}
+
+test('plugins.export: 两层 patch 行都进 section，file 字段区分来源层', async () => {
+  const ctx = makeContext('linux', '/home/alice', 'web');
+  const layered = ctx.useLayeredPatch();
+  layered.set(HOME_PATCH_FILE, 'home-a', { id: 'home-a', disabled: true });
+  layered.set(HOME_PATCH_FILE, 'home-b', { id: 'home-b', disabled: true });
+  layered.set(PROFILE_PATCH_FILE, 'profile-a', { id: 'profile-a', name: 'pkg-a' });
+  layered.set(PROFILE_PATCH_FILE, 'profile-b', { id: 'profile-b', name: 'pkg-b' });
+
+  const out = await new PluginsAdapter().export(ctx, { includeSecrets: false });
+  assert.equal(out.data.patch.length, 4, `两层并集必须齐全: ${JSON.stringify(out.data.patch)}`);
+  assert.deepEqual(
+    [...new Set(out.data.patch.map((p) => p.file))].sort(),
+    [HOME_PATCH_FILE, PROFILE_PATCH_FILE].sort(),
+    'file 必须区分来源层',
+  );
+  assert.deepEqual(
+    out.data.patch.filter((p) => p.file === PROFILE_PATCH_FILE).map((p) => p.lineId),
+    ['profile-a', 'profile-b'],
+  );
+});
+
+test('plugins.export: profile 层文件缺失时降级为仅 home 层（不产生 error 级告警）', async () => {
+  const ctx = makeContext('linux', '/home/alice', 'web');
+  const layered = ctx.useLayeredPatch();
+  layered.set(HOME_PATCH_FILE, 'home-a', { id: 'home-a', disabled: true });
+
+  const out = await new PluginsAdapter().export(ctx, { includeSecrets: false });
+  assert.equal(out.data.patch.length, 1);
+  assert.deepEqual([...new Set(out.data.patch.map((p) => p.file))], [HOME_PATCH_FILE]);
+  assert.equal(out.warnings.length, 0, `缺 profile 层不是故障: ${out.warnings.join(' | ')}`);
+});
+
+test('plugins.analyzeImport: 目标端 profile 层已有同行 → Skip（不是 Create）', async () => {
+  const src = makeContext('linux', '/home/alice', 'web');
+  const srcLayered = src.useLayeredPatch();
+  const raw = { id: 'webserver', config: { port: 3080 } };
+  srcLayered.set(PROFILE_PATCH_FILE, 'webserver', raw);
+
+  const adapter = new PluginsAdapter();
+  const exported = await adapter.export(src, { includeSecrets: false });
+  const sections = new Map([['plugins', exported.data]]);
+
+  // 目标机 profile 层已有同值行 → Skip（旧实现只读 home 层，会误判成 Create）
+  const dst = makeContext('linux', '/home/bob', 'web');
+  dst.useLayeredPatch().set(PROFILE_PATCH_FILE, 'webserver', raw);
+  const items = await adapter.analyzeImport(exported.data, makeImportContext(dst, sections));
+  const item = items.find((i) => i.id === `patch:${patchLayerKey(PROFILE_PATCH_FILE, 'webserver')}`);
+  assert.equal(item?.kind, 'Skip', JSON.stringify(items));
+
+  // 目标机 profile 层同 id 但不同值 → Conflict（旧实现只读 home 层，会误判成 Create）
+  const dst2 = makeContext('linux', '/home/bob2', 'web');
+  dst2.useLayeredPatch().set(PROFILE_PATCH_FILE, 'webserver', { id: 'webserver', config: { port: 9999 } });
+  const items2 = await adapter.analyzeImport(exported.data, makeImportContext(dst2, sections));
+  const item2 = items2.find((i) => i.id === `patch:${patchLayerKey(PROFILE_PATCH_FILE, 'webserver')}`);
+  assert.equal(item2?.kind, 'Conflict', JSON.stringify(items2));
+});
+
+test('plugins: 跨层同名 lineId → 两个独立计划项，各自落各自层', async () => {
+  const src = makeContext('linux', '/home/alice', 'web');
+  const srcLayered = src.useLayeredPatch();
+  srcLayered.set(HOME_PATCH_FILE, 'dup', { id: 'dup', config: { from: 'home' } });
+  srcLayered.set(PROFILE_PATCH_FILE, 'dup', { id: 'dup', config: { from: 'profile' } });
+
+  const adapter = new PluginsAdapter();
+  const exported = await adapter.export(src, { includeSecrets: false });
+  const sections = new Map([['plugins', exported.data]]);
+  assert.equal(exported.data.patch.length, 2);
+
+  const dst = makeContext('linux', '/home/bob', 'web');
+  dst.useLayeredPatch();
+  const items = await adapter.analyzeImport(exported.data, makeImportContext(dst, sections));
+  const patchItems = items.filter((i) => i.id.startsWith('patch:'));
+  assert.equal(patchItems.length, 2, `同名 lineId 必须是两个独立项: ${JSON.stringify(items)}`);
+
+  for (const item of patchItems) {
+    const r = await adapter.applyItem(item, makeImportContext(dst, sections));
+    assert.equal(r.ok, true, JSON.stringify(r));
+  }
+  const layered = dst.patchFile as unknown as { has: (f: string, id: string) => boolean };
+  assert.equal(layered.has(HOME_PATCH_FILE, 'dup'), true, 'home 层的行必须落在 home 层');
+  assert.equal(layered.has(PROFILE_PATCH_FILE, 'dup'), true, 'profile 层的行必须落在 profile 层');
+  assert.deepEqual(
+    (dst.patchFile as unknown as { rawOf: (f: string, id: string) => unknown }).rawOf(HOME_PATCH_FILE, 'dup'),
+    { id: 'dup', config: { from: 'home' } },
+  );
+  assert.deepEqual(
+    (dst.patchFile as unknown as { rawOf: (f: string, id: string) => unknown }).rawOf(PROFILE_PATCH_FILE, 'dup'),
+    { id: 'dup', config: { from: 'profile' } },
+  );
+});
+
+test('rollback: profile 层 patchLine 回滚写回 profile 层（home 层文件不受影响）', async () => {
+  const ctx = makeContext('linux', '/home/bob', 'web');
+  const layered = ctx.useLayeredPatch();
+  const original = { id: 'webserver', config: { port: 3080 } };
+  layered.set(PROFILE_PATCH_FILE, 'webserver', original);
+  layered.set(HOME_PATCH_FILE, 'webserver', { id: 'webserver', config: { port: 1111 } });
+
+  const item: PlanItem = {
+    id: `patch:${patchLayerKey(PROFILE_PATCH_FILE, 'webserver')}`,
+    kind: 'Update',
+    adapter: 'plugins',
+    description: 'write profile patch row',
+    severity: 'info',
+    target: { adapter: 'plugins', ref: patchLayerKey(PROFILE_PATCH_FILE, 'webserver') },
+  };
+  const plan = importPlan(item);
+  const store = new MemSnapshotStore();
+  const snapshot = await createSnapshot({ ctx, plan, sourceZip: '/tmp/x.zip', store, adapters: [] });
+  const entry = snapshot.entries.find((e) => e.kind === 'patchLine');
+  assert.ok(entry !== undefined, `快照必须登记 patchLine 条目: ${JSON.stringify(snapshot.entries)}`);
+  assert.deepEqual(entry.before, original, '快照必须记 profile 层原值（旧实现固定读 home 层，会记成 home 层的值）');
+
+  // 模拟导入改写 profile 层
+  await ctx.patchFile.applyPatchChanges(PROFILE_PATCH_FILE, [
+    { lineId: 'webserver', raw: { id: 'webserver', config: { port: 9999 } }, action: 'update' },
+  ]);
+  const report = await rollback({ ctx, snapshot, store, adapters: [] });
+  assert.equal(report.full, true, JSON.stringify(report));
+  assert.deepEqual(layered.rawOf(PROFILE_PATCH_FILE, 'webserver'), original, '回滚必须写回 profile 层原值');
+  assert.deepEqual(
+    layered.rawOf(HOME_PATCH_FILE, 'webserver'),
+    { id: 'webserver', config: { port: 1111 } },
+    'home 层的行不得被 profile 层回滚污染',
+  );
+});
+
+test('rollback: 旧快照的裸 lineId ref 兼容为 home 层', async () => {
+  const ctx = makeContext('linux', '/home/bob', 'web');
+  const layered = ctx.useLayeredPatch();
+  layered.set(HOME_PATCH_FILE, 'legacy', { id: 'legacy', disabled: false });
+
+  const item: PlanItem = {
+    id: 'patch:legacy',
+    kind: 'Update',
+    adapter: 'plugins',
+    description: 'legacy ref',
+    severity: 'info',
+    target: { adapter: 'plugins', ref: 'legacy' },
+  };
+  const plan = importPlan(item);
+  const store = new MemSnapshotStore();
+  const snapshot = await createSnapshot({ ctx, plan, sourceZip: '/tmp/x.zip', store, adapters: [] });
+  assert.deepEqual(snapshot.entries.find((e) => e.kind === 'patchLine')?.before, { id: 'legacy', disabled: false });
+
+  await ctx.patchFile.applyPatchChanges(HOME_PATCH_FILE, [
+    { lineId: 'legacy', raw: { id: 'legacy', disabled: true }, action: 'update' },
+  ]);
+  const report = await rollback({ ctx, snapshot, store, adapters: [] });
+  assert.equal(report.full, true, JSON.stringify(report));
+  assert.deepEqual(layered.rawOf(HOME_PATCH_FILE, 'legacy'), { id: 'legacy', disabled: false });
+});
+
+test('plugins.export: 存量快照的 file=home token 仍解析到 home 层', async () => {
+  const src = makeContext('linux', '/home/alice', 'web');
+  const layered = src.useLayeredPatch();
+  layered.set(HOME_PATCH_FILE, 'legacy-home', { id: 'legacy-home', disabled: true });
+
+  const adapter = new PluginsAdapter();
+  const exported = await adapter.export(src, { includeSecrets: false });
+  assert.equal(exported.data.patch[0]?.file, HOME_PATCH_FILE, 'home 层 token 与历史快照取值一致');
+
+  const sections = new Map([['plugins', exported.data]]);
+  const dst = makeContext('linux', '/home/bob', 'web');
+  dst.useLayeredPatch();
+  const items = await adapter.analyzeImport(exported.data, makeImportContext(dst, sections));
+  const item = items.find((i) => i.id.startsWith('patch:'));
+  assert.equal(item?.target?.ref, patchLayerKey(HOME_PATCH_FILE, 'legacy-home'));
+  await adapter.applyItem(item!, makeImportContext(dst, sections));
+  assert.equal((dst.patchFile as unknown as { has: (f: string, id: string) => boolean }).has(HOME_PATCH_FILE, 'legacy-home'), true);
+});

package/src/adapters/plugins.test.ts

@@ -4,10 +4,16 @@
  */
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { PluginsAdapter, USER_PATCH_FILE } from './plugins.ts';
+import { PluginsAdapter } from './plugins.ts';
 import { makeContext, makeImportContext } from './test-helpers.ts';
+import { HOME_PATCH_FILE, PROFILE_PATCH_FILE, patchLayerKey } from '../core/patch-layers.ts';
 import type { PlanItem } from '../core/types.ts';
 
+/** 计划项 id：层限定复合键的投影（`patch:<file>#<lineId>`）。 */
+function patchItemId(file: string, lineId: string): string {
+  return `patch:${patchLayerKey(file, lineId)}`;
+}
+
 test('issue #35：patch 文件随分区迁移；目标缺失的 patchedDependencies 声明导入时剔除', async () => {
   const ws = [
     'allowBuilds:',
@@ -167,7 +173,9 @@ test('plugins: 导出清单与 patch 行', async () => {
   ctx.plugins.installed.set('@linxin666/dsh-ssh', { name: '@linxin666/dsh-ssh', version: '0.1.12', enabled: true, isBundle: true, inBundles: ['@linxin666/dsh-web-ui-all'] });
   ctx.plugins.installed.set('dsh-memory-evolve', { name: 'dsh-memory-evolve', version: '1.0.0', enabled: true, spec: 'github:csyangwen/dsh-memory-evolve' });
   ctx.plugins.installed.set('@deepseek-ai/dsh-base', { name: '@deepseek-ai/dsh-base', version: '0.1.0-rc.6', enabled: true });
-  ctx.patchFile.lines.set('skill-badge', { lineId: 'skill-badge', raw: { id: 'skill-badge', disabled: true } });
+  // 层寻址契约：导出同时读 home 与 profile 两层，单层的 MemPatch 对任何 file 都返回同一批行，
+  // 会让同一行被当成两层的两行。此处改用按层键控的门面，夹具才与真实门面同语义。
+  ctx.useLayeredPatch().set(HOME_PATCH_FILE, 'skill-badge', { id: 'skill-badge', disabled: true });
 
   const adapter = new PluginsAdapter();
   const out = await adapter.export(ctx, { includeSecrets: false });
@@ -235,11 +243,11 @@ test('plugins: 已装同版本 Skip / 未装 Install / 版本不同 Conflict / p
   const byId = new Map(items.map((i) => [i.id, i]));
   assert.equal(byId.get('plugin:pkg-a')?.kind, 'Skip');
   assert.equal(byId.get('plugin:pkg-b')?.kind, 'Conflict');
-  assert.equal(byId.get('patch:my-line')?.kind, 'Create');
-  assert.equal(byId.get('patch:my-line')?.target?.ref, 'my-line');
+  assert.equal(byId.get(patchItemId(HOME_PATCH_FILE, 'my-line'))?.kind, 'Create');
+  assert.equal(byId.get(patchItemId(HOME_PATCH_FILE, 'my-line'))?.target?.ref, patchLayerKey(HOME_PATCH_FILE, 'my-line'));
 
   // patch 行写入（Create）
-  const r = await adapter.applyItem(byId.get('patch:my-line')!, makeImportContext(dst, sections));
+  const r = await adapter.applyItem(byId.get(patchItemId(HOME_PATCH_FILE, 'my-line'))!, makeImportContext(dst, sections));
   assert.equal(r.ok, true);
   assert.equal(r.needsRestart, true);
   assert.deepEqual(dst.patchFile.lines.get('my-line')?.raw, { id: 'my-line', name: 'pkg-c', config: { x: 1 } });

package/src/adapters/plugins.ts

@@ -1,9 +1,9 @@
 /**
  * plugins 分区 adapter（设计 §3.3/§8）：
- * 数据源 = ctx.plugins.listInstalled()（插件清单）+ 用户 patch 层（profile cordis.patch.yml）。
+ * 数据源 = ctx.plugins.listInstalled()（插件清单）+ 两个 patch 层（home 与 profile 的 cordis.patch.yml）。
  *
  * 安全不变量：绝不打包插件二进制；导入走 DSH 官方机制（dsh plugin CLI → needsRestart 提示）。
- * patch 行导入（用户自定义行：启用/禁用/插入）写回 cordis.patch.yml，同样 needsRestart。
+ * patch 行导入（用户自定义行：启用/禁用/插入）写回该行自带的层（home 或 profile），同样 needsRestart。
  *
  * T1（本地源插件迁移）：`link:` / `file:` 来源的插件指向本机路径，换机后必然不可达
  * （曾导致插件被静默丢失）。导出时经注入的 `localPack` 执行 `npm pack`，把 tarball 作为
@@ -19,6 +19,7 @@ import { msgOf, zhMsg } from '../core/messages.ts';
 import type { MsgFunc } from '../core/messages.ts';
 import { isPathSafe, normalizePath } from '../utils/paths.ts';
 import { PLUGIN_PATCH_REF_PREFIX } from '../core/backup.ts';
+import { HOME_PATCH_FILE, PROFILE_PATCH_FILE, patchLayerKey, parsePatchLayerKey } from '../core/patch-layers.ts';
 import { parsePnpmPatchedDependencies, sanitizePnpmWorkspacePatches } from './pnpm-workspace.ts';
 import type { LocalPluginTarball, PatchLine, PluginEntry, PluginsSection, PnpmPatchFile } from '../schema/types.ts';
 import type {
@@ -26,7 +27,6 @@ import type {
   ImportContext, PlanItem, ValidationResult,
 } from '../core/types.ts';
 
-export const USER_PATCH_FILE = 'cordis.patch.yml';
 
 /**
  * 本地源插件打包钩子（由宿主注入，见 src/index.ts createAdapters）。
@@ -170,12 +170,16 @@ export class PluginsAdapter implements ConfigAdapter<PluginsSection> {
     } catch (err) {
       warnings.push(msgOf(ctx)('adapter.pluginListReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
     }
+    // 两层都读：home 层（全机偏好）与 profile 层（该 profile 专属）。缺 profile 层文件不是故障
+    // （readPatchLines 对不存在的文件返回空数组），只有真读失败才告警。
     const patch: PatchLine[] = [];
-    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) }));
+    for (const file of [HOME_PATCH_FILE, PROFILE_PATCH_FILE]) {
+      try {
+        const lines = await ctx.patchFile.readPatchLines(file);
+        for (const l of lines) patch.push({ file, lineId: l.lineId, raw: l.raw });
+      } catch (err) {
+        warnings.push(msgOf(ctx)('adapter.patchReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
+      }
     }
     // pnpm-workspace.yaml（allowBuilds / minimumReleaseAgeExclude 等）：随插件分区迁移，
     // 否则目标 profile 的 pnpm 可能因构建白名单/冷静期拒绝安装插件（§34.17 同款语义）。
@@ -414,16 +418,25 @@ export class PluginsAdapter implements ConfigAdapter<PluginsSection> {
 
     // 用户 patch 行：lineId 唯一键；存在且同 → Skip；存在不同 → Conflict；不存在 → Create。
     // mcp-client 行与 systemPrompt/planMode 行由 mcp/prompts adapter 管理，此处跳过（避免重复写入覆盖）。
-    const targetLines = await ctx.target.patchFile.readPatchLines(USER_PATCH_FILE);
+    // 逐层读目标端：行自带的 file 决定比对哪一层（只读 home 层会让 profile 层行在目标机
+    // 已有同值时被误判成 Create，也会让目标机 profile 层的不同值判不出 Conflict）。
+    const targetLines = new Map<string, { lineId: string; raw: unknown }[]>();
+    for (const pl of data.patch) {
+      if (!targetLines.has(pl.file)) {
+        targetLines.set(pl.file, await ctx.target.patchFile.readPatchLines(pl.file));
+      }
+    }
     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);
+      // 层限定复合键：两层可存在同名 lineId，裸 lineId 无法指向「哪一层的哪一行」。
+      const ref = patchLayerKey(pl.file, pl.lineId);
+      const id = `patch:${ref}`;
+      const tl = targetLines.get(pl.file)?.find((l) => l.lineId === pl.lineId);
       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 },
         });
       } else if (isDeepStrictEqual(tl.raw, pl.raw)) {
         items.push({ id, kind: 'Skip', adapter: 'plugins', description: msg('adapter.patchLineSame', { lineId: pl.lineId }), severity: 'info' });
@@ -431,7 +444,7 @@ export class PluginsAdapter implements ConfigAdapter<PluginsSection> {
         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 },
         });
       }
     }
@@ -561,13 +574,16 @@ export class PluginsAdapter implements ConfigAdapter<PluginsSection> {
     // patch 行：Create → insert，Update/Conflict(useImported) → update
     const ref = item.target?.ref;
     if (!ref) return { ok: false, message: msg('adapter.missingTargetRef') };
+    // 复合键解析出层与 lineId：只按 lineId 查找会命中数组里先出现的 home 层行，
+    // 把 profile 层的行写进 home 层（回滚同理）。
+    const { file, lineId } = parsePatchLayerKey(ref);
     const data = ctx.sections.get('plugins') as PluginsSection | undefined;
-    const pl = data?.patch.find((p) => p.lineId === ref);
+    const pl = data?.patch.find((p) => p.file === file && p.lineId === lineId);
     if (!pl) return { ok: false, message: msg('adapter.patchMissing', { ref }) };
-    await ctx.target.patchFile.applyPatchChanges(pl.file, [
-      { lineId: ref, raw: pl.raw, action: item.kind === 'Create' ? 'insert' : 'update' },
+    await ctx.target.patchFile.applyPatchChanges(file, [
+      { lineId, raw: pl.raw, action: item.kind === 'Create' ? 'insert' : 'update' },
     ]);
-    return { ok: true, needsRestart: true, message: msg('adapter.patchWritten', { ref }) };
+    return { ok: true, needsRestart: true, message: msg('adapter.patchWritten', { ref: lineId }) };
   }
 
   async validate(data: PluginsSection, msg: MsgFunc = zhMsg): Promise<ValidationResult> {

package/src/adapters/prompts.ts

@@ -17,7 +17,7 @@ import type {
   ApplyResult, ConfigAdapter, ExportOptions, ExportSection, HostContext,
   ImportContext, PlanItem, ValidationResult,
 } from '../core/types.ts';
-import { USER_PATCH_FILE } from './plugins.ts';
+import { HOME_PATCH_FILE } from '../core/patch-layers.ts';
 
 /** 导出记录：PromptEntry 之外记录来源行名（导入需要重建行时使用） */
 export interface PromptExportEntry extends PromptEntry {
@@ -116,7 +116,7 @@ export class PromptsAdapter implements ConfigAdapter<PromptsExportSection> {
     const warnings: string[] = [];
     let lines: { lineId: string; raw: unknown }[] = [];
     try {
-      lines = await ctx.patchFile.readPatchLines(USER_PATCH_FILE);
+      lines = await ctx.patchFile.readPatchLines(HOME_PATCH_FILE);
     } catch (err) {
       warnings.push(msgOf(ctx)('adapter.patchReadFailedPrompts', { reason: err instanceof Error ? err.message : String(err) }));
     }
@@ -132,7 +132,7 @@ export class PromptsAdapter implements ConfigAdapter<PromptsExportSection> {
   async analyzeImport(data: PromptsExportSection, ctx: ImportContext): Promise<PlanItem[]> {
     const msg = ctx.msg;
     const items: PlanItem[] = [];
-    const targetLines = await ctx.target.patchFile.readPatchLines(USER_PATCH_FILE);
+    const targetLines = await ctx.target.patchFile.readPatchLines(HOME_PATCH_FILE);
     const targetPrompts = extractPrompts(targetLines);
     for (const p of data.prompts) {
       const id = p.id;
@@ -192,17 +192,17 @@ export class PromptsAdapter implements ConfigAdapter<PromptsExportSection> {
     // Create：目标无来源行 → 用记录的行名重建 patch 行（insert）
     if (item.kind === 'Create') {
       const raw = buildPromptLine(ref, prompt);
-      await ctx.target.patchFile.applyPatchChanges(USER_PATCH_FILE, [
+      await ctx.target.patchFile.applyPatchChanges(HOME_PATCH_FILE, [
         { 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);
+    const lines = await ctx.target.patchFile.readPatchLines(HOME_PATCH_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(HOME_PATCH_FILE, [
       { lineId: ref, raw: newRaw, action: 'update' },
     ]);
     return { ok: true, needsRestart: true, message: msg('adapter.promptWritten', { name: prompt.name, ref }) };

package/src/adapters/test-helpers.ts

@@ -158,6 +158,46 @@ export class MemPatch implements PatchFileFacade {
   }
 }
 
+/**
+ * 分层 patch 门面 mock：patch 行按 `file`（层 token）分桶。
+ * 单层的 `MemPatch` 无法表达「同名 lineId 分布在两层」——而那正是层寻址契约的核心，
+ * 故另立一个按层键控的实现，供 plugins 适配器与快照/回滚的契约测试使用。
+ */
+export class MemLayeredPatch implements PatchFileFacade {
+  files = new Map<string, Map<string, { lineId: string; raw: unknown }>>();
+
+  /** 直接落一行（测试夹具；等价于目标机该层已存在该行）。 */
+  set(file: string, lineId: string, raw: unknown): void {
+    const layer = this.files.get(file) ?? new Map();
+    layer.set(lineId, { lineId, raw });
+    this.files.set(file, layer);
+  }
+
+  has(file: string, lineId: string): boolean {
+    return this.files.get(file)?.has(lineId) ?? false;
+  }
+
+  rawOf(file: string, lineId: string): unknown {
+    return this.files.get(file)?.get(lineId)?.raw;
+  }
+
+  async readPatchLines(file: string): Promise<{ lineId: string; raw: unknown }[]> {
+    return [...(this.files.get(file)?.values() ?? [])];
+  }
+
+  async applyPatchChanges(
+    file: string,
+    changes: { lineId: string; raw: unknown; action: 'insert' | 'update' | 'remove' }[],
+  ): Promise<void> {
+    const layer = this.files.get(file) ?? new Map<string, { lineId: string; raw: unknown }>();
+    this.files.set(file, layer);
+    for (const c of changes) {
+      if (c.action === 'remove') layer.delete(c.lineId);
+      else layer.set(c.lineId, { lineId: c.lineId, raw: c.raw });
+    }
+  }
+}
+
 export class MemSnapshotStore implements SnapshotStore {
   snapshots = new Map<string, Snapshot>();
   blobs = new Map<string, Uint8Array>();
@@ -203,6 +243,14 @@ export class MockHostContext implements HostContext {
     this.fs = new MemFs(homeDir);
     this.log = createLogger({ level: 'error', sink: () => {} });
   }
+
+  /** 换成按层键控的 patch 门面（层寻址契约测试用）。
+   *  字段的声明类型仍是单层的 MemPatch，以免既有夹具的 `.lines` 用法失型。 */
+  useLayeredPatch(): MemLayeredPatch {
+    const layered = new MemLayeredPatch();
+    this.patchFile = layered as unknown as MemPatch;
+    return layered;
+  }
 }
 
 export function makeContext(platform: string, homeDir: string, profile?: string): MockHostContext {

package/src/client/api.ts

@@ -4,19 +4,10 @@
  */
 import { zhUiT, type UiT } from '../ui/i18n.ts'
 
-/** Host 半健康检查响应（plugin 版本 / DSH 版本 / 平台，用于主页横幅与兼容性说明） */
+/** Host 半状态响应：设置页页脚版本行的两个字段（消费方只有 ConfigManagerSection） */
 export interface ServiceStatus {
-  ready: boolean
   pluginVersion: string
   dshVersion: string
-  platform: string
-  arch: string
-  homeDir?: string
-  profile?: string
-  profileManifestReadable?: boolean
-  installedPluginCount?: number
-  installedPluginNames?: string[]
-  bundles?: string[]
 }
 
 export const CONFIG_MANAGER_API = {

package/src/client/config-manager.module.css

@@ -2284,7 +2284,7 @@ button.statCard:focus-visible {
   padding: 1px 0;
 }
 
-/* 选项行（加密/导出密钥复选内联） */
+/* 选项行（导出密钥复选内联） */
 .optionsRow {
   display: flex;
   align-items: center;

package/src/client/run-store.test.ts

@@ -2,7 +2,7 @@
  * run-store 单测：模块级单例 store + sessionStorage 恢复（同步面板专属）。
  *
  * 覆盖：
- *  - 敏感字段（token/webdavPassword/encryptPassword 等）绝不写入 sessionStorage（白名单剔除）；
+ *  - 敏感字段（token/webdavPassword 等）绝不写入 sessionStorage（白名单剔除）；
  *  - 内存瞬态（busy/savingConfig）不写入 sessionStorage，刷新后复位；
  *  - 非敏感状态序列化/反序列化往返（新实例 + 同存储 = 模拟刷新）；
  *  - 损坏/版本不符数据回退默认并清除脏键；

package/src/client/sync/SyncSettingsView.tsx

@@ -8,7 +8,7 @@
  *   dialogMask + dialogCard dialogWide + dialogHeaderRow + dialogClose +
  *   dialogBodyScroll，零新增样式）；
  * - **通道配置弹窗**：通道子 tab（GitHub（git）/ WebDAV）切换，两个通道的
- *   配置表单、自动同步、同步模式、是否加密、远端快照**各自独立**；关闭弹窗
+ *   配置表单、自动同步、同步模式、远端快照**各自独立**；关闭弹窗
  *   = 放弃本次操作（GitHub 登录流程进行中则一并取消，§8.12 约定）；
  * - GitHub 子 tab：repoUrl（必填）+ 认证 token（可选，写入 DSH credentials 的提示）
  *   + **GitHub OAuth device flow 登录**（登录块跟随 git 通道配置放在弹窗内：
@@ -24,7 +24,7 @@
  * 全部渲染模型来自 ./sync-view.ts 纯函数（node 单测覆盖），组件只做装配；
  * 状态组件内自持（useState），同时经 toSyncStoreSlice() 镜像进模块级 runStore：
  * 模块级单例保证「切 tab 不丢」，sessionStorage 白名单保证「刷新恢复」；
- * token/webdav 密码/加密与解密密码仅内存（state），成功后清空（已写入 DSH
+ * token/webdav 密码仅内存（state），成功后清空（已写入 DSH
  * credentials），持久化白名单硬性剔除（含 byChannel 内密码类字段），刷新后
  * 清空、需要时重新输入。
  */
@@ -89,7 +89,7 @@ interface SyncUiState {
   webdavUsername: string
   /** 仅内存：成功后清空（已写入 DSH credentials），绝不持久化/回显 */
   webdavPassword: string
-  /** git/webdav 各自独立的设置状态（自动同步 / 同步模式 / 加密 / 快照） */
+  /** git/webdav 各自独立的设置状态（自动同步 / 同步模式 / 快照） */
   byChannel: {
     git: ChannelSyncState
     webdav: ChannelSyncState
@@ -174,7 +174,7 @@ const initial: SyncUiState = {
 
 /**
  * 从 runStore 恢复上次的同步 UI 状态（切 tab 回 / 刷新后挂载）。
- * 敏感字段（token/webdav 密码/加密与解密密码）只在内存切片里保留：切 tab 保留；
+ * 敏感字段（token/webdav 密码）只在内存切片里保留：切 tab 保留；
  * 刷新后已被持久化白名单清空（applyPersisted 强制归零）→ 需要时重新输入。
  * busy/savingConfig 为瞬态：切 tab 由模块级单例保留（切回仍显示进行中）；
  * 刷新后白名单剔除 → 回复空闲。
@@ -240,7 +240,7 @@ export function SyncSettingsView({ api, t }: SyncSettingsViewProps) {
   })
   /** 更新当前激活通道的 byChannel 状态。 */
   const patchChannel = (p: Partial<ChannelSyncState>): void => patchChannelState(state.channel, p)
-  /** 当前激活通道的设置状态（自动同步/模式/加密/快照）。 */
+  /** 当前激活通道的设置状态（自动同步/模式/快照）。 */
   const chState: ChannelSyncState = state.byChannel[state.channel]
   /** GitHub 流程态（不进 store 切片；commit 的镜像写幂等无害）。 */
   const patchGithub = (p: Partial<GithubUiState>): void => commit({

package/src/client/sync/sync-api.ts

@@ -30,7 +30,6 @@ import { zhUiT, type UiT } from '../../ui/i18n.ts';
 
 /** 同步端点常量（与 Host 半 src/index.ts API 常量保持一致） */
 export const SYNC_API = {
-  base: '/api/dsh-config-manager/sync',
   status: '/api/dsh-config-manager/sync/status',
   push: '/api/dsh-config-manager/sync/push',
   pull: '/api/dsh-config-manager/sync/pull',

package/src/client/sync/sync-locales.ts

@@ -331,7 +331,6 @@ export const en: Record<keyof typeof zh, string> = {
   'mode.defaultCount': 'Will sync {n} recommended section(s)',
   'mode.sectionRecommended': 'Recommended',
   'mode.persistHint': 'The mode and section selection are saved locally: both auto sync and manual push use this configuration (persists across restarts).',
-  // Encryption & secret export (manual push only; auto sync always pushes plain snapshots and skips encrypted ones)
   'autosync.title': 'Auto Sync',
   'autosync.description': 'When enabled, DSH keeps config in sync in the background: uploads locally-changed config automatically, pulls and overwrites only when it detects a new remote snapshot; the timer is just a fallback poll and no-ops when nothing changed. Local writes happen only when there are no conflicts or manual-decision items.',
   'autosync.enable': 'Enable auto sync',

package/src/core/analyzer.ts

@@ -526,8 +526,9 @@ export class Analyzer {
       throw new ImportNotConfirmedError(this.msg);
     }
 
-    // 10b. 加密不变量：加密备份必须已成功解密（decryptedCredentials 由宿主用备份密码
-    // 解开 security/secrets.enc 后注入）。未解密（undefined）一律拒绝执行——
+    // 10b. 旧版加密备份的兼容不变量：本插件已无加密层，但历史产物仍可能带
+    // manifest.security.encrypted=true。这类备份的凭据必须由宿主解密后注入
+    // （decryptedCredentials）；未注入（undefined）一律拒绝执行——
     // 不允许把加密凭据静默降级为「缺凭据照常导入」，否则加密备份与普通备份无区别。
     if (bundle.manifest.security.encrypted && opts.decryptedCredentials === undefined) {
       throw new Error(this.msg('import.encryptedPasswordRequired'));
@@ -725,8 +726,8 @@ export class Analyzer {
     // M1：导入成功 → 快照标记 done（元数据写失败只告警，不改变导入结论）
     await this.markSnapshotStatus(snapshot.id, 'done');
 
-    // F1 vault 回填：导出时敏感文件（.credentials.yaml 等）明文未进备份（includeSecrets=false
-    // 时镜像到 <dataDir>/vault），导入成功后从本机 vault 回填 $DSH_HOME；vault 缺失
+    // F1 vault 回填：includeSecrets=false 的导出会把敏感文件（.credentials.yaml 等）镜像到
+    // <dataDir>/vault 而不进备份，导入成功后从本机 vault 回填 $DSH_HOME；vault 缺失
     // （跨机恢复 / 从未镜像过）记入警告提示用户重填。尽力而为：失败仅警告，不影响导入结论。
     try {
       const vaultDataDir = path.join(this.ctx.homeDir, 'dsh-config-manager');

package/src/core/backup.ts

@@ -9,6 +9,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { parseJsonSafe } from '../utils/json.ts';
+import { parsePatchLayerKey } from './patch-layers.ts';
 import { sha256Hex } from '../utils/hashing.ts';
 import { normalizePath } from '../utils/paths.ts';
 import { atomicWriteFile } from '../utils/atomic-write.ts';
@@ -206,10 +207,11 @@ async function engineSnapshotEntry(ctx: HostContext, target: SnapshotTarget): Pr
           copiedTo: `blobs/${crypto.randomUUID()}`,
         };
       }
-      // patchLine：从组合 patch 文件读取原行（file 为必填的 file 字段约定为 'cordis.patch.yml'）
-      const file = 'cordis.patch.yml';
+      // patchLine：ref 是层限定复合键（<file>#<lineId>），据此到**对应层**读原行。
+      // 旧快照的裸 lineId 由 parsePatchLayerKey 兼容为 home 层。
+      const { file, lineId } = parsePatchLayerKey(target.ref);
       const lines = await ctx.patchFile.readPatchLines(file);
-      const line = lines.find((l) => l.lineId === target.ref);
+      const line = lines.find((l) => l.lineId === lineId);
       return { kind: 'patchLine', adapter: target.adapter, ref: target.ref, before: line?.raw ?? null, existed: line !== undefined };
     }
     case 'skills':

package/src/core/config-lifecycle.test.ts

@@ -474,7 +474,10 @@ test('自动快照端到端：真实变更 → 防抖到期 → 落盘一份 aut
   const metas = await h.lifecycle.list();
   assert.equal(metas[0]!.kind, 'auto');
   assert.equal(metas[0]!.trigger, 'watcher');
-  assert.equal(h.autoMetas.length, 1, '宿主回调必须被触发');
+  // 回调在 saveSnapshot 落盘**之后**才触发，所以「等文件出现」不等于「回调已跑」：
+  // 直接断言会在负载高时偶发失败。等回调本身，而不是等它的副作用。
+  const fired = await waitFor(async () => h.autoMetas.length === 1);
+  assert.equal(fired, true, '宿主回调必须被触发');
 });
 
 test('自动快照端到端：恢复自写文件是回声 → 不产生快照（否则会挡住重做）', async (t) => {