@logictan/dsh-config-manager 0.1.60 → 0.1.62

package/lib/core/analyzer.js

@@ -408,8 +408,9 @@ export class Analyzer {
         if (opts.confirm !== true) {
             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'));
@@ -607,8 +608,8 @@ export class Analyzer {
             .map((s) => s.ref);
         // 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/lib/core/backup.js

@@ -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.js';
+import { parsePatchLayerKey } from './patch-layers.js';
 import { sha256Hex } from '../utils/hashing.js';
 import { normalizePath } from '../utils/paths.js';
 import { atomicWriteFile } from '../utils/atomic-write.js';
@@ -180,10 +181,11 @@ async function engineSnapshotEntry(ctx, target) {
                     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/lib/core/exporter.d.ts

@@ -1,6 +1,6 @@
 import type { MsgFunc } from './messages.ts';
 import type { Manifest } from '../schema/types.ts';
-import type { ConfigAdapter, EncryptionProvider, ExportOptions, ExportReport, HostContext, SecretScanner } from './types.ts';
+import type { ConfigAdapter, ExportOptions, ExportReport, HostContext, SecretScanner } from './types.ts';
 /** m1：每导出一个分区前的进度回调信息（Host 侧 run 状态更新用；section = adapter id） */
 export interface SectionProgress {
     section: string;
@@ -14,8 +14,6 @@ export interface ExporterOptions {
     adapters: ConfigAdapter[];
     /** Secret 扫描器；缺省用字段名黑名单剥离（m4 可注入强化版） */
     scanner?: SecretScanner;
-    /** 加密提供者（m4 用 node:crypto 实现）；includeSecrets 时必填；提供时备份标记 encrypted=true */
-    encryption?: EncryptionProvider | null;
     /** 插件自身版本（manifest.exporter.version） */
     exporterVersion?: string;
     now?: () => Date;
@@ -45,7 +43,6 @@ export declare class Exporter {
     private readonly ctx;
     private readonly adapters;
     private readonly scanner;
-    private readonly encryption;
     private readonly exporterVersion;
     private readonly now;
     private readonly msg;

package/lib/core/exporter.js

@@ -3,11 +3,9 @@
  *   adapter 收集各分区 → Secret 过滤 → manifest → checksum → ZIP。
  *
  * 安全不变量：
- *  - Secret 值默认永不进入导出数据（结构化分区逐一过 SecretScanner）；
- *  - includeSecrets=true 必须注入 EncryptionProvider（m4 实现），否则拒绝导出；
- *  - 注入 EncryptionProvider 时备份标记为加密（encrypted=true）：includeSecrets=false
- *    时 secrets.enc 加密空内容占位，备份仍需要密码导入，但不含任何凭据值；
- *  - 加密密码/秘密值绝不写入 manifest 与日志。
+ *  - Secret 值默认永不进入导出数据（结构化分区逐一过 SecretScanner 剥离值）；
+ *  - 备份恒为明文（encrypted=false / encryption=null）：本插件不再有加密层；
+ *  - 秘密值绝不写入 manifest 与日志。
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -138,7 +136,6 @@ export class Exporter {
     ctx;
     adapters;
     scanner;
-    encryption;
     exporterVersion;
     now;
     msg;
@@ -148,7 +145,6 @@ export class Exporter {
         this.ctx = opts.ctx;
         this.adapters = opts.adapters;
         this.scanner = opts.scanner ?? defaultSecretScanner();
-        this.encryption = opts.encryption ?? null;
         this.exporterVersion = opts.exporterVersion ?? '0.1.0';
         this.now = opts.now ?? (() => new Date());
         this.msg = opts.msg ?? msgOf(opts.ctx);
@@ -161,9 +157,6 @@ export class Exporter {
      */
     async export(options) {
         const { includeSecrets, only } = options;
-        if (includeSecrets && !this.encryption) {
-            throw new Error(this.msg('export.encryptionRequired'));
-        }
         // 1. 选定分区（only 过滤 + 默认包含）
         const selected = this.adapters
             .filter((a) => (only === undefined ? a.defaultIncluded : only.includes(a.id)))
@@ -172,6 +165,8 @@ export class Exporter {
         const sections = [];
         const warnings = [];
         const redactedHits = [];
+        /** 文件类分区实扫到的命中数：只有它能让 containsSecrets 为真（结构化分区已被剥离） */
+        let fileSectionSecretHits = 0;
         const included = [];
         const excluded = this.adapters.filter((a) => !selected.includes(a.id)).map((a) => a.id);
         // m1 埋点：每导出一个分区前上报真实进度（onSection 抛错不得中断导出）
@@ -210,6 +205,7 @@ export class Exporter {
                 if (fileHits.length > 0) {
                     // redactedHits 是**报告统计**通道（非告警通道）：仍计入全量命中（含同一文件的多行/多形态命中）。
                     redactedHits.push(...fileHits);
+                    fileSectionSecretHits += fileHits.length;
                     // 告警按**文件**去重（G-09/H1）：同一路径只告警一次。
                     // 修复前按 hit 计数，同一行同时命中「字段名」与「值形状」会产出两条同路径告警，
                     // 使少数文件就吃满上限，导致含真实明文凭据的其它文件被静默淹没（实测 redactedHits=8 而 5 条告警全属一个文件）。
@@ -239,12 +235,13 @@ export class Exporter {
             included.push({ section: adapter.id, counts: section.counts });
             warnings.push(...section.warnings);
         }
-        // 4. 组装 ZIP 条目（JSON 分区 + 文件类分区 + secrets.enc + checksums + manifest）
+        // 4. 组装 ZIP 条目（JSON 分区 + 文件类分区 + checksums + manifest）
         const entries = [];
         const sectionFlags = buildSectionFlags(sections);
-        let containsSecrets = false;
-        let encrypted = false;
-        let encryption = null;
+        // 备份恒为明文：本插件不再有加密层。containsSecrets 只认「文件类分区实扫到的命中」——
+        // 结构化分区的敏感值已被 scanner 剥离，不构成「含秘密」；文件类分区只报告不改写，
+        // 命中即代表归档里确有明文，必须如实标注。
+        const containsSecrets = fileSectionSecretHits > 0;
         for (const section of sections) {
             if (isFileSection(section.sectionId)) {
                 const prefix = SECTION_FILE_PREFIXES[section.sectionId];
@@ -262,34 +259,8 @@ export class Exporter {
                 data: Buffer.from(stringifyJsonSafe(section.data, { space: 2 }), 'utf8'),
             });
         }
-        // secrets.enc：有加密提供者即生成。includeSecrets=true 时加密真实的凭据原文；
-        // 只勾选加密（不导出密钥）时加密空内容占位，备份仍标记 encrypted（导入需密码），
-        // 但绝不把凭据值放进去（containsSecrets 保持 false；安全不变量不破）。
-        if (this.encryption) {
-            const credentialsFile = path.join(this.ctx.homeDir, '.credentials.yaml');
-            let plaintext;
-            if (includeSecrets) {
-                try {
-                    const raw = await this.ctx.fs.readFile(credentialsFile);
-                    plaintext = Buffer.from(raw).toString('utf8');
-                }
-                catch (err) {
-                    warnings.push(this.msg('export.credentialsReadFailed', { reason: err instanceof Error ? err.message : String(err) }));
-                    plaintext = '';
-                }
-            }
-            else {
-                plaintext = '';
-            }
-            const result = await this.encryption.encrypt(plaintext);
-            entries.push({ name: 'security/secrets.enc', data: result.blob });
-            encryption = result.info;
-            containsSecrets = includeSecrets && plaintext !== '';
-            encrypted = true;
-        }
         // 4b. 文件级 vault（includeSecrets=false：敏感文件明文不进归档 → 镜像到本机 vault）。
-        //     尽力而为：任何失败仅记警告，不中断导出。includeSecrets=true 时秘密已加密进归档，
-        //     无需镜像（vault 只服务于「明文不进备份」的本机留存场景）。
+        //     尽力而为：任何失败仅记警告，不中断导出。
         let vaultRefreshed = 0;
         if (!includeSecrets) {
             try {
@@ -317,8 +288,8 @@ export class Exporter {
             arch: this.ctx.arch,
             sections: sectionFlags,
             containsSecrets,
-            encrypted,
-            encryption,
+            encrypted: false,
+            encryption: null,
             exportedAt: this.now().toISOString(),
         });
         entries.push({ name: MANIFEST_FILE, data: Buffer.from(stringifyJsonSafe(manifest, { space: 2 }), 'utf8') });
@@ -333,7 +304,6 @@ export class Exporter {
             sections: Object.keys(sectionFlags).filter((k) => sectionFlags[k]),
             redactedFields: redactedHits.length,
             containsSecrets,
-            encrypted,
             vaultRefreshed,
         });
         const report = {
@@ -342,7 +312,6 @@ export class Exporter {
             security: {
                 secretsExcluded: !includeSecrets,
                 containsSecrets,
-                encrypted,
                 redactedHits: redactedHits.length,
                 vaultRefreshed,
             },

package/lib/core/importer.d.ts

@@ -30,7 +30,7 @@ export interface ExecuteOptions {
     confirm: boolean;
     /** 用户补录的秘密值（仅内存） */
     secretInputs?: Record<string, string>;
-    /** 加密备份解密结果（仅内存；解密必须经 m4 encryption provider） */
+    /** 旧版加密备份的解密结果（仅内存；宿主解密后注入，本插件不再产生加密备份） */
     decryptedCredentials?: Map<string, string>;
     /** 任一项失败立即整体回滚（默认 false：单项失败如实记录并继续其余项） */
     rollbackOnError?: boolean;

package/lib/core/index.d.ts

@@ -11,4 +11,4 @@ export { computeCompatibility, describeCompatibility, describeSchemaStatus, vali
 export { ImportNotConfirmedError, ImportFailedError, } from './types.ts';
 export type * from './types.ts';
 export { MigrationStore, sanitizeEntry, queryHistory, summarizeHistory, renderExport, parseHistoryQuery, isValidMigrationKind, redactHistoryText, makeHistoryFilename, isHistoryBasename, MIGRATION_HISTORY_DIR, DEFAULT_MIGRATION_RETENTION, MIGRATION_HISTORY_SCHEMA_VERSION, type MigrationKind, type MigrationResult, type MigrationHistoryEntry, type StoredMigrationHistoryEntry, type MigrationQuery, type MigrationHistoryStats, type ExportFormat, type ReadMigrationResult, type AppendResult, type MigrationIo, type MigrationStoreOptions, type MigrationSource, } from './migration-history.ts';
-export type { ExportOptions, ExportSection, ValidationResult, HostContext, SettingsFacade, CredentialsFacade, PluginsFacade, WorkspaceFacade, PatchFileFacade, FileSystemFacade, NamespaceInfo, PluginInfo, ConfigAdapter, Portability, SecretScanner, SensitiveHit, EncryptionProvider, PlanItem, PlanItemKind, ItemResolution, GlobalConflictStrategy, ImportAnalysis, ImportDecisions, ImportPlan, ImportResult, ExecutedItem, ImportContext, SnapshotTarget, SnapshotEntry, Snapshot, SnapshotStore, RollbackReport, PathMapping, PathIssue, CompatibilityInput, CompatibilityScore, ExportReport, ApplyResult, ConflictDecision, } from './types.ts';
+export type { ExportOptions, ExportSection, ValidationResult, HostContext, SettingsFacade, CredentialsFacade, PluginsFacade, WorkspaceFacade, PatchFileFacade, FileSystemFacade, NamespaceInfo, PluginInfo, ConfigAdapter, Portability, SecretScanner, SensitiveHit, PlanItem, PlanItemKind, ItemResolution, GlobalConflictStrategy, ImportAnalysis, ImportDecisions, ImportPlan, ImportResult, ExecutedItem, ImportContext, SnapshotTarget, SnapshotEntry, Snapshot, SnapshotStore, RollbackReport, PathMapping, PathIssue, CompatibilityInput, CompatibilityScore, ExportReport, ApplyResult, ConflictDecision, } from './types.ts';

package/lib/core/messages.d.ts

@@ -15,9 +15,7 @@
 import type { MsgFunc } from './msg-types.ts';
 export type { MsgFunc, MsgParams } from './msg-types.ts';
 export declare const zh: {
-    readonly 'export.encryptionRequired': '导出包含秘密需要注入 EncryptionProvider（m4 实现），拒绝明文导出秘密';
     readonly 'export.sectionFailed': '分区 {adapter} 导出失败: {reason}';
-    readonly 'export.credentialsReadFailed': '读取凭据文件失败，跳过秘密导出: {reason}';
     readonly 'export.vaultRefreshed': '凭据明文未进入备份，已镜像到本机 vault（{count} 个文件，恢复时可回填）';
     readonly 'export.vaultRefreshSkipped': 'vault 镜像跳过 {rel}: {reason}';
     readonly 'export.vaultRefreshFailed': 'vault 镜像刷新失败（不影响导出）: {reason}';
@@ -48,9 +46,7 @@ export declare const zh: {
     readonly 'import.secretMissingDesc': '凭据 {ref} 需要补录';
     readonly 'import.secretNotProvided': '凭据未提供，需补录';
     readonly 'import.notConfirmed': '导入未确认：必须显式 confirm 后才允许修改任何数据';
-    readonly 'import.encryptedPasswordRequired': '该备份已加密，必须提供解密密码才能导入（拒绝无密码导入）';
-    readonly 'import.encryptedPasswordWrong': '解密密码错误，请重试';
-    readonly 'import.notEncryptedContainer': '该文件不是加密备份容器，无法解锁';
+    readonly 'import.encryptedPasswordRequired': '该备份含上游历史加密凭据（security.encrypted=true），本插件无解密能力：须由宿主解密后注入凭据（decryptedCredentials）才能导入';
     readonly 'import.userSkipped': '用户跳过（导入中点击「跳过当前插件」）';
     readonly 'import.userSkippedDetail': '插件 {name} 已由用户跳过，未安装';
     readonly 'import.vaultRestored': '凭据文件 {rel} 已从本机 vault 回填';

package/lib/core/messages.js

@@ -1,8 +1,6 @@
 export const zh = {
     // ---------- 导出 ----------
-    'export.encryptionRequired': '导出包含秘密需要注入 EncryptionProvider（m4 实现），拒绝明文导出秘密',
     'export.sectionFailed': '分区 {adapter} 导出失败: {reason}',
-    'export.credentialsReadFailed': '读取凭据文件失败，跳过秘密导出: {reason}',
     'export.vaultRefreshed': '凭据明文未进入备份，已镜像到本机 vault（{count} 个文件，恢复时可回填）',
     'export.vaultRefreshSkipped': 'vault 镜像跳过 {rel}: {reason}',
     'export.vaultRefreshFailed': 'vault 镜像刷新失败（不影响导出）: {reason}',
@@ -34,9 +32,7 @@ export const zh = {
     'import.secretMissingDesc': '凭据 {ref} 需要补录',
     'import.secretNotProvided': '凭据未提供，需补录',
     'import.notConfirmed': '导入未确认：必须显式 confirm 后才允许修改任何数据',
-    'import.encryptedPasswordRequired': '该备份已加密，必须提供解密密码才能导入（拒绝无密码导入）',
-    'import.encryptedPasswordWrong': '解密密码错误，请重试',
-    'import.notEncryptedContainer': '该文件不是加密备份容器，无法解锁',
+    'import.encryptedPasswordRequired': '该备份含上游历史加密凭据（security.encrypted=true），本插件无解密能力：须由宿主解密后注入凭据（decryptedCredentials）才能导入',
     'import.userSkipped': '用户跳过（导入中点击「跳过当前插件」）',
     'import.userSkippedDetail': '插件 {name} 已由用户跳过，未安装',
     'import.vaultRestored': '凭据文件 {rel} 已从本机 vault 回填',
@@ -297,9 +293,7 @@ export const zh = {
 };
 export const en = {
     // ---------- export ----------
-    'export.encryptionRequired': 'Encrypted export requires an EncryptionProvider (m4); refusing to export secrets in plaintext',
     'export.sectionFailed': 'Section {adapter} export failed: {reason}',
-    'export.credentialsReadFailed': 'Failed to read the credentials file; secrets export skipped: {reason}',
     'export.vaultRefreshed': 'Credential plaintext did not enter the backup; mirrored to the local vault ({count} file(s), available for restore backfill)',
     'export.vaultRefreshSkipped': 'Vault mirror skipped {rel}: {reason}',
     'export.vaultRefreshFailed': 'Vault mirror refresh failed (export unaffected): {reason}',
@@ -331,9 +325,7 @@ export const en = {
     'import.secretMissingDesc': 'Credential {ref} needs to be re-entered',
     'import.secretNotProvided': 'Credential not provided; requires re-entry',
     'import.notConfirmed': 'Import not confirmed: explicit confirm is required before any data is modified',
-    'import.encryptedPasswordRequired': 'This backup is encrypted; the decryption password is required to import it (refusing password-less import)',
-    'import.encryptedPasswordWrong': 'Wrong decryption password, please try again',
-    'import.notEncryptedContainer': 'This file is not an encrypted backup container and cannot be unlocked',
+    'import.encryptedPasswordRequired': 'This backup carries upstream-encrypted credentials (security.encrypted=true) and this plugin cannot decrypt them: a host must decrypt and inject them (decryptedCredentials) before import',
     'import.userSkipped': 'Skipped by user (clicked "Skip current plugin" during import)',
     'import.userSkippedDetail': 'Plugin {name} was skipped by the user and not installed',
     'import.vaultRestored': 'Credential file {rel} backfilled from the local vault',

package/lib/core/patch-layers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * cordis patch 层的寻址契约（唯一真源）。
+ *
+ * 宿主组装 patch 栈的顺序是 `bundle → profile → home → --patch`（后者覆盖前者），两层分工不同：
+ *  - home 层 `$DSH_HOME/cordis.patch.yml`：全机偏好，对每个 profile 生效；
+ *  - profile 层 `$DSH_HOME/profiles/<profile>/cordis.patch.yml`：该 profile 专属（端口、trustedHosts、
+ *    挂载行…），换机恢复时必须跟着走。
+ *
+ * 两层的**持久化标识**是这里的两个逻辑 token，而不是相对路径：同步快照会跨机器、
+ * 跨 profile 导入，相对路径会把源机的 profile 名带过去。home 层 token 与历史快照里的
+ * `PatchLine.file` 取值逐字相同（存量快照零改动即可解析回 home 层）。
+ *
+ * 层限定复合键 `<file>#<lineId>`：两层可以存在同名 `lineId`，而计划项 id / `target.ref` /
+ * 快照条目必须唯一指向「哪一层的哪一行」，否则应用与回滚会写错层。两个 token 与 lineId 都不含
+ * `#`（后者由 `readPatchLines` 保证非空字符串，此处不额外校验），分隔符无歧义。
+ */
+/** home 层 token（`$DSH_HOME/cordis.patch.yml`）；取值与历史快照的 file 字段一致。 */
+export declare const HOME_PATCH_FILE = "cordis.patch.yml";
+/** profile 层 token（`$DSH_HOME/profiles/<profile>/cordis.patch.yml`）。 */
+export declare const PROFILE_PATCH_FILE = "profile:cordis.patch.yml";
+/** 层限定复合键：`<file>#<lineId>`。 */
+export declare function patchLayerKey(file: string, lineId: string): string;
+/**
+ * 解析层限定复合键。
+ *
+ * 兼容分支：旧快照的 `target.ref` / `SnapshotEntry.ref` 是裸 `lineId`（当时只有 home 层），
+ * 不含 `#` 即视作 home 层。lineId 本身不含 `#`，因此该分支无歧义。
+ */
+export declare function parsePatchLayerKey(ref: string): {
+    file: string;
+    lineId: string;
+};

package/lib/core/patch-layers.js

@@ -0,0 +1,39 @@
+/**
+ * cordis patch 层的寻址契约（唯一真源）。
+ *
+ * 宿主组装 patch 栈的顺序是 `bundle → profile → home → --patch`（后者覆盖前者），两层分工不同：
+ *  - home 层 `$DSH_HOME/cordis.patch.yml`：全机偏好，对每个 profile 生效；
+ *  - profile 层 `$DSH_HOME/profiles/<profile>/cordis.patch.yml`：该 profile 专属（端口、trustedHosts、
+ *    挂载行…），换机恢复时必须跟着走。
+ *
+ * 两层的**持久化标识**是这里的两个逻辑 token，而不是相对路径：同步快照会跨机器、
+ * 跨 profile 导入，相对路径会把源机的 profile 名带过去。home 层 token 与历史快照里的
+ * `PatchLine.file` 取值逐字相同（存量快照零改动即可解析回 home 层）。
+ *
+ * 层限定复合键 `<file>#<lineId>`：两层可以存在同名 `lineId`，而计划项 id / `target.ref` /
+ * 快照条目必须唯一指向「哪一层的哪一行」，否则应用与回滚会写错层。两个 token 与 lineId 都不含
+ * `#`（后者由 `readPatchLines` 保证非空字符串，此处不额外校验），分隔符无歧义。
+ */
+/** home 层 token（`$DSH_HOME/cordis.patch.yml`）；取值与历史快照的 file 字段一致。 */
+export const HOME_PATCH_FILE = 'cordis.patch.yml';
+/** profile 层 token（`$DSH_HOME/profiles/<profile>/cordis.patch.yml`）。 */
+export const PROFILE_PATCH_FILE = 'profile:cordis.patch.yml';
+/** 层限定复合键的分隔符（两个层 token 与 lineId 都不含它）。 */
+const PATCH_LAYER_SEPARATOR = '#';
+/** 层限定复合键：`<file>#<lineId>`。 */
+export function patchLayerKey(file, lineId) {
+    return `${file}${PATCH_LAYER_SEPARATOR}${lineId}`;
+}
+/**
+ * 解析层限定复合键。
+ *
+ * 兼容分支：旧快照的 `target.ref` / `SnapshotEntry.ref` 是裸 `lineId`（当时只有 home 层），
+ * 不含 `#` 即视作 home 层。lineId 本身不含 `#`，因此该分支无歧义。
+ */
+export function parsePatchLayerKey(ref) {
+    const at = ref.indexOf(PATCH_LAYER_SEPARATOR);
+    if (at < 0)
+        return { file: HOME_PATCH_FILE, lineId: ref };
+    return { file: ref.slice(0, at), lineId: ref.slice(at + 1) };
+}
+//# sourceMappingURL=patch-layers.js.map

package/lib/core/rollback.js

@@ -8,6 +8,7 @@
  *  - settings 回滚仍走 expectedRevision 乐观锁，避免覆盖导入后用户的新修改。
  */
 import { resolveFileTarget } from './backup.js';
+import { parsePatchLayerKey } from './patch-layers.js';
 import { msgOf } from './messages.js';
 /** 逆序补偿单条快照条目；返回 null=成功，否则为失败原因 */
 async function compensateOne(entry, ctx, store) {
@@ -57,10 +58,9 @@ async function compensateOne(entry, ctx, store) {
         }
         case 'patchLine': {
             try {
-                // 引擎只管理 profile 的 cordis.patch.yml（backup.ts 的 patchLine 快照只记 lineId 作 ref，
-                // 不含文件编码）——回滚固定写回该文件；切勿把 lineId 当文件名（否则 patchPath 抛「仅支持管理」）。
-                const file = 'cordis.patch.yml';
-                const lineId = entry.ref;
+                // 快照条目的 ref 是层限定复合键（<file>#<lineId>）——必须写回**同一层**，
+                // 否则 profile 层的原值会被写进 home 层。旧快照的裸 lineId 兼容为 home 层。
+                const { file, lineId } = parsePatchLayerKey(entry.ref);
                 await ctx.patchFile.applyPatchChanges(file, [
                     { lineId, raw: entry.before, action: entry.before === null ? 'remove' : 'update' },
                 ]);

package/lib/core/types.d.ts

@@ -5,14 +5,18 @@
  * HostContext 是 m3 定义、m5 实现的 DSH Service 门面（研究报告 §3.2 的叶子方法最小集），
  * 测试用内存 mock 即可驱动完整导出→导入往返。
  */
-import type { EncryptionInfo, Manifest, SectionId, WorkspaceRecord } from '../schema/types.ts';
+import type { Manifest, SectionId, WorkspaceRecord } from '../schema/types.ts';
 import type { TombstoneKind } from '../schema/tombstones.ts';
 import type { MutationLockPort } from '../utils/env-lock.ts';
 import type { RecursiveListing } from '../utils/recursive-walk.ts';
 import type { Logger } from '../utils/logger.ts';
 import type { MsgFunc } from './messages.ts';
 export interface ExportOptions {
-    /** 是否包含真实秘密（必须配合 encryption 提供者；缺省 false = 只导状态） */
+    /**
+     * 是否把真实秘密写入备份。本插件不再有加密层（备份恒为明文），结构化分区的秘密值
+     * 始终由 SecretScanner 剥离，故本开关当前的实际作用只剩「是否刷新本机 vault 镜像」：
+     * false → 导出后把敏感文件镜像到本机 vault（明文不进归档）。
+     */
     includeSecrets: boolean;
     /** 仅导出指定分区（缺省 = 全部默认包含分区） */
     only?: SectionId[];
@@ -249,7 +253,7 @@ export interface ImportAnalysis {
         item: string;
         dependency: string;
     }[];
-    /** 备份是否加密（manifest.security.encrypted）：加密备份的凭据必须用解密密码恢复 */
+    /** 旧版加密备份标记（manifest.security.encrypted）：本插件不再产生，仅历史产物为 true */
     encrypted: boolean;
 }
 export interface ImportDecisions {
@@ -307,6 +311,7 @@ export interface ImportContext {
     resolutions: Record<string, ItemResolution>;
     /** 用户补录的秘密值（仅内存，永不落盘/日志） */
     secretInputs: Record<string, string>;
+    /** 旧版加密备份的解密结果（仅内存；宿主解密后注入） */
     decryptedCredentials?: Map<string, string>;
     log: Logger;
     /** 消息翻译器（analyzer 注入；适配器用它生成计划项描述/校验/结果消息） */
@@ -461,7 +466,6 @@ export interface ExportReport {
     security: {
         secretsExcluded: boolean;
         containsSecrets: boolean;
-        encrypted: boolean;
         redactedHits: number;
         /** 本次导出镜像到本机 vault 的敏感文件数（文件级 vault；0 或缺失 = 未镜像） */
         vaultRefreshed?: number;
@@ -491,14 +495,6 @@ export interface ConfigAdapter<TSection = unknown> {
     /** 可选：针对本 adapter 的补偿动作 */
     rollback?(entries: SnapshotEntry[], ctx: HostContext): Promise<void>;
 }
-export interface EncryptionProvider {
-    encrypt(plaintext: string): Promise<{
-        blob: Uint8Array;
-        info: EncryptionInfo;
-    }>;
-    /** authTag 校验失败必须抛错 */
-    decrypt(blob: Uint8Array, info: EncryptionInfo, password: string): Promise<string>;
-}
 /** 导入被确认前拒绝执行（安全阀） */
 export declare class ImportNotConfirmedError extends Error {
     constructor(msg?: MsgFunc);

package/lib/index.d.ts

@@ -20,8 +20,8 @@
  *    (isLoopbackRequest); LAN-exposed deployments never serve these endpoints;
  *  - uploads/exported ZIPs are staged under $DSH_HOME/dsh-config-manager/{tmp,exports}
  *    and every `path`/`zipPath` reference is confined to those roots;
- *  - the encryption password is in-memory only: used to derive the AES-256-GCM
- *    key for secrets.enc, never written to any file, manifest, or log;
+ *  - there is no encryption layer: every backup is plaintext, and secret values are
+ *    stripped by the secret scanner before they reach any file, manifest, or log;
  *  - the import execute endpoint refuses to run without `confirm: true`
  *    (core ImportNotConfirmedError safety valve).
  *
@@ -132,6 +132,27 @@ export declare class DshPluginsFacade implements PluginsFacade {
         needsRestart: boolean;
     }>;
 }
+/** Patch-file facade：用户 patch 层（$DSH_HOME/cordis.patch.yml）+ profile patch 层
+ * （$DSH_HOME/profiles/<name>/cordis.patch.yml），两者都在 home 根内。
+ *
+ * 导出仅为让测试能用**真实门面**（而非 mock）钉住层寻址——mock 会让两个层 token 的取值
+ * 撞车无处暴露（DshPluginsFacade 同款做法）。 */
+export declare class DshPatchFileFacade implements PatchFileFacade {
+    private readonly homeDir;
+    private readonly profile;
+    private readonly msg;
+    constructor(homeDir: string, profile: string, msg?: MsgFunc);
+    private patchPath;
+    readPatchLines(file: string): Promise<{
+        lineId: string;
+        raw: unknown;
+    }[]>;
+    applyPatchChanges(file: string, changes: {
+        lineId: string;
+        raw: unknown;
+        action: 'insert' | 'update' | 'remove';
+    }[]): Promise<void>;
+}
 /** 同步路由可预期的请求级错误（status 缺省 400；引擎/传输失败走 500） */
 export declare class SyncRouteError extends Error {
     readonly status: number;
@@ -217,18 +238,6 @@ export declare function executeRestorePlan(plan: RestorePlan, exec: RestoreExecu
  * 是真实故障，仍按 500 暴露，绝不伪装成「未登录」。
  */
 export declare function isGitHubAuthMissing(error: unknown): boolean;
-/** /status 的插件诊断位（issue #28）。仅回非敏感元信息：目录、profile 名、计数。 */
-export interface PluginDiagnostics {
-    homeDir: string;
-    profile: string;
-    /** profile 目录的 package.json 是否可读（不可读 → 清单必然为空） */
-    profileManifestReadable: boolean;
-    /** 插件清单来源 = package.json 的 dependencies 里非 in-box 的包 */
-    installedPluginCount: number;
-    installedPluginNames: string[];
-    /** dsh.profile.bundles 声明（非空即「替换默认插件栈」） */
-    bundles: string[];
-}
 /**
  * Mount the config-manager engine: host context, adapters, and the
  * /api/dsh-config-manager routes (when a webServer is present).