dsh-config-manager 0.1.71 → 0.1.72

package/src/core/backup-verify.ts

@@ -28,6 +28,7 @@
  *    （实测 `verifyChecksums` 只调用 `map.get()`，不会整体物化 Map）。
  *    对 MB 级的 DSH 配置备份完全可接受。
  */
+import { engineMsg } from './messages-core.ts';
 import fs from 'node:fs/promises';
 import { verifyChecksums } from '../utils/hashing.ts';
 import { isENOENT } from '../utils/guards.ts';
@@ -146,18 +147,18 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
   try {
     const stat = await fs.stat(zipPath);
     if (!stat.isFile()) {
-      errors.push(`不是普通文件（目录或特殊文件）/ not a regular file: ${zipPath}`);
+      errors.push(engineMsg('core.backupVerify.notRegularFile', { zip: zipPath }));
       return makeResult(zipPath, 'MISSING', errors, warnings);
     }
     sizeBytes = stat.size;
     buf = await fs.readFile(zipPath);
   } catch (err) {
     if (isENOENT(err)) {
-      errors.push(`备份文件不存在 / backup file not found: ${zipPath}`);
+      errors.push(engineMsg('core.backupVerify.fileNotFound', { zip: zipPath }));
       return makeResult(zipPath, 'MISSING', errors, warnings);
     }
     // 文件在但读不动（EACCES / EBUSY / IO 错）：这是自检自身的失败，不是「备份坏了」
-    errors.push(`备份文件不可读 / backup file unreadable: ${msgOfError(err)}`);
+    errors.push(engineMsg('core.backupVerify.fileUnreadable', { reason: msgOfError(err) }));
     return makeResult(zipPath, 'VERIFY_ERROR', errors, warnings);
   }
 
@@ -170,7 +171,7 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
     /* ---------------- 2. 打开为 ZIP ---------------- */
     // 整体加密容器不是 ZIP（先识别，给出比「ZIP 损坏」准确得多的结论）
     if (isArchiveBlob(buf)) {
-      errors.push('整体加密备份容器（DCA1）需先用密码解密为 ZIP 才能自检 / encrypted container must be decrypted first');
+      errors.push(engineMsg('core.backupVerify.encryptedContainer'));
       return withSize('UNSUPPORTED');
     }
 
@@ -178,7 +179,7 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
     try {
       archive = createHardenedZipParser()(buf);
     } catch (err) {
-      errors.push(`ZIP 无法打开 / cannot open as ZIP: ${msgOfError(err)}`);
+      errors.push(engineMsg('core.backupVerify.cannotOpenZip', { reason: msgOfError(err) }));
       return withSize('CORRUPT');
     }
     const metas = archive.entries();
@@ -187,13 +188,13 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
       file: zipPath, verdict, sizeBytes, entryCount, errors, warnings,
     });
     if (entryCount === 0) {
-      errors.push('空 ZIP（0 条目）/ empty archive');
+      errors.push(engineMsg('core.backupVerify.emptyArchive'));
       return withEntries('CORRUPT');
     }
 
     /* ---------------- 3. manifest.json ---------------- */
     if (!archive.has(MANIFEST_FILE)) {
-      errors.push(`缺少 ${MANIFEST_FILE}（不是本插件导出的备份）/ ${MANIFEST_FILE} missing`);
+      errors.push(engineMsg('core.backupVerify.missingManifest', { file: MANIFEST_FILE }));
       return withEntries('CORRUPT');
     }
     let manifestRaw: string;
@@ -201,14 +202,14 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
       manifestRaw = archive.readEntryText(MANIFEST_FILE);
     } catch (err) {
       // 条目本身读不出来（CRC 失败/解压失败）→ 归档损坏，而非 manifest 语义非法
-      errors.push(`${MANIFEST_FILE} 无法读取（归档损坏）/ unreadable entry: ${msgOfError(err)}`);
+      errors.push(engineMsg('core.backupVerify.manifestUnreadable', { file: MANIFEST_FILE, reason: msgOfError(err) }));
       return withEntries('CORRUPT');
     }
     let manifest: Manifest;
     try {
       manifest = parseManifest(manifestRaw);
     } catch (err) {
-      errors.push(`${MANIFEST_FILE} 非法 / invalid manifest: ${msgOfError(err)}`);
+      errors.push(engineMsg('core.backupVerify.invalidManifest', { file: MANIFEST_FILE, reason: msgOfError(err) }));
       return withEntries('CORRUPT');
     }
     const sections = Object.entries(manifest.sections ?? {})
