dsh-config-manager 0.1.71 → 0.1.72

package/lib/core/backup-plan.js

@@ -32,6 +32,8 @@
  *    目标越出 homeDir 或断链的链接跳过但**写进 warnings**——绝不静默少收内容；
  *    普通目录**超过层级上限**同样留痕（cli-F2），且告警措辞按**真实来源**分派（t37：链接类 vs 目录超深）；
  *  - 命中 `isReservedInternalRel` 的内部命名空间（locks/snapshots/transactions…）跳过；
+ *  - 运行时依赖目录 node_modules（任意深度）**整棵跳过**（issue #76：与 plugins 分区的 npm pack 同口径，
+ *    依赖树可由包内 package.json / lock 重建），跳过了哪些目录、各多少文件一律写进 warnings；
  *  - `pluginFiles`（`dsh-ssh.json` 等第三方插件自有文件）**默认不收**：该分区与 GUI
  *    侧同为 deviceSpecific「任意文件直通、无内容过滤」，`dsh-ssh.json` 里是明文主机
  *    密码——必须由用户显式 `--sections pluginFiles` 选中，并附带显式告警
@@ -39,6 +41,7 @@
  *
  * 零 DSH 运行时依赖：仅 `node:fs/promises` + `node:path` + 本仓库零依赖模块。
  */