@@ -220,13 +221,13 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
 
     if (!isSupported(manifest.schemaVersion)) {
       // 版本超范围是「本插件读不了」，不是「备份坏了」——明确区分，避免误导用户重导
-      errors.push(`schema 版本不受支持 / unsupported schema version: ${describeVersion(manifest.schemaVersion)}`);
+      errors.push(engineMsg('core.backupVerify.unsupportedSchema', { version: describeVersion(manifest.schemaVersion) }));
       return withManifest('UNSUPPORTED');
     }
 
     /* ---------------- 4. integrity/checksums.json ---------------- */
     if (!archive.has(CHECKSUMS_FILE)) {
-      errors.push(`缺少 ${CHECKSUMS_FILE}（无法做完整性校验）/ ${CHECKSUMS_FILE} missing`);
+      errors.push(engineMsg('core.backupVerify.missingChecksums', { file: CHECKSUMS_FILE }));
       return withManifest('CORRUPT');
     }
     let table: Record<string, string>;
@@ -234,7 +235,7 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
       table = parseChecksumsTable(archive.readEntryText(CHECKSUMS_FILE));
     } catch (err) {
       // readEntryText 的 CRC/解压失败与「表结构非法」都归 CORRUPT（两者都说明备份不可信）
-      errors.push(`${CHECKSUMS_FILE} 非法或不可读 / invalid or unreadable checksums table: ${msgOfError(err)}`);
+      errors.push(engineMsg('core.backupVerify.invalidChecksums', { file: CHECKSUMS_FILE, reason: msgOfError(err) }));
       return withManifest('CORRUPT');
     }
 
@@ -243,7 +244,7 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
     const unreadableNames = new Set<string>();
     const unreadable: string[] = [];
     const lazyEntries = new LazyEntryMap(archive, unreadableNames, (name, reason) => {
-      unreadable.push(`${name}（${reason}）`);
+      unreadable.push(engineMsg('core.backupVerify.unreadableEntry', { name, reason }));
     });
     const tableKeys = Object.keys(table);
     const check = verifyChecksums(lazyEntries, table);
@@ -254,10 +255,10 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
     // 4b. 结构提示：未纳入校验表的条目（导出器只把 manifest 与校验表自身排除在外）
     if (tableKeys.length === 0) {
       if (entryCount > NON_DATA_ENTRIES.size) {
-        errors.push('校验表为空但归档含数据条目 / empty checksums table with data entries');
+        errors.push(engineMsg('core.backupVerify.emptyTableWithData'));
         return withManifest('CORRUPT');
       }
-      warnings.push('校验表为空（归档仅含 manifest 与校验表自身）/ empty checksums table');
+      warnings.push(engineMsg('core.backupVerify.emptyTable'));
     }
     const covered = new Set(tableKeys);
     const uncovered = metas
@@ -265,7 +266,7 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
       .map((m) => m.name);
     if (uncovered.length > 0) {
       const shown = uncovered.slice(0, 5).join(', ');
-      warnings.push(`含未纳入校验表的条目 ${uncovered.length} 个 / entries not covered by checksums: ${shown}${uncovered.length > 5 ? ', …' : ''}`);
+      warnings.push(engineMsg('core.backupVerify.uncoveredEntries', { count: uncovered.length, shown, suffix: uncovered.length > 5 ? ', …' : '' }));
     }
 
     // 4c. 结构提示：manifest 声明包含的分区在归档内应有对应条目
@@ -274,30 +275,30 @@ export async function verifyBackupZip(zipPath: string): Promise<BackupVerifyResu
       const jsonPath = SECTION_JSON_PATHS[id as SectionId];
       if (prefix !== undefined) {
         if (!metas.some((m) => m.name.startsWith(prefix) && m.name !== prefix)) {
-          warnings.push(`manifest 声明分区 ${id} 但归档内无对应文件 / declared section has no entries: ${id}`);
+          warnings.push(engineMsg('core.backupVerify.declaredSectionNoEntries', { id }));
         }
       } else if (jsonPath !== undefined && !archive.has(jsonPath)) {
-        warnings.push(`manifest 声明分区 ${id} 但缺少 ${jsonPath} / declared section payload missing: ${id}`);
+        warnings.push(engineMsg('core.backupVerify.declaredSectionPayloadMissing', { id, path: jsonPath }));
       }
     }
     if (manifest.security?.encrypted === true && !metas.some((m) => SECRETS_ENC_RE.test(m.name))) {
-      warnings.push('manifest 标记加密但归档内无凭据密文条目 / encrypted flag without secrets entry');
+      warnings.push(engineMsg('core.backupVerify.encryptedFlagNoSecrets'));
     }
 
     /* ---------------- 裁决 ---------------- */
     if (missing.length > 0) {
-      errors.push(`校验表内条目缺失（${missing.length}）/ missing entries: ${missing.join(', ')}`);
+      errors.push(engineMsg('core.backupVerify.missingEntries', { count: missing.length, list: missing.join(', ') }));
     }
     if (mismatched.length > 0) {
-      errors.push(`条目 SHA-256 不符（${mismatched.length}）/ hash mismatch: ${mismatched.join(', ')}`);
+      errors.push(engineMsg('core.backupVerify.hashMismatch', { count: mismatched.length, list: mismatched.join(', ') }));
     }
     if (unreadable.length > 0) {
-      errors.push(`条目无法读取（${unreadable.length}）/ unreadable entries: ${unreadable.join(', ')}`);
+      errors.push(engineMsg('core.backupVerify.unreadableEntries', { count: unreadable.length, list: unreadable.join(', ') }));
     }
     return withManifest(missing.length > 0 || mismatched.length > 0 || unreadable.length > 0 ? 'CORRUPT' : 'OK');
   } catch (err) {
     // 5. 自检自身异常：如实报 VERIFY_ERROR，绝不降级成 OK
-    errors.push(`自检过程异常 / verification error: ${msgOfError(err)}`);
+    errors.push(engineMsg('core.backupVerify.verificationError', { reason: msgOfError(err) }));
     return withSize('VERIFY_ERROR');
   }
 }

package/src/core/backup.test.ts

@@ -344,3 +344,79 @@ test('F-4: normalizeDshVersion 归一（去空白 / unknown 丢弃 / 非字符
   assert.equal(normalizeDshVersion(undefined), undefined);
   assert.equal(normalizeDshVersion(42), undefined);
 });