+import { engineMsg } from './messages-core.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { listRecursiveFollowingLinks } from '../utils/recursive-walk.js';
@@ -110,7 +113,7 @@ const SECTION_SPECS = {
         files: ['dsh-ssh.json', 'pet.json'],
         dirs: ['plugin-config'],
         label: 'Plugin Files',
-        risk: '第三方插件自有文件不受控（dsh-ssh.json 内含明文主机密码等），仅在你确认内容后才应纳入备份',
+        get risk() { return engineMsg('core.backupPlan.pluginFilesRisk'); },
     },
     // adapters/self.ts（baseDir='dsh-config-manager'，SELF_CONFIG_FILES 白名单）
     self: {
@@ -134,13 +137,16 @@ const SECTION_SPECS = {
  * 跳过原因；而 `too-deep` 自 cli-F2 起对**普通目录**同样会记录（此前只有链接超深才记）—— 整块内容被
  * 深度上限裁掉时若仍写成「链接未进备份」，用户看到的原因就与真实来源（目录层级超出上限）不符。
  * 措辞里**不编具体层数**：上限常量住在 utils/recursive-walk.ts，本模块不 import 它的私有常量。
+ *
+ * 路径**不叠加分区前缀**：内核返回的 `s.path` 已是 homeDir 相对路径（含分区目录），再加一层
+ * 会打印成 `skills/skills/...`（真机规模探针实测），与相邻的「目录读取失败」行口径也不一致。
  */
-function skippedLinkWarning(label, s) {
-    const at = `${label}/${s.path}（${s.reason}）`;
+function skippedLinkWarning(s) {
+    const at = engineMsg('core.backupPlan.pathWithReason', { path: s.path, reason: s.reason });
     if (s.reason === 'too-deep') {
-        return `层级超过上限未进备份（目录或链接目标超出深度上限） / nesting limit exceeded, content NOT in this backup: ${at}`;
+        return engineMsg('core.backupPlan.tooDeep', { at });
     }
-    return `链接未进备份 / link NOT in this backup: ${at}`;
+    return engineMsg('core.backupPlan.linkSkipped', { at });
 }
 /**
  * 递归列出目录下全部普通文件（**相对 homeDir** 的 posix 路径，已排序）；目录不存在 → 空。
@@ -149,16 +155,23 @@ function skippedLinkWarning(label, s) {
  * 并把「跟随了多少链接」「哪些链接/目录没进来（及原因）」写进 warnings。
  * 旧实现遇到链接目录直接跳过且零告警，用户拿到的是「成功但缺斤少两」的备份。
  */
-async function listFilesRecursive(dirAbs, homeDir, warnings, label) {
+async function listFilesRecursive(dirAbs, homeDir, warnings) {
     const listing = await listRecursiveFollowingLinks(dirAbs, homeDir);
     for (const s of listing.skippedLinks) {
-        warnings.push(skippedLinkWarning(label, s));
+        warnings.push(skippedLinkWarning(s));
     }
     for (const dir of listing.unreadableDirs) {
-        warnings.push(`目录读取失败，其内容未进备份 / directory unreadable, content NOT in this backup: ${dir}`);
+        warnings.push(engineMsg('core.backupPlan.dirUnreadable', { dir }));
+    }
+    // issue #76：运行时依赖目录整棵跳过（内容未进备份）——必须可见，绝不静默。
+    for (const dep of listing.skippedDepDirs) {
+        const files = dep.files === null
+            ? engineMsg('core.backupPlan.countNotMeasured')
+            : engineMsg('core.backupPlan.fileCount', { count: dep.files });
+        warnings.push(engineMsg('core.backupPlan.depDirSkipped', { path: dep.path, files }));
     }
     if (listing.followedLinks > 0) {
-        warnings.push(`已跟随 ${listing.followedLinks} 个链接目录收集内容 / followed ${listing.followedLinks} linked director(ies)`);
+        warnings.push(engineMsg('core.backupPlan.followedLinks', { count: listing.followedLinks }));
     }
     return listing.paths;
 }
@@ -171,15 +184,15 @@ function toRelativePath(baseDir, homeRel) {
 }
 /** `--sections` 取值校验：返回选中分区或可读错误（未知 id 一律拒绝并列出合法值） */
 export function parseSectionsArg(raw) {
-    const parts = raw.split(/[,，\s]+/).filter((p) => p !== '');
+    const parts = raw.split(/[,\uFF0C\s]+/).filter((p) => p !== '');
     if (parts.length === 0) {
-        return { ok: false, error: '`--sections` 缺值 / missing value for `--sections`' };
+        return { ok: false, error: engineMsg('core.backupPlan.sectionsMissingValue') };
     }
     const unknown = parts.filter((p) => !OFFLINE_BACKUP_SECTIONS.includes(p));
     if (unknown.length > 0) {
         return {
             ok: false,
-            error: `未知分区 / unknown section(s): ${unknown.join(', ')}（可用 / available: ${OFFLINE_BACKUP_SECTIONS.join(', ')}）`,
+            error: engineMsg('core.backupPlan.unknownSections', { unknown: unknown.join(', '), available: OFFLINE_BACKUP_SECTIONS.join(', ') }),
         };
     }
     // 去重并保持声明顺序，保证产物可复现
@@ -207,7 +220,7 @@ export async function collectBackupEntries(homeDir, only = []) {
         let excluded = 0;
         const push = (zipName, data) => {
             if (!isPathSafe(zipName)) {
-                warnings.push(`跳过不安全条目名 / unsafe entry name skipped: ${zipName}`);
+                warnings.push(engineMsg('core.backupPlan.unsafeEntryName', { name: zipName }));
                 excluded += 1;
                 return;
             }
@@ -229,7 +242,7 @@ export async function collectBackupEntries(homeDir, only = []) {
             catch (err) {
                 // 不存在 → 静默跳过（按需创建的文件，如 dsh-ssh.json）
                 if (err.code !== 'ENOENT') {
-                    warnings.push(`探测失败 / stat failed: ${norm}（${err instanceof Error ? err.message : String(err)}）`);
+                    warnings.push(engineMsg('core.backupPlan.statFailed', { path: norm, reason: err instanceof Error ? err.message : String(err) }));
                 }
                 return;
             }
@@ -242,7 +255,7 @@ export async function collectBackupEntries(homeDir, only = []) {
                 push(`${prefix}${toRelativePath(spec.baseDir, norm)}`, new Uint8Array(data));
             }
             catch (err) {
-                warnings.push(`读取失败 / read failed: ${norm}（${err instanceof Error ? err.message : String(err)}）`);
+                warnings.push(engineMsg('core.backupPlan.readFailed', { path: norm, reason: err instanceof Error ? err.message : String(err) }));
             }
         };
         // 1) 固定文件（存在才收）
@@ -251,7 +264,7 @@ export async function collectBackupEntries(homeDir, only = []) {
         // 2) 递归目录（跟随 junction/符号链接；未跟随的链接与不可读目录写进 warnings）
         for (const dirRel of spec.dirs ?? []) {
             const dirAbs = path.join(homeDir, ...normalizePath(dirRel).split('/'));
-            const rels = await listFilesRecursive(dirAbs, homeDir, warnings, normalizePath(dirRel));
+            const rels = await listFilesRecursive(dirAbs, homeDir, warnings);
             for (const homeRel of rels)
                 await consider(homeRel);
         }
@@ -264,7 +277,7 @@ export async function collectBackupEntries(homeDir, only = []) {
         }
         else {
             empty.push(sectionId);
-            warnings.push(`分区无内容，未写入 / section empty, skipped: ${sectionId}`);
+            warnings.push(engineMsg('core.backupPlan.sectionEmpty', { section: sectionId }));
         }
     }
     return { entries, sections, warnings, included, empty };

package/lib/core/backup-verify.js

@@ -28,6 +28,7 @@
  *    （实测 `verifyChecksums` 只调用 `map.get()`，不会整体物化 Map）。
  *    对 MB 级的 DSH 配置备份完全可接受。
  */
+import { engineMsg } from './messages-core.js';
 import fs from 'node:fs/promises';
 import { verifyChecksums } from '../utils/hashing.js';
 import { isENOENT } from '../utils/guards.js';
@@ -114,7 +115,7 @@ export async function verifyBackupZip(zipPath) {
     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;
@@ -122,11 +123,11 @@ export async function verifyBackupZip(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);
     }
     /** 已知字节数后的骨架（后续阶段失败时保留体积信息） */
@@ -137,7 +138,7 @@ export async function verifyBackupZip(zipPath) {
         /* ---------------- 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');
         }
         let archive;
@@ -145,7 +146,7 @@ export async function verifyBackupZip(zipPath) {
             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();
@@ -154,12 +155,12 @@ export async function verifyBackupZip(zipPath) {
             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;
@@ -168,7 +169,7 @@ export async function verifyBackupZip(zipPath) {
         }
         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;
@@ -176,7 +177,7 @@ export async function verifyBackupZip(zipPath) {
             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 ?? {})
@@ -187,12 +188,12 @@ export async function verifyBackupZip(zipPath) {
         });
         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;
@@ -201,7 +202,7 @@ export async function verifyBackupZip(zipPath) {
         }
         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');
         }
         // 4a. 完整性比对：**复用官方 verifyChecksums**（与导出侧 buildChecksums 同源同口径），
@@ -209,7 +210,7 @@ export async function verifyBackupZip(zipPath) {
         const unreadableNames = new Set();
         const unreadable = [];
         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);
@@ -219,10 +220,10 @@ export async function verifyBackupZip(zipPath) {
         // 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
@@ -230,7 +231,7 @@ export async function verifyBackupZip(zipPath) {
             .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 声明包含的分区在归档内应有对应条目
         for (const id of sections) {
@@ -238,31 +239,31 @@ export async function verifyBackupZip(zipPath) {
             const jsonPath = SECTION_JSON_PATHS[id];
             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/lib/core/backup.d.ts

@@ -144,6 +144,11 @@ export interface FileSnapshotStoreOptions {
      * 未注入 → `fallbackPruneSelector`（只按 keepLast，等价既有 FIFO；分层字段被忽略 = 保守少删）。
      */
     pruneSelector?: PruneSelector;
+    /**
+     * 诊断回调（可选）：保留清理**被放弃**或失败时的可见线索。
+     * 缺省 = 不记录（不改变行为）；宿主接 `host.log.warn` —— 「这轮为什么没清理」必须能查。
+     */
+    onWarn?: (message: string) => void;
 }
 /** 文件快照存储：<dir>/<id>/snapshot.json + <dir>/<id>/blobs/* */
 export declare class FileSnapshotStore implements SnapshotStore {

package/lib/core/backup.js

@@ -5,6 +5,7 @@
  * 快照不保存 credential 值（DSH 永不回读值）——credential 条目只记 existed 标志，
  * 回滚时 existed=true 的条目如实标记「值需人工补录」。
  */
+import { engineMsg } from './messages-core.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
@@ -60,8 +61,11 @@ async function backupHostFiles(ctx, blobs) {
             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 });
@@ -73,8 +77,10 @@ async function backupHostFiles(ctx, blobs) {
             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;
@@ -98,7 +104,7 @@ const FILE_BASES = {
 // 其它分区语义处理」同类缺陷）。注册表新增文件类分区时若忘了在这里补，进程启动即失败。
 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 }));
     }
 }
 /**
@@ -257,7 +263,7 @@ async function engineSnapshotEntry(ctx, target) {
         case 'secrets':
             // secrets 已注册但**没有 adapter、也没有 ZIP 内分区 JSON**（凭据值走独立加密容器 secrets.enc）。
             // 任何计划项都不应以它为快照目标 —— 显式报错，而不是落到 default 分支。
-            throw new Error('secrets 分区没有 adapter / 无分区载荷，不应作为快照目标（凭据值走独立加密容器，绝不进快照）');
+            throw new Error(engineMsg('core.backup.secretsSectionNotSnapshotTarget'));
         default: {
             // 编译期穷举断言：SectionId 的每一项都已被上面的 case 处理 → 此处 target.adapter 收窄为 never。
             // 新增分区若忘了在这里实现快照语义，tsc 会直接报错（不再依赖人肉核对清单）。
@@ -265,8 +271,7 @@ async function engineSnapshotEntry(ctx, target) {
             // 运行期（只可能来自运行期强转：被篡改的 plan / 旧 journal 反序列化）：**显式报错**。
             // 旧实现在这里静默返回 settingsNamespace 条目（连 existed 都没有）→ 回滚把该目标当「原本不存在」
             // 而不做任何补偿：该分区的写入永远撤不掉，报告却仍说「已快照、可回滚」（审计 core-flow#F-10）。
-            throw new Error(`快照不支持分区「${String(unhandled)}」：它未在 schema/section-registry.ts 注册（或缺少快照实现）；`
-                + '拒绝按其它分区语义静默记录（那会让该分区的写入无法回滚）');
+            throw new Error(engineMsg('core.backup.sectionUnsupported', { section: String(unhandled) }));
         }
     }
 }
@@ -405,7 +410,7 @@ export class FileSnapshotStore {
     async writeBlob(dir, blobPath, data, hashes) {
         const target = path.join(dir, blobPath);
         if (!target.startsWith(dir))
-            throw new Error(`快照 blob 路径越界: ${blobPath}`);
+            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);
@@ -429,7 +434,7 @@ export class FileSnapshotStore {
         // 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' };
@@ -439,7 +444,9 @@ export class FileSnapshotStore {
             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;
     }
@@ -480,7 +487,19 @@ export class FileSnapshotStore {
     async prune() {
         const dir = this.options.dir;
         const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-        const referenced = await this.options.referencedSnapshotIds?.().catch(() => new Set()) ?? new Set();
+        // F3：被未收敛 journal 引用的快照**绝不自动清理**。判据是「读不到 ≠ 没有引用」——
+        // 引用提供者抛错时**放弃本轮清理**，绝不按空集合继续删：一次瞬时 IO 错就可能删掉
+        // 事故恢复唯一的回滚点（那是 SAFE MODE 的唯一证据）。此前这里是 `.catch(() => new Set())`。
+        let referenced = new Set();
+        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())
@@ -494,11 +513,18 @@ export class FileSnapshotStore {
                 const parsed = parseJsonSafe(await fs.readFile(path.join(dir, entry.name, 'snapshot.json'), 'utf8'));
                 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))
+                if (referenced.has(entry.name))
                     continue; // Phase 4 F3：recovery 引用豁免
-                metas.push({ id: parsed.id, createdAt: parsed.createdAt });
+                metas.push({ id: entry.name, createdAt: parsed.createdAt });
             }
             catch {
                 // 损坏 / 非快照目录：跳过（与 listSnapshots 语义一致）
@@ -528,7 +554,7 @@ export class FileSnapshotStore {
         const target = path.join(this.snapshotDir(id), blobPath);
         const dir = this.options.dir;
         if (!target.startsWith(dir))
-            throw new Error(`快照 blob 路径越界: ${blobPath}`);
+            throw new Error(engineMsg('core.backup.blobPathEscaped', { path: blobPath }));
         return fs.readFile(target);
     }
     /** 标记快照生命周期状态：重写 <dir>/<id>/snapshot.json（保留其余字段）。 */
@@ -559,55 +585,55 @@ export function computeMetadataHash(snapshot) {
 export async function verifySnapshot(snapshotsDir, id) {
     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;
     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);
     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;
     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);
     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}` };
+            return { ok: false, reason: engineMsg('core.backup.blobPathEscaped', { path: blobPath }) };
         let data;
         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 覆盖，
@@ -623,7 +649,7 @@ export async function verifySnapshot(snapshotsDir, id) {
     }
     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/lib/core/boot-rescue.js

@@ -34,6 +34,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { atomicWriteFile } from '../utils/atomic-write.js';
 import { sha256Hex } from '../utils/hashing.js';
+import { engineMsg } from './messages-core.js';
 /* ---------------------------------------------------------------- 常量 */
 /** 默认备份目录（相对 homeDir 的 posix 路径；backupDir 缺省时使用） */
 const DEFAULT_BACKUP_DIR_REL = 'dsh-config-manager/transactions/rescue-backups';
@@ -340,13 +341,13 @@ async function readRescueState(backupDir) {
 /** 救援模式 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) {
     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');
 }
 /** 单引号 YAML 标量（按 YAML 规则把 `'` 转义为 `''`）。 */

package/lib/core/boot-safety.js

@@ -21,6 +21,7 @@
 import { RESCUE_KEEP_BUNDLE_PREFIXES, computeSafeBundles } from './boot-rescue.js';
 import { BOOT_CRITICAL_RELS, profileCriticalRels } from './boot-paths.js';
 import { zhMsg } from './messages.js';
+import { engineMsg } from './messages-core.js';
 /** 可解析性检查的目标（.json → JSON.parse；.yaml/.yml → 注入的 parseYaml）。 */
 function parseKind(rel) {
     if (rel.endsWith('.json'))
@@ -118,7 +119,7 @@ export async function auditBootSafety(deps) {
                     const drop = new Set(prunable.map((p) => p.name));
                     const next = (Array.isArray(bundles) ? bundles : []).filter((b) => !(typeof b === 'string' && drop.has(b)));
                     if (!writeBundles(pkg, next))
-                        throw new Error('dsh.profile.bundles 不是数组或结构异常');
+                        throw new Error(engineMsg('core.bootSafety.bundlesNotArray'));
                     await deps.writeText(pkgRel, JSON.stringify(pkg, null, 2) + '\n');
                     written = true;
                 }