+
+/* ---------------- 宿主文件「存在但读不出来」不得记成 existed:false（数据安全） ---------------- */
+
+test('备份：宿主文件存在但读不出来 → existed=true + unreadable=true（绝不写 existed:false）', async (t) => {
+  const dir = await tmpDir(t, 'unreadable');
+  const { ctx } = countingCtx();
+  await seedHostFiles(ctx);
+  // 让 settings.yaml 这一次读不出来（占用 / 权限 / IO 错的等价物）
+  const fsFacade = ctx.fs as { readFile: (rel: string) => Promise<Uint8Array> };
+  const original = fsFacade.readFile.bind(ctx.fs);
+  fsFacade.readFile = async (rel: string) => {
+    if (rel === 'settings.yaml') throw new Error('EBUSY: resource busy or locked');
+    return original(rel);
+  };
+  const store = new FileSnapshotStore({ dir });
+  const snapshot = await createSnapshot({ ctx, plan: emptyPlan(), sourceZip: 'unit.zip', store, adapters: [] });
+
+  const settings = (snapshot.hostFileBackups ?? []).find((b) => b.relPath === 'settings.yaml');
+  assert.ok(settings, 'settings.yaml 必须仍被登记（绝不因读失败而消失）');
+  assert.equal(settings.existed, true, '存在但读不到 → existed 必须为 true（写成 false 会在恢复时删掉用户真实文件）');
+  assert.equal(settings.unreadable, true, '必须显式标注 unreadable');
+  assert.equal(settings.blobPath, '', '读不到 → 没有 blob');
+  const patch = (snapshot.hostFileBackups ?? []).find((b) => b.relPath === 'cordis.patch.yml');
+  assert.equal(patch?.existed, true, '其余宿主文件照常读');
+  assert.equal(patch?.unreadable, undefined, '读得到的条目不得被标 unreadable');
+  assert.equal((await verifySnapshot(dir, snapshot.id)).ok, true, 'unreadable 条目不得破坏 durable+verified');
+});
+
+/* ---------------- 保留清理 fail-closed：引用集合读不出来时本轮绝不删（数据安全） ---------------- */
+
+test('保留清理：recovery 引用集合读不出来 → 本轮放弃清理，绝不按空集合删（F3 不可回退）', async (t) => {
+  const dir = await tmpDir(t, 'prune-ref');
+  const { ctx } = countingCtx();
+  await seedHostFiles(ctx);
+  let scans = 0;
+  const warned: string[] = [];
+  const store = new FileSnapshotStore({
+    dir,
+    // 引用扫描一次瞬时失败（EACCES / IO 错）—— 此前会被 .catch 成空集合，随即按「无人引用」继续删
+    referencedSnapshotIds: async () => { scans += 1; throw new Error('EACCES: permission denied'); },
+    retentionPolicy: () => ({ keepLast: 1, keepMonthly: 0, keepYearly: 0 }),
+    onWarn: (message) => { warned.push(message) },
+  });
+
+  const first = await createSnapshot({ ctx, plan: emptyPlan(), sourceZip: 'unit.zip', store, adapters: [] });
+  const second = await createSnapshot({ ctx, plan: emptyPlan(), sourceZip: 'unit.zip', store, adapters: [] });
+
+  assert.ok(scans >= 1, 'prune 必须真的问过 recovery 引用集合（否则本用例不成立）');
+  const remaining = (await fs.readdir(dir)).sort();
+  assert.deepEqual(remaining, [first.id, second.id].sort(), '读不到引用集合时本轮必须放弃清理 —— 两个快照都得留着');
+  assert.ok(warned.some((m) => m.includes('放弃')), '放弃必须留痕（绝不静默）：' + JSON.stringify(warned));
+});
+
+/* ---------------- 保留清理：目录名 ≠ 内部 id 时跳过并留痕（数据安全） ---------------- */
+
+test('保留清理：快照目录名与内部 id 不一致时跳过并留痕（绝不按内部 id 删另一个目录）', async (t) => {
+  const dir = await tmpDir(t, 'prune-name');
+  const { ctx } = countingCtx();
+  await seedHostFiles(ctx);
+  const warned: string[] = [];
+  const store = new FileSnapshotStore({
+    dir,
+    retentionPolicy: () => ({ keepLast: 1, keepMonthly: 0, keepYearly: 0 }),
+    onWarn: (message) => { warned.push(message) },
+  });
+  const first = await createSnapshot({ ctx, plan: emptyPlan(), sourceZip: 'unit.zip', store, adapters: [] });
+  // 手工制造「目录名 ≠ 内部 id」（改名目录 / 半截拷贝残留的真机形态）
+  const renamed = path.join(dir, 'zzz-renamed-dir');
+  await fs.rename(path.join(dir, first.id), renamed);
+  const second = await createSnapshot({ ctx, plan: emptyPlan(), sourceZip: 'unit.zip', store, adapters: [] });
+
+  const remaining = (await fs.readdir(dir)).sort();
+  assert.ok(remaining.includes('zzz-renamed-dir'), '目录名与内部 id 不一致的目录绝不能被当成候选删掉');
+  assert.ok(remaining.includes(second.id), '新建的快照当然还在');
+  assert.ok(warned.some((m) => m.includes('不一致')), '跳过必须留痕（绝不静默）：' + JSON.stringify(warned));
+});

package/src/core/backup.ts

@@ -5,6 +5,7 @@
  * 快照不保存 credential 值（DSH 永不回读值）——credential 条目只记 existed 标志，
  * 回滚时 existed=true 的条目如实标记「值需人工补录」。
  */
+import { engineMsg } from './messages-core.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
@@ -103,8 +104,11 @@ async function backupHostFiles(
     try {
       existed = await ctx.fs.exists(relPath);
     } catch (err) {
+      // 探测自身失败 = 存在性判不出来：按「存在但不可读」登记。**绝不写 existed:false** ——
+      // 那会被恢复侧读成「当时确实不存在」，进而删掉用户真实的文件。
       ctx.log.warn(`快照探测宿主文件失败 ${relPath}: ${err instanceof Error ? err.message : String(err)}`);
-      existed = false;
+      backups.push({ relPath, blobPath: '', existed: true, unreadable: true });
+      continue;
     }
     if (!existed) {
       backups.push({ relPath, blobPath: '', existed: false });
@@ -115,8 +119,10 @@ async function backupHostFiles(
       blobs.set(blobPath, await ctx.fs.readFile(relPath));
       backups.push({ relPath, blobPath, existed: true });
     } catch (err) {
+      // 文件确实存在、只是这次读不出来（占用/权限/IO）：登记 existed=true + unreadable，
+      // 恢复侧据此只跳过并告警，绝不进入「删除」分支（见 HostFileBackup.unreadable）。
       ctx.log.warn(`快照读取宿主文件失败 ${relPath}: ${err instanceof Error ? err.message : String(err)}`);
-      backups.push({ relPath, blobPath: '', existed: false });
+      backups.push({ relPath, blobPath: '', existed: true, unreadable: true });
     }
   }
   return backups;
@@ -142,7 +148,7 @@ const FILE_BASES: Partial<Record<SectionId, string>> = {
 // 其它分区语义处理」同类缺陷）。注册表新增文件类分区时若忘了在这里补，进程启动即失败。
 for (const id of SECTION_IDS) {
   if (isFileSection(id) && FILE_BASES[id] === undefined) {
-    throw new Error(`分区 ${id} 是文件类分区，但 core/backup.ts 的 FILE_BASES 未给基准目录（拒绝静默退回 homeDir 根）`);
+    throw new Error(engineMsg('core.backup.fileSectionBaseMissing', { section: id }));
   }
 }
 
@@ -316,7 +322,7 @@ async function engineSnapshotEntry(ctx: HostContext, target: SnapshotTarget): Pr
       // secrets 已注册但**没有 adapter、也没有 ZIP 内分区 JSON**（凭据值走独立加密容器 secrets.enc）。
       // 任何计划项都不应以它为快照目标 —— 显式报错，而不是落到 default 分支。
       throw new Error(
-        'secrets 分区没有 adapter / 无分区载荷，不应作为快照目标（凭据值走独立加密容器，绝不进快照）',
+        engineMsg('core.backup.secretsSectionNotSnapshotTarget'),
       );
     default: {
       // 编译期穷举断言：SectionId 的每一项都已被上面的 case 处理 → 此处 target.adapter 收窄为 never。
@@ -326,8 +332,7 @@ async function engineSnapshotEntry(ctx: HostContext, target: SnapshotTarget): Pr
       // 旧实现在这里静默返回 settingsNamespace 条目（连 existed 都没有）→ 回滚把该目标当「原本不存在」
       // 而不做任何补偿：该分区的写入永远撤不掉，报告却仍说「已快照、可回滚」（审计 core-flow#F-10）。
       throw new Error(
-        `快照不支持分区「${String(unhandled)}」：它未在 schema/section-registry.ts 注册（或缺少快照实现）；`
-        + '拒绝按其它分区语义静默记录（那会让该分区的写入无法回滚）',
+        engineMsg('core.backup.sectionUnsupported', { section: String(unhandled) }),
       );
     }
   }
@@ -534,6 +539,11 @@ export interface FileSnapshotStoreOptions {
    * 未注入 → `fallbackPruneSelector`（只按 keepLast，等价既有 FIFO；分层字段被忽略 = 保守少删）。
    */
   pruneSelector?: PruneSelector;
+  /**
+   * 诊断回调（可选）：保留清理**被放弃**或失败时的可见线索。
+   * 缺省 = 不记录（不改变行为）；宿主接 `host.log.warn` —— 「这轮为什么没清理」必须能查。
+   */
+  onWarn?: (message: string) => void;
 }
 
 /** 文件快照存储：<dir>/<id>/snapshot.json + <dir>/<id>/blobs/* */
@@ -554,7 +564,7 @@ export class FileSnapshotStore implements SnapshotStore {
    */
   private async writeBlob(dir: string, blobPath: string, data: Uint8Array, hashes: Record<string, string>): Promise<void> {
     const target = path.join(dir, blobPath);
-    if (!target.startsWith(dir)) throw new Error(`快照 blob 路径越界: ${blobPath}`);
+    if (!target.startsWith(dir)) throw new Error(engineMsg('core.backup.blobPathEscaped', { path: blobPath }));
     await fs.mkdir(path.dirname(target), { recursive: true });
     await atomicWriteFile(target, data);
     hashes[blobPath] = sha256Hex(data);
@@ -579,7 +589,7 @@ export class FileSnapshotStore implements SnapshotStore {
     // 4) 验证（从磁盘重读，不信任内存对象）
     const verified = await verifySnapshot(this.options.dir, snapshot.id);
     if (!verified.ok) {
-      throw new Error(`快照 ${snapshot.id} 验证失败: ${verified.reason}`);
+      throw new Error(engineMsg('core.backup.snapshotVerifyFailed', { id: snapshot.id, reason: verified.reason ?? '' }));
     }
     // 5) 原子发布 READY（重写 snapshot.json readiness='READY'；metadataHash 稳定不受影响）
     const ready = { ...snapshot, readiness: 'READY' as const };
@@ -588,7 +598,9 @@ export class FileSnapshotStore implements SnapshotStore {
     try {
       await this.prune();
     } catch (err) {
-      // 快照已 READY + verified；prune 失败（EBUSY/EPERM）不应把刚成功的快照判为 unusable
+      // 快照已 READY + verified；prune 失败（EBUSY/EPERM）不应把刚成功的快照判为 unusable ——
+      // 但必须留痕：保留清理长期失败会让快照无限堆积，用户与日志都看不到线索。
+      this.options.onWarn?.(engineMsg('core.backup.pruneFailed', { reason: err instanceof Error ? err.message : String(err) }));
     }
     return snapshot.id;
   }
@@ -632,7 +644,18 @@ export class FileSnapshotStore implements SnapshotStore {
   private async prune(): Promise<void> {
     const dir = this.options.dir;
     const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-    const referenced = await this.options.referencedSnapshotIds?.().catch(() => new Set<string>()) ?? new Set<string>();
+    // F3：被未收敛 journal 引用的快照**绝不自动清理**。判据是「读不到 ≠ 没有引用」——
+    // 引用提供者抛错时**放弃本轮清理**，绝不按空集合继续删：一次瞬时 IO 错就可能删掉
+    // 事故恢复唯一的回滚点（那是 SAFE MODE 的唯一证据）。此前这里是 `.catch(() => new Set())`。
+    let referenced = new Set<string>();
+    if (this.options.referencedSnapshotIds !== undefined) {
+      try {
+        referenced = await this.options.referencedSnapshotIds();
+      } catch (err) {
+        this.options.onWarn?.(engineMsg('core.backup.pruneAbandoned', { reason: err instanceof Error ? err.message : String(err) }));
+        return;
+      }
+    }
     // m-retention：策略读取失败 → 回退缺省（绝不因策略提供者异常而误删/崩溃）
     const policy = await Promise.resolve()
       .then(() => this.options.retentionPolicy?.() ?? defaultRetentionPolicyLike())
@@ -644,9 +667,16 @@ export class FileSnapshotStore implements SnapshotStore {
       try {
         const parsed = parseJsonSafe(await fs.readFile(path.join(dir, entry.name, 'snapshot.json'), 'utf8')) as Snapshot;
         if (typeof parsed.id !== 'string' || parsed.id === '' || typeof parsed.createdAt !== 'string') continue;
+        // 删除目标只能是**目录名**（下面 path.join(dir, id) 就是按它删的）。目录名与内部 id 不一致时
+        // **绝不猜**：pinned/被引用的判断是对着这份 snapshot.json 做的，删除却会打在另一个目录上 ——
+        // 跳过并留痕（手工改名/半截拷贝残留会出现这种形态）。
+        if (parsed.id !== entry.name) {
+          this.options.onWarn?.(engineMsg('core.backup.dirNameIdMismatch', { dir: entry.name, id: parsed.id }));
+          continue;
+        }
         if (parsed.pinned === true) continue; // 置顶快照豁免自动清理
-        if (referenced.has(parsed.id)) continue; // Phase 4 F3：recovery 引用豁免
-        metas.push({ id: parsed.id, createdAt: parsed.createdAt });
+        if (referenced.has(entry.name)) continue; // Phase 4 F3：recovery 引用豁免
+        metas.push({ id: entry.name, createdAt: parsed.createdAt });
       } catch {
         // 损坏 / 非快照目录：跳过（与 listSnapshots 语义一致）
       }
@@ -672,7 +702,7 @@ export class FileSnapshotStore implements SnapshotStore {
   async readBlob(id: string, blobPath: string): Promise<Uint8Array> {
     const target = path.join(this.snapshotDir(id), blobPath);
     const dir = this.options.dir;
-    if (!target.startsWith(dir)) throw new Error(`快照 blob 路径越界: ${blobPath}`);
+    if (!target.startsWith(dir)) throw new Error(engineMsg('core.backup.blobPathEscaped', { path: blobPath }));
     return fs.readFile(target);
   }
 
@@ -712,51 +742,51 @@ export interface SnapshotVerifyResult {
 export async function verifySnapshot(snapshotsDir: string, id: string): Promise<SnapshotVerifyResult> {
   const dir = path.join(snapshotsDir, id);
   if (!dir.startsWith(path.resolve(snapshotsDir) + path.sep)) {
-    return { ok: false, reason: '快照路径越界' };
+    return { ok: false, reason: engineMsg('core.backup.snapshotPathEscaped') };
   }
   let raw: string;
   try {
     raw = await fs.readFile(path.join(dir, 'snapshot.json'), 'utf8');
   } catch {
-    return { ok: false, reason: 'snapshot.json 缺失' };
+    return { ok: false, reason: engineMsg('core.backup.snapshotJsonMissing') };
   }
   const snapshot = parseJsonSafe(raw) as Snapshot;
   if (snapshot === null || typeof snapshot !== 'object' || typeof snapshot.id !== 'string' || snapshot.id === '') {
-    return { ok: false, reason: 'snapshot.json 非法' };
+    return { ok: false, reason: engineMsg('core.backup.snapshotJsonInvalid') };
   }
   if (snapshot.id !== id) {
-    return { ok: false, reason: 'snapshot.id 与目录不匹配' };
+    return { ok: false, reason: engineMsg('core.backup.snapshotIdDirMismatch') };
   }
   let manifestRaw: string;
   try {
     manifestRaw = await fs.readFile(path.join(dir, 'manifest.json'), 'utf8');
   } catch {
-    return { ok: false, reason: 'manifest.json 缺失' };
+    return { ok: false, reason: engineMsg('core.backup.manifestMissing') };
   }
   const manifest = parseJsonSafe(manifestRaw) as SnapshotManifest;
   if (manifest === null || typeof manifest !== 'object' || manifest.snapshotId !== id) {
-    return { ok: false, reason: 'manifest 非法或 snapshotId 不匹配' };
+    return { ok: false, reason: engineMsg('core.backup.manifestInvalid') };
   }
   // entryCount 匹配（manifest 声明条目数与实际一致，防计数篡改）
   if (typeof manifest.entryCount !== 'number' || manifest.entryCount !== snapshot.entries.length) {
-    return { ok: false, reason: 'manifest.entryCount 与 snapshot.entries 不一致（篡改）' };
+    return { ok: false, reason: engineMsg('core.backup.entryCountMismatch') };
   }
   // metadataHash 匹配（破坏性内容）
   if (computeMetadataHash(snapshot) !== manifest.metadataHash) {
-    return { ok: false, reason: 'metadataHash 不匹配（破坏性内容被篡改）' };
+    return { ok: false, reason: engineMsg('core.backup.metadataHashMismatch') };
   }
   // blob hashes 匹配 + 存在
   for (const [blobPath, expectedHash] of Object.entries(manifest.blobHashes)) {
     const target = path.join(dir, blobPath);
-    if (!target.startsWith(dir)) return { ok: false, reason: `blob 路径越界: ${blobPath}` };
+    if (!target.startsWith(dir)) return { ok: false, reason: engineMsg('core.backup.blobPathEscaped', { path: blobPath }) };
     let data: Uint8Array;
     try {
       data = await fs.readFile(target);
     } catch {
-      return { ok: false, reason: `blob 缺失: ${blobPath}` };
+      return { ok: false, reason: engineMsg('core.backup.blobMissing', { path: blobPath }) };
     }
     if (sha256Hex(data) !== expectedHash) {
-      return { ok: false, reason: `blob hash 不匹配: ${blobPath}` };
+      return { ok: false, reason: engineMsg('core.backup.blobHashMismatch', { path: blobPath }) };
     }
   }
   // Review C P2：snapshot.json 引用的每个 blob（entries.copiedTo / hostFileBackups.blobPath）都必须被 manifest 覆盖，
@@ -770,7 +800,7 @@ export async function verifySnapshot(snapshotsDir: string, id: string): Promise<
   }
   for (const relBlob of referencedBlobs) {
     if (!(relBlob in manifest.blobHashes)) {
-      return { ok: false, reason: `snapshot 引用的 blob 未在 manifest 中: ${relBlob}` };
+      return { ok: false, reason: engineMsg('core.backup.blobNotInManifest', { blob: relBlob }) };
     }
   }
   return { ok: true };

package/src/core/boot-rescue.ts

@@ -35,6 +35,7 @@ import path from 'node:path';
 
 import { atomicWriteFile } from '../utils/atomic-write.ts';
 import { sha256Hex } from '../utils/hashing.ts';
+import { engineMsg } from './messages-core.ts';
 
 /* ---------------------------------------------------------------- 常量 */
 
@@ -414,14 +415,14 @@ export interface RescueSelfMount {
 /** 救援模式 profile patch 的头注释（说明本文件被谁接管、bundle 层的实际状态）。 */
 const RESCUE_PATCH_HEADER_LINES = [
   '# dsh-config-manager RESCUE MODE',
-  '# 本文件（profile patch 层）已被救援模式接管；home patch 同时被置空。',
+  engineMsg('core.bootRescue.patchTakenOver'),
 ];
 
 /** 救援模式 profile patch 的头注释（按 bundle 处理方式给出准确说明，不得夸大能力）。 */
 function rescuePatchHeader(bundlesDisabled: boolean): string {
   const note = bundlesDisabled
-    ? '# dsh.profile.bundles 已被收窄为 DSH 核心与救援插件自身，被禁用的包同时已从 dependencies 临时摘除：其余用户插件本次启动不挂载。'
-    : '# 注意：dsh.profile.bundles 里的插件仍由 bundle 层挂载（本次只裁剪了不可解析的 bundle）。';
+    ? engineMsg('core.bootRescue.bundlesNarrowed')
+    : engineMsg('core.bootRescue.bundlesNote');
   return [...RESCUE_PATCH_HEADER_LINES, note, ''].join('\n');
 }
 

package/src/core/boot-safety.ts

@@ -23,6 +23,7 @@ import type { BundleResolver } from './boot-rescue.ts';
 import { BOOT_CRITICAL_RELS, profileCriticalRels } from './boot-paths.ts';
 import type { MsgFunc } from './messages.ts';
 import { zhMsg } from './messages.ts';
+import { engineMsg } from './messages-core.ts';
 
 /** 审计问题 id（稳定；测试与 UI 判定用，展示文本一律走 msg）。 */
 export type BootSafetyIssueId =
@@ -167,7 +168,7 @@ export async function auditBootSafety(deps: BootSafetyDeps): Promise<BootSafetyR
           // 只剔除「不可解析且非核心」的条目：其余条目（含解析不出的核心项）原样保留
           const drop = new Set(prunable.map((p) => p.name))
           const next = (Array.isArray(bundles) ? bundles : []).filter((b) => !(typeof b === 'string' && drop.has(b))) as string[]
-          if (!writeBundles(pkg, next)) throw new Error('dsh.profile.bundles 不是数组或结构异常')
+          if (!writeBundles(pkg, next)) throw new Error(engineMsg('core.bootSafety.bundlesNotArray'))
           await deps.writeText(pkgRel, JSON.stringify(pkg, null, 2) + '\n')
           written = true
         } catch (err) {